sapiopycommons 2024.10.14a341__py3-none-any.whl → 2024.10.25a345__py3-none-any.whl

sapiopycommons/chem/Molecules.py

@@ -231,7 +231,7 @@ def mol_to_sapio_substance(mol: Mol, include_stereoisomers=False,
     indigo_mol.aromatize()
     if enhanced_stereo:
         # Remove enhanced stereo layer when generating InChI as the stereo hash is generated separately for reg.
-        mol_copy: Mol = Chem.MolFromMolBlock(Chem.MolToMolBlock(mol))
+        mol_copy: Mol = Chem.Mol(mol)
         Chem.CanonicalizeEnhancedStereo(mol_copy)
         molecule["inchi"] = Chem.MolToInchi(mol_copy)
         molecule["inchiKey"] = Chem.MolToInchiKey(mol_copy)

sapiopycommons/customreport/column_builder.py

@@ -52,9 +52,9 @@ class ColumnBuilder:
         :param field: The field name to return the type of.
         :return: The field type of the given field name.
         """
-        # Check if the field name is a system field. If it us, use the field type defined in this file.
+        # Check if the field name is a system field. If it is, use the field type defined in this file.
         field_name: str = AliasUtil.to_data_field_name(field)
         if field_name in SYSTEM_FIELDS:
             return SYSTEM_FIELDS.get(field_name)
         # Otherwise, check if the field type can be found from the wrapper.
-        return AliasUtil.to_field_type(field_name, data_type)
+        return AliasUtil.to_field_type(field, data_type)

sapiopycommons/datatype/pseudo_data_types.py

@@ -0,0 +1,440 @@
+from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
+from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrapperField
+
+
+class ActiveTaskPseudoDef:
+    DATA_TYPE_NAME: str = "ActiveTask"
+    ACTIVE_TASK_ID__FIELD_NAME = WrapperField("ActiveTaskId", FieldType.LONG)
+    ACTIVE_WORKFLOW_ID__FIELD_NAME = WrapperField("ActiveWorkflowId", FieldType.LONG)
+    DATE_EDITED__FIELD_NAME = WrapperField("DateEdited", FieldType.DATE)
+    EDITED_BY__FIELD_NAME = WrapperField("EditedBy", FieldType.STRING)
+    STATUS__FIELD_NAME = WrapperField("Status", FieldType.ENUM)
+    TASK_USAGE_ID__FIELD_NAME = WrapperField("TaskUsageId", FieldType.LONG)
+
+
+class ActiveWorkflowPseudoDef:
+    DATA_TYPE_NAME: str = "ActiveWorkflow"
+    ACTIVE_WORKFLOW_ID__FIELD_NAME = WrapperField("ActiveWorkflowId", FieldType.LONG)
+    CREATED_BY__FIELD_NAME = WrapperField("CreatedBy", FieldType.STRING)
+    DATE_CREATED__FIELD_NAME = WrapperField("DateCreated", FieldType.DATE)
+    DATE_EDITED__FIELD_NAME = WrapperField("DateEdited", FieldType.STRING)
+    EDITED_BY__FIELD_NAME = WrapperField("EditedBy", FieldType.STRING)
+    ESTIMATED_ATTACHMENTS__FIELD_NAME = WrapperField("EstimatedAttachments", FieldType.LONG)
+    NAME__FIELD_NAME = WrapperField("Name", FieldType.STRING)
+    RELATED_RECORD_ID__FIELD_NAME = WrapperField("RelatedRecordId", FieldType.LONG)
+    STATUS__FIELD_NAME = WrapperField("Status", FieldType.ENUM)
+    WORKFLOW_ID__FIELD_NAME = WrapperField("WorkflowId", FieldType.LONG)
+
+
+class AuditLogPseudoDef:
+    DATA_TYPE_NAME: str = "AuditLog"
+    DATA_FIELD_NAME__FIELD_NAME = WrapperField("DataFieldName", FieldType.STRING)
+    DATA_TYPE_NAME__FIELD_NAME = WrapperField("DataTypeName", FieldType.STRING)
+    DESCRIPTION__FIELD_NAME = WrapperField("Description", FieldType.STRING)
+    EVENT_TYPE__FIELD_NAME = WrapperField("EventType", FieldType.ENUM)
+    FULL_NAME__FIELD_NAME = WrapperField("FullName", FieldType.STRING)
+    NEW_VALUE__FIELD_NAME = WrapperField("NewValue", FieldType.STRING)
+    ORIGINAL_VALUE__FIELD_NAME = WrapperField("OriginalValue", FieldType.STRING)
+    RECORD_ID__FIELD_NAME = WrapperField("RecordId", FieldType.LONG)
+    RECORD_NAME__FIELD_NAME = WrapperField("RecordName", FieldType.STRING)
+    TIME_STAMP__FIELD_NAME = WrapperField("TimeStamp", FieldType.DATE)
+    USER_COMMENT__FIELD_NAME = WrapperField("UserComment", FieldType.STRING)
+    USER_NAME__FIELD_NAME = WrapperField("UserName", FieldType.STRING)
+
+
+class DataFieldDefinitionPseudoDef:
+    DATA_TYPE_NAME: str = "DataFieldDefinition"
+    APPROVE_EDIT__FIELD_NAME = WrapperField("ApproveEdit", FieldType.BOOLEAN)
+    AUTO_CLEAR_FIELD_LIST__FIELD_NAME = WrapperField("AutoClearFieldList", FieldType.STRING)
+    AUTO_SORT__FIELD_NAME = WrapperField("AutoSort", FieldType.BOOLEAN)
+    COLOR_MAPPING_ID__FIELD_NAME = WrapperField("ColorMappingId", FieldType.LONG)
+    DATA_FIELD_NAME__FIELD_NAME = WrapperField("DataFieldName", FieldType.STRING)
+    DATA_FIELD_TAG__FIELD_NAME = WrapperField("DataFieldTag", FieldType.STRING)
+    DATA_FIELD_TYPE__FIELD_NAME = WrapperField("DataFieldType", FieldType.STRING)
+    DATA_TYPE_NAME__FIELD_NAME = WrapperField("DataTypeName", FieldType.STRING)
+    DECIMAL_DIGITS__FIELD_NAME = WrapperField("DecimalDigits", FieldType.INTEGER)
+    DEFAULT_VALUE__FIELD_NAME = WrapperField("DefaultValue", FieldType.STRING)
+    DEPENDENT_FIELDS__FIELD_NAME = WrapperField("Dependent_Fields", FieldType.STRING)
+    DESCRIPTION__FIELD_NAME = WrapperField("Description", FieldType.STRING)
+    DIRECT_EDIT__FIELD_NAME = WrapperField("DirectEdit", FieldType.BOOLEAN)
+    DISPLAY_NAME__FIELD_NAME = WrapperField("DisplayName", FieldType.STRING)
+    EDITABLE__FIELD_NAME = WrapperField("Editable", FieldType.BOOLEAN)
+    ENUM_VALUES__FIELD_NAME = WrapperField("EnumValues", FieldType.STRING)
+    FORM_COL__FIELD_NAME = WrapperField("FormCol", FieldType.SHORT)
+    FORM_COL_SPAN__FIELD_NAME = WrapperField("FormColSpan", FieldType.SHORT)
+    FORM_NAME__FIELD_NAME = WrapperField("FormName", FieldType.STRING)
+    HTML_EDITOR__FIELD_NAME = WrapperField("HtmlEditor", FieldType.BOOLEAN)
+    IDENTIFIER__FIELD_NAME = WrapperField("Identifier", FieldType.BOOLEAN)
+    INDEX_FOR_SEARCH__FIELD_NAME = WrapperField("IndexForSearch", FieldType.BOOLEAN)
+    LINK_OUT__FIELD_NAME = WrapperField("LinkOut", FieldType.BOOLEAN)
+    LINK_OUT_URL__FIELD_NAME = WrapperField("LinkOutUrl", FieldType.BOOLEAN)
+    MAX_LENGTH__FIELD_NAME = WrapperField("MaxLength", FieldType.INTEGER)
+    MAXIMUM_VALUE__FIELD_NAME = WrapperField("MaximumValue", FieldType.DOUBLE)
+    MINIMUM_VALUE__FIELD_NAME = WrapperField("MinimumValue", FieldType.DOUBLE)
+    MULT_SELECT__FIELD_NAME = WrapperField("MultSelect", FieldType.BOOLEAN)
+    NUM_LINES__FIELD_NAME = WrapperField("NumLines", FieldType.INTEGER)
+    REQUIRED__FIELD_NAME = WrapperField("Required", FieldType.BOOLEAN)
+    SORT_KEY__FIELD_NAME = WrapperField("SortKey", FieldType.BOOLEAN)
+    STATIC_DATE__FIELD_NAME = WrapperField("StaticDate", FieldType.BOOLEAN)
+    UNIQUE_VALUE__FIELD_NAME = WrapperField("UniqueValue", FieldType.BOOLEAN)
+    VISIBLE__FIELD_NAME = WrapperField("Visible", FieldType.BOOLEAN)
+    WORKFLOW_ONLY_EDITING__FIELD_NAME = WrapperField("WorkflowOnlyEditing", FieldType.BOOLEAN)
+
+
+class DataTypeDefinitionPseudoDef:
+    DATA_TYPE_NAME: str = "DataTypeDefinition"
+    ADDABLE__FIELD_NAME = WrapperField("Addable", FieldType.BOOLEAN)
+    ATTACHMENT__FIELD_NAME = WrapperField("Attachment", FieldType.BOOLEAN)
+    ATTACHMENT_TYPE__FIELD_NAME = WrapperField("AttachmentType", FieldType.STRING)
+    DATA_TYPE_TAG__FIELD_NAME = WrapperField("DATA_TYPE_TAG", FieldType.STRING)
+    DATA_TYPE_ID__FIELD_NAME = WrapperField("DataTypeId", FieldType.LONG)
+    DATA_TYPE_NAME__FIELD_NAME = WrapperField("DataTypeName", FieldType.STRING)
+    DELETABLE__FIELD_NAME = WrapperField("Deletable", FieldType.BOOLEAN)
+    DESCRIPTION__FIELD_NAME = WrapperField("Description", FieldType.STRING)
+    DISPLAY_NAME__FIELD_NAME = WrapperField("DisplayName", FieldType.STRING)
+    EXTENSION_TYPE__FIELD_NAME = WrapperField("ExtensionType", FieldType.BOOLEAN)
+    GROUP_ADDABLE__FIELD_NAME = WrapperField("GroupAddable", FieldType.BOOLEAN)
+    HIDE_DATA_RECORDS__FIELD_NAME = WrapperField("HideDataRecords", FieldType.BOOLEAN)
+    HIGH_VOLUME__FIELD_NAME = WrapperField("HighVolume", FieldType.BOOLEAN)
+    IS_HIDE_IN_MOBILE__FIELD_NAME = WrapperField("IS_HIDE_IN_MOBILE", FieldType.BOOLEAN)
+    IS_HVDT_ON_SAVE_ENABLED__FIELD_NAME = WrapperField("IS_HVDT_ON_SAVE_ENABLED", FieldType.BOOLEAN)
+    IS_PUBLIC_ATTACHMENT__FIELD_NAME = WrapperField("IS_PUBLIC_ATTACHMENT", FieldType.BOOLEAN)
+    ICON_COLOR__FIELD_NAME = WrapperField("IconColor", FieldType.STRING)
+    ICON_NAME__FIELD_NAME = WrapperField("IconName", FieldType.STRING)
+    IMPORTABLE__FIELD_NAME = WrapperField("Importable", FieldType.BOOLEAN)
+    IS_ACTIVE__FIELD_NAME = WrapperField("IsActive", FieldType.BOOLEAN)
+    IS_HIDDEN__FIELD_NAME = WrapperField("IsHidden", FieldType.BOOLEAN)
+    MAX_TABLE_ROW_COUNT__FIELD_NAME = WrapperField("MaxTableRowCount", FieldType.LONG)
+    PLURAL_DISPLAY_NAME__FIELD_NAME = WrapperField("PluralDisplayName", FieldType.STRING)
+    RECORD_ASSIGNABLE__FIELD_NAME = WrapperField("RecordAssignable", FieldType.BOOLEAN)
+    RECORD_IMAGE_ASSIGNABLE__FIELD_NAME = WrapperField("RecordImageAssignable", FieldType.BOOLEAN)
+    RECORD_IMAGE_MANUALLY_ADDABLE__FIELD_NAME = WrapperField("RecordImageManuallyAddable", FieldType.BOOLEAN)
+    REMOVABLE__FIELD_NAME = WrapperField("Removable", FieldType.BOOLEAN)
+    RESTRICTED__FIELD_NAME = WrapperField("Restricted", FieldType.BOOLEAN)
+    SHOW_ON_HOME_SCREEN__FIELD_NAME = WrapperField("ShowOnHomeScreen", FieldType.BOOLEAN)
+    SHOW_SUB_TABLES__FIELD_NAME = WrapperField("ShowSubTables", FieldType.BOOLEAN)
+    SHOW_TABS__FIELD_NAME = WrapperField("ShowTabs", FieldType.BOOLEAN)
+    SINGLE_PARENT__FIELD_NAME = WrapperField("SingleParent", FieldType.BOOLEAN)
+    UNDER_CONTAINER__FIELD_NAME = WrapperField("UnderContainer", FieldType.BOOLEAN)
+
+
+class EnbDataTypeDefinitionPseudoDef:
+    DATA_TYPE_NAME: str = "EnbDataTypeDefinition"
+    DATA_TYPE_ID__FIELD_NAME = WrapperField("DataTypeId", FieldType.LONG)
+    DATA_TYPE_NAME__FIELD_NAME = WrapperField("DataTypeName", FieldType.STRING)
+    DESCRIPTION__FIELD_NAME = WrapperField("Description", FieldType.STRING)
+    DISPLAY_NAME__FIELD_NAME = WrapperField("DisplayName", FieldType.STRING)
+    ENB_DATA_TYPE_NAME__FIELD_NAME = WrapperField("EnbDataTypeName", FieldType.STRING)
+    ICON_COLOR__FIELD_NAME = WrapperField("IconColor", FieldType.STRING)
+    ICON_NAME__FIELD_NAME = WrapperField("IconName", FieldType.STRING)
+    NOTEBOOK_EXPERIMENT_ID__FIELD_NAME = WrapperField("Notebook_Experiment_ID", FieldType.LONG)
+    PLURAL_DISPLAY_NAME__FIELD_NAME = WrapperField("PluralDisplayName", FieldType.STRING)
+
+
+class EnbEntryPseudoDef:
+    DATA_TYPE_NAME: str = "EnbEntry"
+    APPROVAL_DUE_DATE__FIELD_NAME = WrapperField("ApprovalDueDate", FieldType.DATE)
+    COLUMN_ORDER__FIELD_NAME = WrapperField("ColumnOrder", FieldType.INTEGER)
+    COLUMN_SPAN__FIELD_NAME = WrapperField("ColumnSpan", FieldType.INTEGER)
+    CREATED_BY__FIELD_NAME = WrapperField("CreatedBy", FieldType.STRING)
+    DATA_TYPE_NAME__FIELD_NAME = WrapperField("DataTypeName", FieldType.STRING)
+    DATE_CREATED__FIELD_NAME = WrapperField("DateCreated", FieldType.DATE)
+    DEPENDENT_ENTRY_ID_LIST__FIELD_NAME = WrapperField("DependentEntryIdList", FieldType.STRING)
+    ENTRY_DESCRIPTION__FIELD_NAME = WrapperField("EntryDescription", FieldType.STRING)
+    ENTRY_HEIGHT__FIELD_NAME = WrapperField("EntryHeight", FieldType.INTEGER)
+    ENTRY_ID__FIELD_NAME = WrapperField("EntryId", FieldType.LONG)
+    ENTRY_NAME__FIELD_NAME = WrapperField("EntryName", FieldType.STRING)
+    ENTRY_ORDER__FIELD_NAME = WrapperField("EntryOrder", FieldType.INTEGER)
+    ENTRY_REQUIRES_E_SIGN__FIELD_NAME = WrapperField("EntryRequiresESign", FieldType.BOOLEAN)
+    ENTRY_SINGLETON_ID__FIELD_NAME = WrapperField("EntrySingletonId", FieldType.STRING)
+    ENTRY_STATUS__FIELD_NAME = WrapperField("EntryStatus", FieldType.STRING)
+    ENTRY_TYPE__FIELD_NAME = WrapperField("EntryType", FieldType.STRING)
+    EXPERIMENT_ID__FIELD_NAME = WrapperField("ExperimentId", FieldType.LONG)
+    HAS_COMMENTS__FIELD_NAME = WrapperField("HasComments", FieldType.BOOLEAN)
+    IS_CREATED_FROM_TEMPLATE__FIELD_NAME = WrapperField("IsCreatedFromTemplate", FieldType.BOOLEAN)
+    IS_REQUIRED_ENTRY__FIELD_NAME = WrapperField("IsRequiredEntry", FieldType.BOOLEAN)
+    IS_SHOWN_IN_TEMPLATE__FIELD_NAME = WrapperField("IsShownInTemplate", FieldType.BOOLEAN)
+    LAST_MODIFIED_BY__FIELD_NAME = WrapperField("LastModifiedBy", FieldType.STRING)
+    LAST_MODIFIED_DATE__FIELD_NAME = WrapperField("LastModifiedDate", FieldType.DATE)
+    RELATED_ENTRY_ID_LIST__FIELD_NAME = WrapperField("RelatedEntryIdList", FieldType.STRING)
+    REQUIRES_GRABBER_PLUGIN__FIELD_NAME = WrapperField("RequriesGrabberPlugin", FieldType.BOOLEAN)
+    SOURCE_ENTRY_ID__FIELD_NAME = WrapperField("SourceEntryId", FieldType.LONG)
+    SUBMITTED_BY__FIELD_NAME = WrapperField("SubmittedBy", FieldType.STRING)
+    SUBMITTED_DATE__FIELD_NAME = WrapperField("SubmittedDate", FieldType.DATE)
+    TAB_ID__FIELD_NAME = WrapperField("TabId", FieldType.LONG)
+    TEMPLATE_ITEM_FULFILLED_TIME_STAMP__FIELD_NAME = WrapperField("TemplateItemFulfilledTimeStamp", FieldType.LONG)
+
+
+class EnbEntryOptionsPseudoDef:
+    DATA_TYPE_NAME: str = "EnbEntryOptions"
+    ENTRY_ID__FIELD_NAME = WrapperField("EntryId", FieldType.LONG)
+    ENTRY_OPTION_VALUE__FIELD_NAME = WrapperField("EntryOptionValue", FieldType.STRING)
+    ENTRY_OPTION_KEY__FIELD_NAME = WrapperField("EntryOptionkey", FieldType.STRING)
+
+
+class ExperimentEntryRecordPseudoDef:
+    DATA_TYPE_NAME: str = "ExperimentEntryRecord"
+    ENTRY_ID__FIELD_NAME = WrapperField("EntryId", FieldType.LONG)
+    RECORD_ID__FIELD_NAME = WrapperField("RecordId", FieldType.LONG)
+
+
+class LimsUserPseudoDef:
+    DATA_TYPE_NAME: str = "LimsUser"
+    API_USER__FIELD_NAME = WrapperField("ApiUser", FieldType.BOOLEAN)
+    EMAIL_ADDRESS__FIELD_NAME = WrapperField("EmailAddress", FieldType.STRING)
+    FIRST_NAME__FIELD_NAME = WrapperField("FirstName", FieldType.STRING)
+    LAST_NAME__FIELD_NAME = WrapperField("LastName", FieldType.STRING)
+    MIDDLE_NAME__FIELD_NAME = WrapperField("MiddleName", FieldType.STRING)
+    PWD_EXPIRE_DATE__FIELD_NAME = WrapperField("PwdExpireDate", FieldType.DATE)
+    PWD_EXPIRE_INTERVAL__FIELD_NAME = WrapperField("PwdExpireInterval", FieldType.INTEGER)
+    USER_NAME__FIELD_NAME = WrapperField("UserName", FieldType.STRING)
+
+
+class NotebookExperimentPseudoDef:
+    DATA_TYPE_NAME: str = "NotebookExperiment"
+    ACCESS_LEVEL__FIELD_NAME = WrapperField("AccessLevel", FieldType.STRING)
+    APPROVAL_DUE_DATE__FIELD_NAME = WrapperField("ApprovalDueDate", FieldType.DATE)
+    CREATED_BY__FIELD_NAME = WrapperField("CreatedBy", FieldType.STRING)
+    DATE_CREATED__FIELD_NAME = WrapperField("DateCreated", FieldType.DATE)
+    DESCRIPTION__FIELD_NAME = WrapperField("Description", FieldType.STRING)
+    EXPERIMENT_ID__FIELD_NAME = WrapperField("ExperimentId", FieldType.LONG)
+    EXPERIMENT_NAME__FIELD_NAME = WrapperField("ExperimentName", FieldType.STRING)
+    EXPERIMENT_OWNER__FIELD_NAME = WrapperField("ExperimentOwner", FieldType.STRING)
+    EXPERIMENT_RECORD_ID__FIELD_NAME = WrapperField("ExperimentRecordId", FieldType.LONG)
+    EXPERIMENT_TYPE_NAME__FIELD_NAME = WrapperField("ExperimentTypeName", FieldType.STRING)
+    IS_ACTIVE__FIELD_NAME = WrapperField("IsActive", FieldType.BOOLEAN)
+    IS_MODIFIABLE__FIELD_NAME = WrapperField("IsModifiable", FieldType.BOOLEAN)
+    IS_TEMPLATE__FIELD_NAME = WrapperField("IsTemplate", FieldType.BOOLEAN)
+    IS_PROTOCOL_TEMPLATE__FIELD_NAME = WrapperField("Is_Protocol_Template", FieldType.BOOLEAN)
+    LAST_MODIFIED_BY__FIELD_NAME = WrapperField("LastModifiedBy", FieldType.STRING)
+    LAST_MODIFIED_DATE__FIELD_NAME = WrapperField("LastModifiedDate", FieldType.DATE)
+    SOURCE_TEMPLATE_ID__FIELD_NAME = WrapperField("SourceTemplateId", FieldType.LONG)
+    STATUS__FIELD_NAME = WrapperField("Status", FieldType.STRING)
+
+
+class NotebookExperimentOptionPseudoDef:
+    DATA_TYPE_NAME: str = "NotebookExperimentOption"
+    EXPERIMENT_ID__FIELD_NAME = WrapperField("ExperimentId", FieldType.LONG)
+    OPTION_KEY__FIELD_NAME = WrapperField("OptionKey", FieldType.STRING)
+    OPTION_VALUE__FIELD_NAME = WrapperField("OptionValue", FieldType.STRING)
+
+
+class SystemLogPseudoDef:
+    DATA_TYPE_NAME: str = "SystemLog"
+    DATA_FIELD_NAME__FIELD_NAME = WrapperField("DataFieldName", FieldType.STRING)
+    DATA_TYPE_NAME__FIELD_NAME = WrapperField("DataTypeName", FieldType.STRING)
+    DESCRIPTION__FIELD_NAME = WrapperField("Description", FieldType.STRING)
+    EVENT_ID__FIELD_NAME = WrapperField("EventId", FieldType.LONG)
+    EVENT_TYPE__FIELD_NAME = WrapperField("EventType", FieldType.STRING)
+    FULL_NAME__FIELD_NAME = WrapperField("FullName", FieldType.STRING)
+    NEW_VALUE__FIELD_NAME = WrapperField("NewValue", FieldType.STRING)
+    ORIGINAL_VALUE__FIELD_NAME = WrapperField("OriginalValue", FieldType.STRING)
+    RECORD_ID__FIELD_NAME = WrapperField("RecordId", FieldType.LONG)
+    RECORD_NAME__FIELD_NAME = WrapperField("RecordName", FieldType.STRING)
+    TIMESTAMP__FIELD_NAME = WrapperField("Timestamp", FieldType.DATE)
+    USER_COMMENT__FIELD_NAME = WrapperField("UserComment", FieldType.STRING)
+    USERNAME__FIELD_NAME = WrapperField("Username", FieldType.STRING)
+
+
+class SystemObjectChangeLogPseudoDef:
+    DATA_TYPE_NAME: str = "System_Object_Change_Log"
+    ALT_ID__FIELD_NAME = WrapperField("Alt_Id", FieldType.STRING)
+    ATTRIBUTE_NAME__FIELD_NAME = WrapperField("Attribute_Name", FieldType.STRING)
+    CHANGE_TYPE__FIELD_NAME = WrapperField("Change_Type", FieldType.STRING)
+    DATA_FIELD_NAME__FIELD_NAME = WrapperField("Data_Field_Name", FieldType.STRING)
+    DATA_TYPE_NAME__FIELD_NAME = WrapperField("Data_Type_Name", FieldType.STRING)
+    EVENT_ID__FIELD_NAME = WrapperField("Event_Id", FieldType.STRING)
+    NEW_VALUE__FIELD_NAME = WrapperField("New_Value", FieldType.STRING)
+    OBJECT_ID__FIELD_NAME = WrapperField("Object_Id", FieldType.STRING)
+    OBJECT_TYPE__FIELD_NAME = WrapperField("Object_Type", FieldType.STRING)
+    OLD_VALUE__FIELD_NAME = WrapperField("Old_Value", FieldType.STRING)
+    TIMESTAMP__FIELD_NAME = WrapperField("Timestamp", FieldType.DATE)
+    USERNAME__FIELD_NAME = WrapperField("Username", FieldType.STRING)
+
+
+class TaskPseudoDef:
+    DATA_TYPE_NAME: str = "Task"
+    ATTACHMENT_REQUIRED__FIELD_NAME = WrapperField("AttachmentRequired", FieldType.BOOLEAN)
+    CREATED_BY__FIELD_NAME = WrapperField("CreatedBy", FieldType.STRING)
+    CUSTOM_ACTION__FIELD_NAME = WrapperField("CustomAction", FieldType.STRING)
+    DATA_TYPE_NAME_LIST__FIELD_NAME = WrapperField("DataTypeNameList", FieldType.STRING)
+    DATE_CREATED__FIELD_NAME = WrapperField("DateCreated", FieldType.DATE)
+    DATE_EDITED__FIELD_NAME = WrapperField("DateEdited", FieldType.DATE)
+    DISPLAY_TYPE__FIELD_NAME = WrapperField("DisplayType", FieldType.ENUM)
+    EDITED_BY__FIELD_NAME = WrapperField("EditedBy", FieldType.STRING)
+    INPUT_DATA_TYPE_NAME__FIELD_NAME = WrapperField("InputDataTypeName", FieldType.STRING)
+    IS_TEMPLATE__FIELD_NAME = WrapperField("IsTemplate", FieldType.BOOLEAN)
+    LONG_DESC__FIELD_NAME = WrapperField("LongDesc", FieldType.STRING)
+    MENU_TASK_ID__FIELD_NAME = WrapperField("MenuTaskId", FieldType.ENUM)
+    NAME__FIELD_NAME = WrapperField("Name", FieldType.STRING)
+    SHORT_DESC__FIELD_NAME = WrapperField("ShortDesc", FieldType.STRING)
+    TASK_ID__FIELD_NAME = WrapperField("TaskId", FieldType.LONG)
+    TASK_VERSION__FIELD_NAME = WrapperField("TaskVersion", FieldType.LONG)
+    TEMPLATE_TASK_ID__FIELD_NAME = WrapperField("TemplateTaskId", FieldType.LONG)
+    TYPE__FIELD_NAME = WrapperField("Type", FieldType.ENUM)
+
+
+class TaskAttachmentPseudoDef:
+    DATA_TYPE_NAME: str = "TaskAttachment"
+    ACTIVE_TASK_ID__FIELD_NAME = WrapperField("ActiveTaskId", FieldType.LONG)
+    RECORD_ID__FIELD_NAME = WrapperField("RecordId", FieldType.LONG)
+
+
+class TaskOptionPseudoDef:
+    DATA_TYPE_NAME: str = "TaskOption"
+    OPTION_KEY__FIELD_NAME = WrapperField("OptionKey", FieldType.STRING)
+    OPTION_VALUE__FIELD_NAME = WrapperField("OptionValue", FieldType.STRING)
+    TASK_ID__FIELD_NAME = WrapperField("TaskId", FieldType.LONG)
+
+
+class TaskUsagePseudoDef:
+    DATA_TYPE_NAME: str = "TaskUsage"
+    FORCE_ATTACH__FIELD_NAME = WrapperField("ForceAttach", FieldType.BOOLEAN)
+    IS_TEMPLATE__FIELD_NAME = WrapperField("IsTemplate", FieldType.BOOLEAN)
+    TASK_ID__FIELD_NAME = WrapperField("TaskId", FieldType.LONG)
+    TASK_ORDER__FIELD_NAME = WrapperField("TaskOrder", FieldType.INTEGER)
+    TASK_USAGE_ID__FIELD_NAME = WrapperField("TaskUsageId", FieldType.LONG)
+    WORKFLOW_ID__FIELD_NAME = WrapperField("WorkflowId", FieldType.LONG)
+
+
+class VeloxWebhookPseudoDef:
+    DATA_TYPE_NAME: str = "VELOXWEBHOOK"
+    CUSTOM_PLUGIN_POINT__FIELD_NAME = WrapperField("CUSTOM_PLUGIN_POINT", FieldType.STRING)
+    DATA_TYPE_NAME_SET__FIELD_NAME = WrapperField("DATA_TYPE_NAME_SET", FieldType.STRING)
+    DESCRIPTION__FIELD_NAME = WrapperField("DESCRIPTION", FieldType.STRING)
+    ENB_ENTRY_TYPE__FIELD_NAME = WrapperField("ENB_ENTRY_TYPE", FieldType.STRING)
+    EXPERIMENT_ENTRY_NAME__FIELD_NAME = WrapperField("EXPERIMENT_ENTRY_NAME", FieldType.STRING)
+    GUID__FIELD_NAME = WrapperField("GUID", FieldType.STRING)
+    ICON_COLOR__FIELD_NAME = WrapperField("ICON_COLOR", FieldType.STRING)
+    ICON_GUID__FIELD_NAME = WrapperField("ICON_GUID", FieldType.STRING)
+    IS_RETRY_ON_FAILURE__FIELD_NAME = WrapperField("IS_RETRY_ON_FAILURE", FieldType.BOOLEAN)
+    IS_TRANSACTIONAL__FIELD_NAME = WrapperField("IS_TRANSACTIONAL", FieldType.BOOLEAN)
+    LINE_1_TEXT__FIELD_NAME = WrapperField("LINE_1_TEXT", FieldType.STRING)
+    LINE_2_TEXT__FIELD_NAME = WrapperField("LINE_2_TEXT", FieldType.STRING)
+    PLUGIN_ORDER__FIELD_NAME = WrapperField("PLUGIN_ORDER", FieldType.INTEGER)
+    PLUGIN_POINT__FIELD_NAME = WrapperField("PLUGIN_POINT", FieldType.STRING)
+    SECTION_NAME_PATH__FIELD_NAME = WrapperField("SECTION_NAME_PATH", FieldType.STRING)
+    TEMPLATE_NAME__FIELD_NAME = WrapperField("TEMPLATE_NAME", FieldType.STRING)
+    WEBHOOK_URL__FIELD_NAME = WrapperField("WEBHOOK_URL", FieldType.STRING)
+
+
+class VeloxWebhookExecutionPseudoDef:
+    DATA_TYPE_NAME: str = "VELOXWEBHOOK_EXECUTION"
+    EXECUTION_TIMESTAMP__FIELD_NAME = WrapperField("EXECUTION_TIMESTAMP", FieldType.DATE)
+    EXECUTION_USERNAME__FIELD_NAME = WrapperField("EXECUTION_USERNAME", FieldType.STRING)
+    GUID__FIELD_NAME = WrapperField("GUID", FieldType.STRING)
+    LAST_ATTEMPT_NUMBER__FIELD_NAME = WrapperField("LAST_ATTEMPT_NUMBER", FieldType.INTEGER)
+    LAST_ATTEMPT_RESULT__FIELD_NAME = WrapperField("LAST_ATTEMPT_RESULT", FieldType.STRING)
+    REQUEST_BODY__FIELD_NAME = WrapperField("REQUEST_BODY", FieldType.STRING)
+    WEBHOOK_GUID__FIELD_NAME = WrapperField("WEBHOOK_GUID", FieldType.STRING)
+    WEBHOOK_URL__FIELD_NAME = WrapperField("WEBHOOK_URL", FieldType.STRING)
+
+
+class VeloxWebhookExecutionAttemptPseudoDef:
+    DATA_TYPE_NAME: str = "VELOXWEBHOOK_EXECUTION_ATTEMPT"
+    ATTEMPT_DURATION__FIELD_NAME = WrapperField("ATTEMPT_DURATION", FieldType.INTEGER)
+    ATTEMPT_NUMBER__FIELD_NAME = WrapperField("ATTEMPT_NUMBER", FieldType.INTEGER)
+    ATTEMPT_RESULT__FIELD_NAME = WrapperField("ATTEMPT_RESULT", FieldType.STRING)
+    ATTEMPT_TIMESTAMP__FIELD_NAME = WrapperField("ATTEMPT_TIMESTAMP", FieldType.DATE)
+    EXECUTION_GUID__FIELD_NAME = WrapperField("EXECUTION_GUID", FieldType.STRING)
+    GUID__FIELD_NAME = WrapperField("GUID", FieldType.STRING)
+    RESPONSE_BODY__FIELD_NAME = WrapperField("RESPONSE_BODY", FieldType.STRING)
+    RESPONSE_CODE__FIELD_NAME = WrapperField("RESPONSE_CODE", FieldType.INTEGER)
+    WEBHOOK_GUID__FIELD_NAME = WrapperField("WEBHOOK_GUID", FieldType.STRING)
+    WEBHOOK_URL__FIELD_NAME = WrapperField("WEBHOOK_URL", FieldType.STRING)
+
+
+class VeloxWebhookExecutionLogPseudoDef:
+    DATA_TYPE_NAME: str = "VELOXWEBHOOK_EXECUTION_LOG"
+    ATTEMPT_GUID__FIELD_NAME = WrapperField("ATTEMPT_GUID", FieldType.STRING)
+    LOG_LEVEL__FIELD_NAME = WrapperField("LOG_LEVEL", FieldType.STRING)
+    LOG_LINE_NUM__FIELD_NAME = WrapperField("LOG_LINE_NUM", FieldType.INTEGER)
+    LOG_MESSAGE__FIELD_NAME = WrapperField("LOG_MESSAGE", FieldType.STRING)
+    LOG_TIMESTAMP__FIELD_NAME = WrapperField("LOG_TIMESTAMP", FieldType.DATE)
+
+
+class VeloxRuleCostPseudoDef:
+    DATA_TYPE_NAME: str = "VELOX_RULE_COST"
+    ACTION_COST__FIELD_NAME = WrapperField("ACTION_COST", FieldType.LONG)
+    ACTION_COUNT__FIELD_NAME = WrapperField("ACTION_COUNT", FieldType.LONG)
+    ANCESTOR_DESCENDANT_COUNT__FIELD_NAME = WrapperField("ANCESTOR_DESCENDANT_COUNT", FieldType.LONG)
+    PARENT_CHILD_COUNT__FIELD_NAME = WrapperField("PARENT_CHILD_COUNT", FieldType.LONG)
+    PROCESSING_TIME__FIELD_NAME = WrapperField("PROCESSING_TIME", FieldType.LONG)
+    RULE_GUID__FIELD_NAME = WrapperField("RULE_GUID", FieldType.STRING)
+    SOURCE_RECORD_COUNT__FIELD_NAME = WrapperField("SOURCE_RECORD_COUNT", FieldType.LONG)
+    TIMESTAMP__FIELD_NAME = WrapperField("TIMESTAMP", FieldType.DATE)
+    TOTAL_COST__FIELD_NAME = WrapperField("TOTAL_COST", FieldType.LONG)
+    TRANSACTION_GUID__FIELD_NAME = WrapperField("TRANSACTION_GUID", FieldType.STRING)
+    USERNAME__FIELD_NAME = WrapperField("USERNAME", FieldType.STRING)
+
+
+class VeloxConversationPseudoDef:
+    DATA_TYPE_NAME: str = "VeloxConversation"
+    CONVERSATION_DESCRIPTION__FIELD_NAME = WrapperField("ConversationDescription", FieldType.STRING)
+    CONVERSATION_GUID__FIELD_NAME = WrapperField("ConversationGuid", FieldType.STRING)
+    CONVERSATION_NAME__FIELD_NAME = WrapperField("ConversationName", FieldType.STRING)
+    CREATED_BY__FIELD_NAME = WrapperField("CreatedBy", FieldType.STRING)
+    DATE_CREATED__FIELD_NAME = WrapperField("DateCreated", FieldType.DATE)
+    SERVER_PLUGIN_PATH__FIELD_NAME = WrapperField("Server_Plugin_Path", FieldType.STRING)
+
+
+class VeloxConversationMessagePseudoDef:
+    DATA_TYPE_NAME: str = "VeloxConversationMessage"
+    CONVERSATION_GUID__FIELD_NAME = WrapperField("ConversationGuid", FieldType.STRING)
+    MESSAGE__FIELD_NAME = WrapperField("Message", FieldType.STRING)
+    MESSAGE_GUID__FIELD_NAME = WrapperField("MessageGuid", FieldType.STRING)
+    MESSAGE_SENDER__FIELD_NAME = WrapperField("MessageSender", FieldType.STRING)
+    MESSAGE_TIMESTAMP__FIELD_NAME = WrapperField("MessageTimestamp", FieldType.DATE)
+
+
+class VeloxScriptPseudoDef:
+    DATA_TYPE_NAME: str = "VeloxScript"
+    CODE__FIELD_NAME = WrapperField("Code", FieldType.STRING)
+    CREATED_BY__FIELD_NAME = WrapperField("CreatedBy", FieldType.STRING)
+    DATE_CREATED__FIELD_NAME = WrapperField("DateCreated", FieldType.LONG)
+    LAST_MODIFIED_BY__FIELD_NAME = WrapperField("LastModifiedBy", FieldType.STRING)
+    LAST_MODIFIED_DATE__FIELD_NAME = WrapperField("LastModifiedDate", FieldType.LONG)
+    PATH__FIELD_NAME = WrapperField("Path", FieldType.STRING)
+    PLUGIN_DESCRIPTION__FIELD_NAME = WrapperField("PluginDescription", FieldType.STRING)
+    PLUGIN_LINE1_TEXT__FIELD_NAME = WrapperField("PluginLine1Text", FieldType.STRING)
+    PLUGIN_LINE2_TEXT__FIELD_NAME = WrapperField("PluginLine2Text", FieldType.STRING)
+    PLUGIN_ORDER__FIELD_NAME = WrapperField("PluginOrder", FieldType.INTEGER)
+    PLUGIN_POINT__FIELD_NAME = WrapperField("PluginPoint", FieldType.STRING)
+    PROJECT_GUID__FIELD_NAME = WrapperField("ProjectGuid", FieldType.STRING)
+    SCRIPT_GUID__FIELD_NAME = WrapperField("ScriptGuid", FieldType.STRING)
+
+
+class VeloxScriptProjectPseudoDef:
+    DATA_TYPE_NAME: str = "VeloxScriptProject"
+    CLASS_PATH__FIELD_NAME = WrapperField("ClassPath", FieldType.STRING)
+    CREATED_BY__FIELD_NAME = WrapperField("CreatedBy", FieldType.STRING)
+    DATE_CREATED__FIELD_NAME = WrapperField("DateCreated", FieldType.LONG)
+    DEPLOYMENT_OUT_OF_DATE__FIELD_NAME = WrapperField("DeploymentOutOfDate", FieldType.BOOLEAN)
+    DESCRIPTION__FIELD_NAME = WrapperField("Description", FieldType.STRING)
+    PROJECT_GUID__FIELD_NAME = WrapperField("ProjectGuid", FieldType.STRING)
+    PROJECT_NAME__FIELD_NAME = WrapperField("ProjectName", FieldType.STRING)
+    SCRIPT_LANGUAGE__FIELD_NAME = WrapperField("ScriptLanguage", FieldType.STRING)
+
+
+class WorkflowPseudoDef:
+    DATA_TYPE_NAME: str = "Workflow"
+    ALL_ACCESS__FIELD_NAME = WrapperField("AllAccess", FieldType.BOOLEAN)
+    CATEGORY__FIELD_NAME = WrapperField("Category", FieldType.STRING)
+    CREATED_BY__FIELD_NAME = WrapperField("CreatedBy", FieldType.STRING)
+    DATE_CREATED__FIELD_NAME = WrapperField("DateCreated", FieldType.DATE)
+    DATE_EDITED__FIELD_NAME = WrapperField("DateEdited", FieldType.DATE)
+    DIRECT_LAUNCH__FIELD_NAME = WrapperField("DirectLaunch", FieldType.BOOLEAN)
+    EDITED_BY__FIELD_NAME = WrapperField("EditedBy", FieldType.STRING)
+    IS_TEMPLATE__FIELD_NAME = WrapperField("IsTemplate", FieldType.BOOLEAN)
+    LONG_DESC__FIELD_NAME = WrapperField("LongDesc", FieldType.STRING)
+    NAME__FIELD_NAME = WrapperField("Name", FieldType.STRING)
+    SHORT_DESC__FIELD_NAME = WrapperField("ShortDesc", FieldType.STRING)
+    WORKFLOW_ID__FIELD_NAME = WrapperField("WorkflowId", FieldType.LONG)
+    WORKFLOW_VERSION__FIELD_NAME = WrapperField("WorkflowVersion", FieldType.LONG)
+
+
+class WorkflowOptionPseudoDef:
+    DATA_TYPE_NAME: str = "WorkflowOption"
+    OPTION_KEY__FIELD_NAME = WrapperField("OptionKey", FieldType.STRING)
+    OPTION_VALUE__FIELD_NAME = WrapperField("OptionValue", FieldType.STRING)
+    WORKFLOW_ID__FIELD_NAME = WrapperField("WorkflowId", FieldType.LONG)

sapiopycommons/eln/experiment_handler.py

@@ -23,6 +23,7 @@ from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelInst
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 from sapiopylib.rest.utils.recordmodel.properties import Child
 
+from sapiopycommons.eln.experiment_report_util import ExperimentReportUtil
 from sapiopycommons.general.aliases import AliasUtil, SapioRecord, ExperimentIdentifier, UserIdentifier, \
     DataTypeIdentifier, RecordModel
 from sapiopycommons.general.exceptions import SapioException
@@ -67,9 +68,9 @@ class ExperimentHandler:
     """Whether this ExperimentHandler has queried the system for all steps in the experiment."""
     __steps: dict[str, ElnEntryStep]
     """Steps from this experiment. All steps are cached the first time any individual step is accessed."""
-    __step_options: dict[ElnEntryStep, dict[str, str]]
-    """Entry options for each step in this experiment. Only cached for each individual step when they are first accessed.
-    The cache is updated whenever the entry options for a step are changed by this handler."""
+    __step_options: dict[int, dict[str, str]]
+    """Entry options for each step in this experiment. All entry options are cached the first time any individual step's
+    options are queried. The cache is updated whenever the entry options for a step are changed by this handler."""
 
     # Constants
     __ENTRY_COMPLETE_STATUSES = [ExperimentEntryStatus.Completed, ExperimentEntryStatus.CompletedApproved]
@@ -549,6 +550,39 @@ class ExperimentHandler:
         data_type: str = AliasUtil.to_data_type_name(data_type)
         return [x for x in all_steps if data_type in x.get_data_type_names()]
 
+    def get_step_by_option(self, key: str, value: str | None = None) -> ElnEntryStep:
+        """
+        Retrieve the step in this experiment that contains an entry option with the provided key and value.
+        Throws an exception if no entries or multiple entries in the experiment match.
+
+        :param key: The key of the entry option to match on.
+        :param value: The value of the entry option to match on. If not provided, then only matches on key.
+        :return: The entry in this experiment that matches the provided entry option key and value.
+        """
+        steps: list[ElnEntryStep] = self.get_steps_by_option(key, value)
+        count: int = len(steps)
+        if count != 1:
+            option = key + ("::" + value if value is not None else "")
+            raise SapioException(f"{('No' if count == 0 else 'Multiple')} entries in this experiment match the "
+                                 f"provided option: {option}")
+        return steps[0]
+
+    def get_steps_by_option(self, key: str, value: str | None = None) -> list[ElnEntryStep]:
+        """
+        Retrieve every step in this experiment that contains an entry option with the provided key and value.
+
+        :param key: The key of the entry option to match on.
+        :param value: The value of the entry option to match on. If not provided, then only matches on key.
+        :return: The entries in this experiment that match the provided entry option key and value.
+        """
+        ret_list: list[ElnEntryStep] = []
+        for step in self.get_all_steps():
+            options: dict[str, str] = self.get_step_options(step)
+            if key in options:
+                if value is None or options[key] == value:
+                    ret_list.append(step)
+        return ret_list
+
     def get_step_records(self, step: Step) -> list[DataRecord]:
         """
         Query for the data records for the given step. The returned records are not cached by the ExperimentHandler.
@@ -966,7 +1000,7 @@ class ExperimentHandler:
         if clear_template_item_fulfilled_timestamp is True:
             entry.template_item_fulfilled_timestamp = None
         if entry_options_map is not None:
-            self.__step_options.update({step: entry_options_map})
+            self.__step_options.update({step.get_id(): entry_options_map})
 
     def get_step_option(self, step: Step, option: str) -> str:
         """
@@ -996,8 +1030,8 @@ class ExperimentHandler:
         list of steps in the experiment and caches them.
 
         Getting the step options requires a webservice query, which is made the first time any step option
-        method is called for a specific step. The step options are cached so that subsequent calls of this
-        method for that step don't make a webservice call.
+        method is called for any step in this experiment. The step options are cached so that subsequent calls of this
+        method don't make a webservice call.
 
         :param step:
             The step to get the options of.
@@ -1005,7 +1039,10 @@ class ExperimentHandler:
             If given a name, throws an exception if no step of the given name exists in the experiment.
         :return: The map of options for the input step.
         """
-        return self.__get_step_options(step)
+        step = self.__to_eln_step(step)
+        if step not in self.__step_options:
+            self.__step_options.update(ExperimentReportUtil.get_experiment_entry_options(self.user, self.get_all_steps()))
+        return self.__step_options[step.get_id()]
 
     def add_step_options(self, step: Step, mapping: Mapping[str, str]):
         """
@@ -1175,16 +1212,3 @@ class ExperimentHandler:
             return self.__exp_options
         self.__exp_options = self.__eln_man.get_notebook_experiment_options(self.__exp_id)
         return self.__exp_options
-
-    def __get_step_options(self, step: Step) -> dict[str, str]:
-        """
-        Cache the options for the input step if they haven't been cached yet.
-
-        :return: The entry options for the input step.
-        """
-        step = self.__to_eln_step(step)
-        if step in self.__step_options:
-            return self.__step_options.get(step)
-        options: dict[str, str] = step.get_options()
-        self.__step_options.update({step: options})
-        return options

sapiopycommons/eln/experiment_report_util.py

@@ -1,16 +1,18 @@
+from sapiopylib.rest.ELNService import ElnManager
 from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
+from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment, ElnExperimentQueryCriteria
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
 from sapiopycommons.customreport.custom_report_builder import CustomReportBuilder
 from sapiopycommons.customreport.term_builder import TermBuilder
-from sapiopycommons.general.aliases import SapioRecord, UserIdentifier, AliasUtil
+from sapiopycommons.datatype.pseudo_data_types import EnbEntryOptionsPseudoDef, NotebookExperimentOptionPseudoDef, \
+    NotebookExperimentPseudoDef, ExperimentEntryRecordPseudoDef, EnbEntryPseudoDef
+from sapiopycommons.general.aliases import SapioRecord, UserIdentifier, AliasUtil, FieldValue, \
+    ExperimentEntryIdentifier, ExperimentIdentifier
 from sapiopycommons.general.custom_report_util import CustomReportUtil
 from sapiopycommons.recordmodel.record_handler import RecordHandler
 
-_NOTEBOOK_ID = "EXPERIMENTID"
-_RECORD_ID = "RECORDID"
-
 
 # FR-46908 - Provide a utility class that holds experiment related custom reports e.g. getting all the experiments
 # that given records were used in or getting all records of a datatype used in given experiments.
@@ -23,8 +25,8 @@ class ExperimentReportUtil:
         If a record wasn't used in any experiments then it will be mapped to an empty list.
 
         :param context: The current webhook context or a user object to send requests from.
-        :param records: a list of records of the same data type.
-        :return: a dictionary mapping each record to a list of ids of each experiment it was used in.
+        :param records: A list of records of the same data type.
+        :return: A dictionary mapping each record to a list of ids of each experiment it was used in.
         """
         if not records:
             return {}
@@ -38,24 +40,25 @@ class ExperimentReportUtil:
         id_to_record: dict[int, SapioRecord] = RecordHandler.map_by_id(records)
         record_to_exps: dict[SapioRecord, set[int]] = {record: set() for record in records}
         for row in rows:
-            record_id: int = row[_RECORD_ID]
-            exp_id: int = row[_NOTEBOOK_ID]
+            record_id: int = row["RecordId"]
+            exp_id: int = row[NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name]
             record = id_to_record[record_id]
             record_to_exps[record].add(exp_id)
 
         return {record: list(exps) for record, exps in record_to_exps.items()}
 
     @staticmethod
-    def map_experiments_to_records_of_type(context: UserIdentifier, exp_ids: list[int],
+    def map_experiments_to_records_of_type(context: UserIdentifier, exp_ids: list[ExperimentIdentifier],
                                            wrapper_type: type[WrappedType]) -> dict[int, list[WrappedType]]:
         """
-        Return a dictionary mapping each experiment id to a list of records of the given type that were used in each experiment.
-        If an experiment didn't use any records of the given type then it will be mapped to an empty list.
+        Return a dictionary mapping each experiment id to a list of records of the given type that were used in each
+        experiment. If an experiment didn't use any records of the given type then it will be mapped to an empty list.
 
         :param context: The current webhook context or a user object to send requests from.
-        :param exp_ids: a list of experiment ids. These are specifically the Notebook Experiment ids which can be found in the title of the experiment.
+        :param exp_ids: A list of experiment identifiers.
         :param wrapper_type: The record model wrapper to use, corresponds to which data type we will query for.
-        :return: a dictionary mapping each experiment id to a list of records of the given type that were used in that experiment.
+        :return: A dictionary mapping each experiment id to a list of records of the given type that were used in that
+            experiment.
         """
         if not exp_ids:
             return {}
@@ -64,20 +67,130 @@ class ExperimentReportUtil:
         record_handler = RecordHandler(user)
         data_type_name: str = wrapper_type.get_wrapper_data_type_name()
 
+        exp_ids: list[int] = AliasUtil.to_notebook_ids(exp_ids)
         rows = ExperimentReportUtil.__get_record_experiment_relation_rows(user, data_type_name, exp_ids=exp_ids)
-        record_ids: set[int] = {row[_RECORD_ID] for row in rows}
+        record_ids: set[int] = {row["RecordId"] for row in rows}
         records = record_handler.query_models_by_id(wrapper_type, record_ids)
 
         id_to_record: dict[int, WrappedType] = RecordHandler.map_by_id(records)
         exp_to_records: dict[int, set[SapioRecord]] = {exp: set() for exp in exp_ids}
         for row in rows:
-            record_id: int = row[_RECORD_ID]
-            exp_id: int = row[_NOTEBOOK_ID]
+            record_id: int = row["RecordId"]
+            exp_id: int = row[NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name]
             record = id_to_record[record_id]
             exp_to_records[exp_id].add(record)
 
         return {exp: list(records) for exp, records in exp_to_records.items()}
 
+    @staticmethod
+    def get_experiment_options(context: UserIdentifier, experiments: list[ExperimentIdentifier]) \
+            -> dict[int, dict[str, str]]:
+        """
+        Run a custom report to retrieve the experiment options for all the provided experiments. Effectively a batched
+        version of the get_notebook_experiment_options function of ElnManager.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param experiments: The experiment identifiers to retrieve the experiment options for.
+        :return: A dictionary mapping the notebook experiment ID to the options for that experiment.
+        """
+        exp_ids: list[int] = AliasUtil.to_notebook_ids(experiments)
+
+        report_builder = CustomReportBuilder(NotebookExperimentOptionPseudoDef.DATA_TYPE_NAME)
+        root = TermBuilder.is_term(NotebookExperimentOptionPseudoDef.DATA_TYPE_NAME,
+                                   NotebookExperimentOptionPseudoDef.EXPERIMENT_ID__FIELD_NAME,
+                                   exp_ids)
+        report_builder.set_root_term(root)
+        report_builder.add_column(NotebookExperimentOptionPseudoDef.EXPERIMENT_ID__FIELD_NAME)
+        report_builder.add_column(NotebookExperimentOptionPseudoDef.OPTION_KEY__FIELD_NAME)
+        report_builder.add_column(NotebookExperimentOptionPseudoDef.OPTION_VALUE__FIELD_NAME)
+        report = report_builder.build_report_criteria()
+
+        # Ensure that each experiment appears in the dictionary, even if it has no experiment options.
+        options: dict[int, dict[str, str]] = {x: {} for x in exp_ids}
+        results: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(context, report)
+        for row in results:
+            exp_id: int = row[NotebookExperimentOptionPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name]
+            key: str = row[NotebookExperimentOptionPseudoDef.OPTION_KEY__FIELD_NAME.field_name]
+            value: str = row[NotebookExperimentOptionPseudoDef.OPTION_VALUE__FIELD_NAME.field_name]
+            options[exp_id][key] = value
+        return options
+
+    @staticmethod
+    def get_experiment_entry_options(context: UserIdentifier, entries: list[ExperimentEntryIdentifier]) \
+            -> dict[int, dict[str, str]]:
+        """
+        Run a custom report to retrieve the entry options for all the provided entries. Effectively a batched
+        version of the get_experiment_entry_options function of ElnManager.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param entries: The experiment entry identifiers to retrieve the entry options for.
+        :return: A dictionary mapping the entry ID to the options for that entry.
+        """
+        entries: list[int] = AliasUtil.to_entry_ids(entries)
+        report_builder = CustomReportBuilder(EnbEntryOptionsPseudoDef.DATA_TYPE_NAME)
+        root = TermBuilder.is_term(EnbEntryOptionsPseudoDef.DATA_TYPE_NAME,
+                                   EnbEntryOptionsPseudoDef.ENTRY_ID__FIELD_NAME,
+                                   entries)
+        report_builder.set_root_term(root)
+        report_builder.add_column(EnbEntryOptionsPseudoDef.ENTRY_ID__FIELD_NAME)
+        report_builder.add_column(EnbEntryOptionsPseudoDef.ENTRY_OPTION_KEY__FIELD_NAME)
+        report_builder.add_column(EnbEntryOptionsPseudoDef.ENTRY_OPTION_VALUE__FIELD_NAME)
+        report = report_builder.build_report_criteria()
+
+        # Ensure that each entry appears in the dictionary, even if it has no entry options.
+        options: dict[int, dict[str, str]] = {x: {} for x in entries}
+        results: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(context, report)
+        for row in results:
+            entry_id: int = row[EnbEntryOptionsPseudoDef.ENTRY_ID__FIELD_NAME.field_name]
+            key: str = row[EnbEntryOptionsPseudoDef.ENTRY_OPTION_KEY__FIELD_NAME.field_name]
+            value: str = row[EnbEntryOptionsPseudoDef.ENTRY_OPTION_VALUE__FIELD_NAME.field_name]
+            options[entry_id][key] = value
+        return options
+
+    @staticmethod
+    def get_experiments_by_name(context: UserIdentifier, name: str) -> list[ElnExperiment]:
+        """
+        Run a custom report that retrieves every experiment in the system with a given name.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param name: The name of the experiment to query for.
+        :return: A list of every experiment in the system with a name that matches the input.
+        """
+        return ExperimentReportUtil.get_experiments_by_names(context, [name])[name]
+
+    @staticmethod
+    def get_experiments_by_names(context: UserIdentifier, names: list[str]) -> dict[str, list[ElnExperiment]]:
+        """
+        Run a custom report that retrieves every experiment in the system with a name from a list of names.
+
+        :param context: The current webhook context or a user object to send requests from.
+        :param names: The names of the experiment to query for.
+        :return: A dictionary mapping the experiment name to a list of every experiment in the system with that name.
+        """
+        user = AliasUtil.to_sapio_user(context)
+
+        report_builder = CustomReportBuilder(NotebookExperimentPseudoDef.DATA_TYPE_NAME)
+        report_builder.add_column(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME)
+        root = TermBuilder.is_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
+                                   NotebookExperimentPseudoDef.EXPERIMENT_NAME__FIELD_NAME,
+                                   names)
+        report_builder.set_root_term(root)
+
+        # Ensure that each entry appears in the dictionary, even if it has no experiments.
+        ret_val: dict[str, list[ElnExperiment]] = {x: [] for x in names}
+
+        exp_ids: list[int] = []
+        for row in CustomReportUtil.run_custom_report(user, report_builder.build_report_criteria()):
+            exp_ids.append(row[NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME.field_name])
+        if not exp_ids:
+            return ret_val
+
+        criteria = ElnExperimentQueryCriteria(notebook_experiment_id_white_list=exp_ids)
+        experiments: list[ElnExperiment] = ElnManager(user).get_eln_experiment_by_criteria(criteria)
+        for experiment in experiments:
+            ret_val.get(experiment.notebook_experiment_name).append(experiment)
+        return ret_val
+
     @staticmethod
     def __get_record_experiment_relation_rows(user: SapioUser, data_type_name: str, record_ids: list[int] | None = None,
                                               exp_ids: list[int] | None = None) -> list[dict[str, int]]:
@@ -88,30 +201,44 @@ class ExperimentReportUtil:
         assert (record_ids or exp_ids)
 
         if record_ids:
-            records_term = TermBuilder.is_term(data_type_name, "RECORDID", record_ids)
+            records_term = TermBuilder.is_term(data_type_name, "RecordId", record_ids)
         else:
             # Get all records of the given type
             records_term = TermBuilder.all_records_term(data_type_name)
 
         if exp_ids:
-            exp_term = TermBuilder.is_term("NOTEBOOKEXPERIMENT", "EXPERIMENTID", exp_ids)
+            exp_term = TermBuilder.is_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
+                                           NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
+                                           exp_ids)
         else:
             # Get all experiments
