sapiopycommons 2024.10.24a342__py3-none-any.whl → 2024.10.29a346__py3-none-any.whl

sapiopycommons/general/aliases.py

@@ -5,8 +5,10 @@ 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.eln.SapioELNEnums import ElnBaseDataType
 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 +33,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."""
@@ -86,44 +90,50 @@ class AliasUtil:
         return record if isinstance(record, int) else record.record_id
 
     @staticmethod
-    def to_data_type_name(value: DataTypeIdentifier) -> str:
+    def to_data_type_name(value: DataTypeIdentifier, convert_eln_dts: bool = True) -> str:
         """
         Convert a given value to a data type name.
 
         :param value: A value which is a string, record, or record model type.
+        :param convert_eln_dts: If true, convert ELN data types to their base data type name.
         :return: A string of the data type name of the input value.
         """
-        if isinstance(value, str):
-            return value
         if isinstance(value, SapioRecord):
-            return value.data_type_name
-        return value.get_wrapper_data_type_name()
+            value = value.data_type_name
+        elif not isinstance(value, str):
+            value = value.get_wrapper_data_type_name()
+        if convert_eln_dts and ElnBaseDataType.is_eln_type(value):
+            return ElnBaseDataType.get_base_type(value).data_type_name
+        return value
 
     @staticmethod
-    def to_data_type_names(values: Iterable[DataTypeIdentifier], return_set: bool = False) -> list[str] | set[str]:
+    def to_data_type_names(values: Iterable[DataTypeIdentifier], return_set: bool = False,
+                           convert_eln_dts: bool = True) -> list[str] | set[str]:
         """
         Convert a given iterable of values to a list or set of data type names.
 
         :param values: An iterable of values which are strings, records, or record model types.
         :param return_set: If true, return a set instead of a list.
+        :param convert_eln_dts: If true, convert ELN data types to their base data type name.
         :return: A list or set of strings of the data type name of the input value.
         """
-        values = [AliasUtil.to_data_type_name(x) for x in values]
+        values = [AliasUtil.to_data_type_name(x, convert_eln_dts) for x in values]
         return set(values) if return_set else values
 
     @staticmethod
-    def to_singular_data_type_name(values: Iterable[DataTypeIdentifier]) -> str:
+    def to_singular_data_type_name(values: Iterable[DataTypeIdentifier], convert_eln_dts: bool = True) -> str:
         """
         Convert a given iterable of values to a singular data type name that they share. Throws an exception if more
         than one data type name exists in the provided list of identifiers.
 
         :param values: An iterable of values which are strings, records, or record model types.
+        :param convert_eln_dts: If true, convert ELN data types to their base data type name.
         :return: The single data type name that the input vales share. Returns an empty string if an empty iterable
             was provided.
         """
         if not values:
             return ""
-        data_types: set[str] = AliasUtil.to_data_type_names(values, True)
+        data_types: set[str] = AliasUtil.to_data_type_names(values, True, convert_eln_dts)
         if len(data_types) > 1:
             raise SapioException(f"Provided values contain multiple data types: {data_types}. "
                                  f"Only expecting a single data type.")
@@ -223,7 +233,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/multimodal/multimodal_data.py

@@ -38,9 +38,6 @@ class PyMolecule:
     normError: str | None
     desaltError: str | None
     desaltedList: list[str] | None
-    registrationHash: str | None
-    hasOrGroup: bool
-    CXSMILESHash: str | None
 
 
 @dataclass
@@ -103,9 +100,9 @@ class PyMoleculeLoaderResult:
         compoundList: the compounds successfully loaded.
         errorList: an error record is added here for each one we failed to load in Sapio.
     """
-    compoundByStr: dict[str, PyCompound] | None
-    compoundList: list[PyCompound] | None
-    errorList: list[ChemLoadingError] | None
+    compoundByStr: dict[str, PyCompound]
+    compoundList: list[PyCompound]
+    errorList: list[ChemLoadingError]
 
 
 @dataclass