-            exp_term = TermBuilder.gte_term("NOTEBOOKEXPERIMENT", "EXPERIMENTID", "0")
+            exp_term = TermBuilder.gte_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
+                                            NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
+                                            0)
 
         root_term = TermBuilder.and_terms(records_term, exp_term)
 
         # Join records on the experiment entry records that correspond to them.
-        records_entry_join = TermBuilder.compare_is_term("EXPERIMENTENTRYRECORD", "RECORDID", data_type_name, "RECORDID")
+        records_entry_join = TermBuilder.compare_is_term(ExperimentEntryRecordPseudoDef.DATA_TYPE_NAME,
+                                                         ExperimentEntryRecordPseudoDef.RECORD_ID__FIELD_NAME,
+                                                         data_type_name,
+                                                         "RecordId")
         # Join entry records on the experiment entries they are in.
-        experiment_entry_enb_entry_join = TermBuilder.compare_is_term("ENBENTRY", "ENTRYID", "EXPERIMENTENTRYRECORD", "ENTRYID")
+        experiment_entry_enb_entry_join = TermBuilder.compare_is_term(EnbEntryPseudoDef.DATA_TYPE_NAME,
+                                                                      EnbEntryPseudoDef.ENTRY_ID__FIELD_NAME,
+                                                                      ExperimentEntryRecordPseudoDef.DATA_TYPE_NAME,
+                                                                      ExperimentEntryRecordPseudoDef.ENTRY_ID__FIELD_NAME)
         # Join entries on the experiments they are in.
-        enb_entry_experiment_join = TermBuilder.compare_is_term("NOTEBOOKEXPERIMENT", "EXPERIMENTID", "ENBENTRY", "EXPERIMENTID")
+        enb_entry_experiment_join = TermBuilder.compare_is_term(NotebookExperimentPseudoDef.DATA_TYPE_NAME,
+                                                                NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
+                                                                EnbEntryPseudoDef.DATA_TYPE_NAME,
+                                                                EnbEntryPseudoDef.EXPERIMENT_ID__FIELD_NAME)
 
         report_builder = CustomReportBuilder(data_type_name)
         report_builder.set_root_term(root_term)
-        report_builder.add_column("RECORDID", FieldType.LONG, data_type=data_type_name)
-        report_builder.add_column("EXPERIMENTID", FieldType.LONG, data_type="NOTEBOOKEXPERIMENT")
+        report_builder.add_column("RecordId", FieldType.LONG)
+        report_builder.add_column(NotebookExperimentPseudoDef.EXPERIMENT_ID__FIELD_NAME,
+                                  data_type=NotebookExperimentPseudoDef.DATA_TYPE_NAME)
         report_builder.add_join(records_entry_join)
         report_builder.add_join(experiment_entry_enb_entry_join)
         report_builder.add_join(enb_entry_experiment_join)

sapiopycommons/general/aliases.py

@@ -5,8 +5,9 @@ from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
 from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment
+from sapiopylib.rest.pojo.eln.ExperimentEntry import ExperimentEntry
 from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
-from sapiopylib.rest.utils.Protocols import ElnExperimentProtocol
+from sapiopylib.rest.utils.Protocols import ElnExperimentProtocol, ElnEntryStep
 from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedRecordModel, WrappedType, WrapperField
 
@@ -31,8 +32,10 @@ dictionaries.."""
 HasFieldWrappers = type[WrappedType] | WrappedRecordModel
 """An identifier for classes that have wrapper fields."""
 ExperimentIdentifier = ElnExperimentProtocol | ElnExperiment | int
-"""An ExperimentIdentifier is either an experiment protocol, experiment, or an integer for te experiment's notebook
+"""An ExperimentIdentifier is either an experiment protocol, experiment, or an integer for the experiment's notebook
 ID."""
+ExperimentEntryIdentifier = ElnEntryStep | ExperimentEntry | int
+"""An ExperimentEntryIdentifier is either an ELN entry step, experiment entry, or an integer for the entry's ID."""
 FieldMap = dict[str, FieldValue]
 """A field map is simply a dict of data field names to values. The purpose of aliasing this is to help distinguish
 any random dict in a webhook from one which is explicitly used for record fields."""
@@ -223,7 +226,51 @@ class AliasUtil:
         if isinstance(experiment, ElnExperiment):
             return experiment.notebook_experiment_id
         return experiment.get_id()
-    
+
+    @staticmethod
+    def to_notebook_ids(experiments: list[ExperimentIdentifier]) -> list[int]:
+        """
+        Convert a list of objects that identify ELN experiments to their notebook IDs.
+
+        :return: The list of notebook IDs for the experiment identifiers.
+        """
+        notebook_ids: list[int] = []
+        for experiment in experiments:
+            notebook_ids.append(AliasUtil.to_notebook_id(experiment))
+        return notebook_ids
+
+    @staticmethod
+    def to_entry_id(entry: ExperimentEntryIdentifier) -> int:
+        """
+        Convert an object that identifies an experiment entry to its entry ID.
+
+        :return: The entry ID for the entry identifier.
+        """
+        if isinstance(entry, int):
+            return entry
+        elif isinstance(entry, ExperimentEntry):
+            return entry.entry_id
+        elif isinstance(entry, ElnEntryStep):
+            return entry.get_id()
+        raise SapioException(f"Unrecognized entry identifier of type {type(entry)}")
+
+    @staticmethod
+    def to_entry_ids(entries: list[ExperimentEntryIdentifier]) -> list[int]:
+        """
+        Convert a list of objects that identify experiment entries to their entry IDs.
+
+        :return: The list of entry IDs for the entry identifiers.
+        """
+        entry_ids: list[int] = []
+        for entry in entries:
+            entry_ids.append(AliasUtil.to_entry_id(entry))
+        return entry_ids
+
     @staticmethod
     def to_sapio_user(context: UserIdentifier) -> SapioUser:
+        """
+        Convert an object that could be either a SapioUser or SapioWebhookContext to just a SapioUser.
+
+        :return: A SapioUser object.
+        """
         return context if isinstance(context, SapioUser) else context.user

sapiopycommons/general/audit_log.py

@@ -2,24 +2,13 @@ from enum import Enum
 
 from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReportCriteria
-from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
 
+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
 
-EVENTTYPE_COLUMN = "EVENTTYPE"
-TIMESTAMP_COLUMN = "TIMESTAMP"
-DATATYPENAME_COLUMN = "DATATYPENAME"
-RECORDID_COLUMN = "RECORDID"
-DESCRIPTION_COLUMN = "DESCRIPTION"
-USERNAME_COLUMN = "USERNAME"
-USERCOMMENT_COLUMN = "USERCOMMENT"
-RECORDNAME_COLUMN = "RECORDNAME"
-DATAFIELDNAME_COLUMN = "DATAFIELDNAME"
-ORIGINALVALUE_COLUMN = "ORIGINALVALUE"
-NEWVALUE_COLUMN = "NEWVALUE"
-
 
 class EventType(Enum):
     """An enum to represent the possible event type values with the event type column in the audit log table."""
@@ -39,7 +28,6 @@ class EventType(Enum):
 
 
 class AuditLogEntry:
-
     __event_type: EventType
     __date: int
     __data_type_name: str
@@ -97,40 +85,41 @@ class AuditLogEntry:
         return self.__new_value
 
     def __init__(self, report_row: dict[str, FieldValue]):
-        self.__event_type = EventType((report_row[EVENTTYPE_COLUMN]))
-        self.__date = report_row[TIMESTAMP_COLUMN]
-        self.__data_type_name = report_row[DATATYPENAME_COLUMN]
-        self.__record_id = report_row[RECORDID_COLUMN]
-        self.__description = report_row[DESCRIPTION_COLUMN]
-        self.__users_login_name = report_row[USERNAME_COLUMN]
-        self.__comment = report_row[USERCOMMENT_COLUMN]
-        self.__data_record_name = report_row[RECORDNAME_COLUMN]
-        self.__data_field_name = report_row[DATAFIELDNAME_COLUMN]
-        self.__original_value = report_row[ORIGINALVALUE_COLUMN]
-        self.__new_value = report_row[NEWVALUE_COLUMN]
-
-
-class AuditLog:
-    AUDIT_LOG_PSEUDO_DATATYPE: str = "AUDITLOG"
-    EVENT_TYPE: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, EVENTTYPE_COLUMN, FieldType.ENUM)
-    DATE: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, TIMESTAMP_COLUMN, FieldType.DATE)
-    DATA_TYPE_NAME: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, DATATYPENAME_COLUMN, FieldType.STRING)
-    RECORD_ID: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, RECORDID_COLUMN, FieldType.LONG)
-    DESCRIPTION: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, DESCRIPTION_COLUMN, FieldType.STRING)
-    USERS_LOGIN_NAME: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, USERNAME_COLUMN, FieldType.STRING)
-    COMMENT: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, USERCOMMENT_COLUMN, FieldType.STRING)
-    DATA_RECORD_NAME: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, RECORDNAME_COLUMN, FieldType.STRING)
-    DATA_FIELD_NAME: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, DATAFIELDNAME_COLUMN, FieldType.STRING)
-    ORIGINAL_VALUE: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, ORIGINALVALUE_COLUMN, FieldType.STRING)
-    NEW_VALUE: ReportColumn = ReportColumn(AUDIT_LOG_PSEUDO_DATATYPE, NEWVALUE_COLUMN, FieldType.STRING)
-
-    AUDIT_LOG_COLUMNS = [EVENT_TYPE, DATE, DATA_TYPE_NAME, RECORD_ID, DESCRIPTION, USERS_LOGIN_NAME, COMMENT,
-                         DATA_RECORD_NAME, DATA_FIELD_NAME, ORIGINAL_VALUE, NEW_VALUE]
+        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:
@@ -148,15 +137,19 @@ class AuditLog:
         # 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(AuditLog.AUDIT_LOG_PSEUDO_DATATYPE, RECORDID_COLUMN, record_ids)
+        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(AuditLog.AUDIT_LOG_PSEUDO_DATATYPE, DATAFIELDNAME_COLUMN, 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(AuditLog.AUDIT_LOG_COLUMNS, root_term)
+        return CustomReportCriteria(AuditLogUtil.report_columns(), root_term)
 
     def run_data_record_audit_log_report(self, records: list[RecordIdentifier],
                                          fields: list[FieldIdentifier] | None = None) \
@@ -172,7 +165,7 @@ class AuditLog:
         """
         fields: list[str] = AliasUtil.to_data_field_names(fields)
         # First, we must build our report criteria for running the Custom Report.
-        criteria = AuditLog.create_data_record_audit_log_report(records, fields)
+        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)

sapiopycommons/general/time_util.py

@@ -5,8 +5,6 @@ from datetime import datetime
 
 import pytz
 
-from sapiopycommons.general.exceptions import SapioException
-
 __timezone = None
 """The default timezone. Use TimeUtil.set_default_timezone in a global context before making use of TimeUtil."""
 
@@ -96,9 +94,10 @@ class TimeUtil:
         return TimeUtil.current_time(timezone).strftime(time_format)
 
     @staticmethod
-    def millis_to_format(millis: int, time_format: str, timezone: str | int = None) -> str:
+    def millis_to_format(millis: int, time_format: str, timezone: str | int = None) -> str | None:
         """
-        Convert the input time in milliseconds to the provided format.
+        Convert the input time in milliseconds to the provided format. If None is passed to the millis parameter,
+        None will be returned
 
         :param millis: The time in milliseconds to convert from.
         :param time_format: The format to display the input time in. Documentation for how the time formatting works
@@ -107,6 +106,9 @@ class TimeUtil:
             timezone variable set by the TimeUtil. A list of valid timezones can be found at
             https://en.wikipedia.org/wiki/List_of_tz_database_time_zones. May also accept a UTC offset in seconds.
         """
+        if millis is None:
+            return None
+
         tz = TimeUtil.__to_tz(timezone)
         return datetime.fromtimestamp(millis / 1000, tz).strftime(time_format)
 
@@ -141,39 +143,3 @@ class TimeUtil:
             return True
         except Exception:
             return False
-
-
-class DateRange:
-    start: int | None
-    end: int | None
-
-    @staticmethod
-    def from_string(value: str | None) -> DateRange:
-        """
-        Construct a DateRange object from a string. The field value of date range fields is a string of the form
-        <start timestamp>/<end timestamp>.
-
-        :param value: A date range field value.
-        :return: A DateRange object matching the input field value.
-        """
-        if not value:
-            return DateRange(None, None)
-        values: list[str] = value.split("/")
-        return DateRange(int(values[0]), int(values[1]))
-
-    def __init__(self, start: int | None, end: int | None):
-        """
-        :param start: The timestamp for the start of the date range.
-        :param end: The timestamp for the end of the date rate.
-        """
-        if (start and end is None) or (end and start is None):
-            raise SapioException("Both start and end values must be present in a date range.")
-        if start and end and end < start:
-            raise SapioException(f"End timestamp {end} is earlier than the start timestamp {start}.")
-        self.start = start
-        self.end = end
-
-    def __str__(self) -> str | None:
-        if not self.start and not self.end:
-            return None
-        return f"{self.start}/{self.end}"

sapiopycommons/sftpconnect/sftp_builder.py

@@ -0,0 +1,69 @@
+import io
+from enum import Enum
+
+import paramiko
+from paramiko import pkey
+from paramiko.sftp_client import SFTPClient
+from sapiopycommons.general.exceptions import SapioException
+
+
+class SFTPAuthMethod(Enum):
+    """
+    An enum being used to specify connection type to the target server.
+    """
+    PASSWORD = 0
+    """Connection is being done via Password."""
+    FILEPATH = 1
+    """Connection is being done using a private key file in the codebase."""
+    KEY_STRING = 2
+    """Connection is being done using a private key in string form."""
+
+
+class SFTPBuilder:
+    """
+    A class for making SFTP connections.
+    """
+
+    @staticmethod
+    def open_sftp(username: str, host: str, port: int, authentication: str,
+                  connection_type: SFTPAuthMethod = SFTPAuthMethod.PASSWORD) -> SFTPClient:
+        """
+        Builds a SFTP client from user input.
+
+        :param username: The username of the individual trying to connect to the target server.
+        :param host: The hostname/IP address of the target server.
+        :param port: The port number used to connect to the target server.
+        :param authentication: The string used to connect to the target server. This could hold a filepath, a password
+            or a private key in string form depending on the connection_type parameter.
+
+            If authentication is a private key string, they are generally formated like this:
+            -----BEGIN OPENSSH PRIVATE KEY-----\n
+            asdfh;hjadfh;jghajdg54646+5fasdfadlajklgajd'gj'ajg654564\n
+            asdkjfhj;kghj;ahj;wh41234hjadjkhhdsgadshjkdghjshdlsds468\n
+            ....
+
+        :param connection_type: This enum is used to specify how the connection to the target server is being made.
+            The options are:
+            (0) PASSWORD: This means that the authentication parameter contains a password that will be used to connect to the server
+            (1) FILEPATH: This means that the authentication parameter contains a filepath leading to a private key file stored in the codebase
+            (2) KEY_STRING: This means that the authentication parameter contains the private key in string form
+
+        """
+
+        client = paramiko.SSHClient()
+        client.set_missing_host_key_policy(paramiko.MissingHostKeyPolicy)
+
+        if connection_type == SFTPAuthMethod.FILEPATH:
+            client.connect(host, username=username, port=port, key_filename=authentication)
+            return client.open_sftp()
+
+        if connection_type == SFTPAuthMethod.KEY_STRING:
+            private_key: pkey = paramiko.RSAKey.from_private_key(io.StringIO(authentication))
+            client.connect(host, username=username, port=port, pkey=private_key)
+            return client.open_sftp()
+
+        if connection_type == SFTPAuthMethod.PASSWORD:
+            client.connect(host, username=username, password=authentication, port=port)
+            return client.open_sftp()
+
+        raise SapioException("The SFTPAuthMethod enumerator was not properly specified.")

{sapiopycommons-2024.10.14a341.dist-info → sapiopycommons-2024.10.25a345.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2024.10.14a341
+Version: 2024.10.25a345
 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-2024.10.14a341.dist-info → sapiopycommons-2024.10.25a345.dist-info}/RECORD

@@ -2,17 +2,18 @@ sapiopycommons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/callbacks/callback_util.py,sha256=nb6cXK8yFq96gtG0Z2NiK-qdNaRh88bavUH-ZoBjh18,67953
 sapiopycommons/chem/IndigoMolecules.py,sha256=3f-aig3AJkKJhRmhlQ0cI-5G8oeaQk_3foJTDZCvoko,2040
-sapiopycommons/chem/Molecules.py,sha256=0B_SsXB2swg2DiP50p0tcNOVO1ajlxumSI42YyDiSHI,11517
+sapiopycommons/chem/Molecules.py,sha256=SQKnqdZnhYj_6HGtEZmE_1DormonRR1-nBAQ__z4gms,11485
 sapiopycommons/chem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/customreport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/customreport/column_builder.py,sha256=sS_wZYOR72rs3syTNjwCVP4h8M8N0b0burkTxFQItVU,3019
+sapiopycommons/customreport/column_builder.py,sha256=0RO53e9rKPZ07C--KcepN6_tpRw_FxF3O9vdG0ilKG8,3014
 sapiopycommons/customreport/custom_report_builder.py,sha256=o2O89OrWPm0OYS8Ux6EKZTg6hcUzfz3ZxAgnzJg1wEw,6601
 sapiopycommons/customreport/term_builder.py,sha256=oVsr7iFPnug2TrZUCcAMhyps-b62kDodPcBxyQeneUY,16763
 sapiopycommons/datatype/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/datatype/attachment_util.py,sha256=_l2swuP8noIGAl4bwzBUEhr6YlN_OVZl3-gi1XqFHYA,3364
+sapiopycommons/datatype/pseudo_data_types.py,sha256=Fe75Rnq5evyeJM1nC0sLkLGKAC74g2-GEeTdMeId80o,27649
 sapiopycommons/eln/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/eln/experiment_handler.py,sha256=eUVKHmgd4oowWg37mBnp4Ag_NsXBkDhm6mV4j36HhKs,66850
-sapiopycommons/eln/experiment_report_util.py,sha256=B55hXbTGndCEI19LiqhjvO46_chujZUK0qDTWHjzfcU,6398
+sapiopycommons/eln/experiment_handler.py,sha256=jtJC-ZU8fDud5UD8IVLJZVOqgm8QMkyA1kZZujf3fcg,68454
+sapiopycommons/eln/experiment_report_util.py,sha256=nt-zs6ag1oBAN3NSHcdLBtY1EWxsiI10NfW15xTnn4g,14522
 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
@@ -26,14 +27,14 @@ sapiopycommons/flowcyto/flow_cyto.py,sha256=YlkKJR_zEHYRuNW0bnTqlTyZeXs0lOaeSCfG
 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=Gih9shHsj765q4HimfFTTI7wWDPAtXjoqCgHisyIQZY,10409
-sapiopycommons/general/audit_log.py,sha256=tJi4uU4qRY2WWcK4ItkjRvoCHCwwiU9LwCNv4lP5-QQ,8713
+sapiopycommons/general/aliases.py,sha256=eyW5VSK8q5xCjWv9fwd3gKEmK_7pboVLa4DPQpJXpe4,12264
+sapiopycommons/general/audit_log.py,sha256=KQI0AGgN9WLwKqnHE4Tm0xeBCfpVBf8rIQ2HFmnyFGI,8956
 sapiopycommons/general/custom_report_util.py,sha256=BGu9Ki0wn3m4Nk-LKM6inDSfe8ULUSG9d-HJJNOTtGc,15653
 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=sXThADCRAQDWYDD9C5CdhcKYIt3qOaVNyZfGBR7HW9A,8701
+sapiopycommons/general/time_util.py,sha256=jUAWmQLNcLHZa4UYB4ht_I3d6uoi63VxYdo7T80Ydw0,7458
 sapiopycommons/multimodal/multimodal.py,sha256=A1QsC8QTPmgZyPr7KtMbPRedn2Ie4WIErodUvQ9otgU,6724
 sapiopycommons/multimodal/multimodal_data.py,sha256=t-0uY4cVgm88uXaSOL4ZeB6zmdHufowXuLFlMk61wFg,15087
 sapiopycommons/processtracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -43,10 +44,12 @@ sapiopycommons/recordmodel/record_handler.py,sha256=Uxjrq6f_cWFbqi7KRLySdOvmQGtb
 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=eKYMiyBc10DNTfbeidQUcfZgFTwhu5ZU-nNJMCK_eos,3014
 sapiopycommons/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/webhook/webhook_handlers.py,sha256=JTquLBln49L1pJ9txJ4oc4Hpzy9kYtMKs0m4SLaFx78,18363
 sapiopycommons/webhook/webservice_handlers.py,sha256=1J56zFI0pWl5MHoNTznvcZumITXgAHJMluj8-2BqYEw,3315
-sapiopycommons-2024.10.14a341.dist-info/METADATA,sha256=HAeNuNnK_r78w9E501s3a6mdD7RdbJLNOsY5W-XTViU,3177
-sapiopycommons-2024.10.14a341.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-sapiopycommons-2024.10.14a341.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-sapiopycommons-2024.10.14a341.dist-info/RECORD,,
+sapiopycommons-2024.10.25a345.dist-info/METADATA,sha256=SSy4mFChmb1yl1geoOfc81CC9PW0uxqulO8eHqyRDZA,3177
+sapiopycommons-2024.10.25a345.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+sapiopycommons-2024.10.25a345.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+sapiopycommons-2024.10.25a345.dist-info/RECORD,,