sapiopycommons 2024.8.28a315__py3-none-any.whl → 2024.8.29a317__py3-none-any.whl

sapiopycommons/general/aliases.py

@@ -1,47 +1,24 @@
 from collections.abc import Iterable
 from typing import Any
 
-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.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.Protocols import ElnExperimentProtocol
 from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
-from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedRecordModel, WrappedType, WrapperField
+from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedRecordModel, WrappedType
 
-from sapiopycommons.general.exceptions import SapioException
-
-FieldValue = int | float | str | bool | None
-"""Allowable values for fields in the system."""
 RecordModel = PyRecordModel | WrappedRecordModel | WrappedType
 """Different forms that a record model could take."""
 SapioRecord = DataRecord | RecordModel
 """A record could be provided as either a DataRecord, PyRecordModel, or WrappedRecordModel (WrappedType)."""
 RecordIdentifier = SapioRecord | int
 """A RecordIdentifier is either a record type or an integer for the record's record ID."""
-DataTypeIdentifier = SapioRecord | type[WrappedType] | str
-"""A DataTypeIdentifier is either a SapioRecord, a record model wrapper type, or a string."""
-FieldIdentifier = WrapperField | str | tuple[str, FieldType]
-"""A FieldIdentifier is either wrapper field from a record model wrapper, a string, or a tuple of string
-and field type."""
-FieldIdentifierKey = WrapperField | str
-"""A FieldIdentifierKey is a FieldIdentifier, except it can't be a tuple, s tuples can't be used as keys in
-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
 ID."""
-FieldMap = dict[str, FieldValue]
+FieldMap = dict[str, Any]
 """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."""
-FieldIdentifierMap = dict[FieldIdentifierKey, FieldValue]
-"""A field identifier map is the same thing as a field map, except the keys can be field identifiers instead
-of just strings. Note that although one of the allowed field identifiers is a tuple, you can't use tuples as
-keys in a dictionary."""
-UserIdentifier = SapioWebhookContext | SapioUser
-"""An identifier for classes from which a user object can be used for sending requests."""
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
@@ -73,123 +50,7 @@ class AliasUtil:
 
         :return: A list of record IDs for the input records.
         """
-        return [(AliasUtil.to_record_id(x)) for x in records]
-
-    @staticmethod
-    def to_record_id(record: RecordIdentifier):
-        """
-        Convert a single variable that could be either an integer, DataRecord, PyRecordModel,
-        or WrappedRecordModel to just an integer (taking the record ID from the record).
-
-        :return: A record ID for the input record.
-        """
-        return record if isinstance(record, int) else record.record_id
-
-    @staticmethod
-    def to_data_type_name(value: DataTypeIdentifier) -> str:
-        """
-        Convert a given value to a data type name.
-
-        :param value: A value which is a string, record, or record model type.
-        :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()
-
-    @staticmethod
-    def to_data_type_names(values: Iterable[DataTypeIdentifier], return_set: bool = False) -> 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.
-        :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]
-        return set(values) if return_set else values
-
-    @staticmethod
-    def to_singular_data_type_name(values: Iterable[DataTypeIdentifier]) -> 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.
-        :return: The single data type name that the input vales share.
-        """
-        data_types: set[str] = AliasUtil.to_data_type_names(values, True)
-        if len(data_types) > 1:
-            raise SapioException(f"Provided values contain multiple data types: {data_types}. "
-                                 f"Only expecting a single data type.")
-        return data_types.pop()
-
-    @staticmethod
-    def to_data_field_name(value: FieldIdentifier) -> str:
-        """
-        Convert a string or WrapperField to a data field name string.
-
-        :param value: A string or WrapperField.
-        :return: A string of the data field name of the input value.
-        """
-        if isinstance(value, tuple):
-            return value[0]
-        if isinstance(value, WrapperField):
-            return value.field_name
-        return value
-
-    @staticmethod
-    def to_data_field_names(values: Iterable[FieldIdentifier]) -> list[str]:
-        """
-        Convert an iterable of strings or WrapperFields to a list of data field name strings.
-
-        :param values: An iterable of strings or WrapperFields.
-        :return: A list of strings of the data field names of the input values.
-        """
-        return [AliasUtil.to_data_field_name(x) for x in values]
-
-    @staticmethod
-    def to_data_field_names_dict(values: dict[FieldIdentifierKey, Any]) -> dict[str, Any]:
-        """
-        Take a dictionary whose keys are field identifiers and convert them all to strings for the data field name.
-
-        :param values: A dictionary of field identifiers to field values.
-        :return: A dictionary of strings of the data field names to field values for the input values.
-        """
-        ret_dict: dict[str, FieldValue] = {}
-        for field, value in values.items():
-            ret_dict[AliasUtil.to_data_field_name(field)] = value
-        return ret_dict
-
-    @staticmethod
-    def to_data_field_names_list_dict(values: list[dict[FieldIdentifierKey, Any]]) -> list[dict[str, Any]]:
-        ret_list: list[dict[str, Any]] = []
-        for field_map in values:
-            ret_list.append(AliasUtil.to_data_field_names_dict(field_map))
-        return ret_list
-
-    @staticmethod
-    def to_field_type(field: FieldIdentifier, data_type: HasFieldWrappers | None = None) -> FieldType:
-        """
-        Convert a given field identifier to the field type for that field.
-
-        :param field: A string or WrapperField.
-        :param data_type: If the field is provided as a string, then a record model wrapper or wrapped record model
-            must be provided to determine the field type.
-        :return: The field type of the given field.
-        """
-        if isinstance(field, tuple):
-            return field[1]
-        if isinstance(field, WrapperField):
-            return field.field_type
-        for var in dir(data_type):
-            attr = getattr(data_type, var)
-            if isinstance(attr, WrapperField) and attr.field_name == field:
-                return attr.field_type
-        raise SapioException(f"The wrapper of data type \"{data_type.get_wrapper_data_type_name()}\" doesn't have a "
-                             f"field with the name \"{field}\",")
+        return [(x if isinstance(x, int) else x.record_id) for x in records]
 
     @staticmethod
     def to_field_map_lists(records: Iterable[SapioRecord]) -> list[FieldMap]:
@@ -202,7 +63,6 @@ class AliasUtil:
         field_map_list: list[FieldMap] = []
         for record in records:
             if isinstance(record, DataRecord):
-                # noinspection PyTypeChecker
                 field_map_list.append(record.get_fields())
             else:
                 field_map_list.append(record.fields.copy_to_dict())
@@ -220,7 +80,3 @@ class AliasUtil:
         if isinstance(experiment, ElnExperiment):
             return experiment.notebook_experiment_id
         return experiment.get_id()
-    
-    @staticmethod
-    def to_sapio_user(context: UserIdentifier) -> SapioUser:
-        return context if isinstance(context, SapioUser) else context.user

sapiopycommons/general/custom_report_util.py

@@ -1,21 +1,21 @@
 from collections.abc import Iterable
+from typing import Any
 
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReport, CustomReportCriteria, RawReportTerm
-
-from sapiopycommons.general.aliases import UserIdentifier, FieldValue, AliasUtil, FieldIdentifierKey
+from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
 class CustomReportUtil:
     @staticmethod
-    def run_system_report(context: UserIdentifier,
+    def run_system_report(context: SapioWebhookContext | SapioUser,
                           report_name: str,
-                          filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None = None,
+                          filters: dict[str, Iterable[Any]] | None = None,
                           page_limit: int | None = None,
                           page_size: int | None = None,
-                          page_number: int | None = None) -> list[dict[str, FieldValue]]:
+                          page_number: int | None = None) -> list[dict[str, Any]]:
         """
         Run a system report and return the results of that report as a list of dictionaries for the values of each
         column in each row.
@@ -41,16 +41,16 @@ class CustomReportUtil:
         results: tuple = CustomReportUtil.__exhaust_system_report(context, report_name, page_limit,
                                                                   page_size, page_number)
         columns: list[ReportColumn] = results[0]
-        rows: list[list[FieldValue]] = results[1]
+        rows: list[list[Any]] = results[1]
         return CustomReportUtil.__process_results(rows, columns, filters)
 
     @staticmethod
-    def run_custom_report(context: UserIdentifier,
+    def run_custom_report(context: SapioWebhookContext | SapioUser,
                           report_criteria: CustomReportCriteria,
-                          filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None = None,
+                          filters: dict[str, Iterable[Any]] | None = None,
                           page_limit: int | None = None,
                           page_size: int | None = None,
-                          page_number: int | None = None) -> list[dict[str, FieldValue]]:
+                          page_number: int | None = None) -> list[dict[str, Any]]:
         """
         Run a custom report and return the results of that report as a list of dictionaries for the values of each
         column in each row.
@@ -82,16 +82,16 @@ class CustomReportUtil:
         results: tuple = CustomReportUtil.__exhaust_custom_report(context, report_criteria, page_limit,
                                                                   page_size, page_number)
         columns: list[ReportColumn] = results[0]
-        rows: list[list[FieldValue]] = results[1]
+        rows: list[list[Any]] = results[1]
         return CustomReportUtil.__process_results(rows, columns, filters)
 
     @staticmethod
-    def run_quick_report(context: UserIdentifier,
+    def run_quick_report(context: SapioWebhookContext | SapioUser,
                          report_term: RawReportTerm,
-                         filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None = None,
+                         filters: dict[str, Iterable[Any]] | None = None,
                          page_limit: int | None = None,
                          page_size: int | None = None,
-                         page_number: int | None = None) -> list[dict[str, FieldValue]]:
+                         page_number: int | None = None) -> list[dict[str, Any]]:
         """
         Run a quick report and return the results of that report as a list of dictionaries for the values of each
         column in each row.
@@ -115,11 +115,11 @@ class CustomReportUtil:
         results: tuple = CustomReportUtil.__exhaust_quick_report(context, report_term, page_limit,
                                                                  page_size, page_number)
         columns: list[ReportColumn] = results[0]
-        rows: list[list[FieldValue]] = results[1]
+        rows: list[list[Any]] = results[1]
         return CustomReportUtil.__process_results(rows, columns, filters)
 
     @staticmethod
-    def get_system_report_criteria(context: UserIdentifier, report_name: str) -> CustomReport:
+    def get_system_report_criteria(context: SapioWebhookContext | SapioUser, report_name: str) -> CustomReport:
         """
         Retrieve a custom report from the system given the name of the report. This works by querying the system report
         with a page number and size of 1 to minimize the amount of data transfer needed to retrieve the report's config.
@@ -134,27 +134,27 @@ class CustomReportUtil:
         :param report_name: The name of the system report to run.
         :return: The CustomReport object for the given system report name.
         """
-        user: SapioUser = AliasUtil.to_sapio_user(context)
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
         report_man = DataMgmtServer.get_custom_report_manager(user)
         return report_man.run_system_report_by_name(report_name, 1, 1)
 
     @staticmethod
-    def __exhaust_system_report(context: UserIdentifier,
+    def __exhaust_system_report(context: SapioWebhookContext | SapioUser,
                                 report_name: str,
                                 page_limit: int | None,
                                 page_size: int | None,
                                 page_number: int | None) \
-            -> tuple[list[ReportColumn], list[list[FieldValue]]]:
+            -> tuple[list[ReportColumn], list[list[Any]]]:
         """
         Given a system report, iterate over every page of the report and collect the results
         until there are no remaining pages.
         """
-        user: SapioUser = AliasUtil.to_sapio_user(context)
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
         result = None
         has_next_page: bool = True
-        rows: list[list[FieldValue]] = []
+        rows: list[list[Any]] = []
         cur_page: int = 1
         while has_next_page and (not page_limit or cur_page <= page_limit):
             result = report_man.run_system_report_by_name(report_name, page_size, page_number)
@@ -166,17 +166,17 @@ class CustomReportUtil:
         return result.column_list, rows
 
     @staticmethod
-    def __exhaust_custom_report(context: UserIdentifier,
+    def __exhaust_custom_report(context: SapioWebhookContext | SapioUser,
                                 report: CustomReportCriteria,
                                 page_limit: int | None,
                                 page_size: int | None,
                                 page_number: int | None) \
-            -> tuple[list[ReportColumn], list[list[FieldValue]]]:
+            -> tuple[list[ReportColumn], list[list[Any]]]:
         """
         Given a custom report, iterate over every page of the report and collect the results
         until there are no remaining pages.
         """
-        user: SapioUser = AliasUtil.to_sapio_user(context)
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
         result = None
@@ -185,7 +185,7 @@ class CustomReportUtil:
         if page_number is not None:
             report.page_number = page_number
         has_next_page: bool = True
-        rows: list[list[FieldValue]] = []
+        rows: list[list[Any]] = []
         cur_page: int = 1
         while has_next_page and (not page_limit or cur_page <= page_limit):
             result = report_man.run_custom_report(report)
@@ -197,22 +197,22 @@ class CustomReportUtil:
         return result.column_list, rows
 
     @staticmethod
-    def __exhaust_quick_report(context: UserIdentifier,
+    def __exhaust_quick_report(context: SapioWebhookContext | SapioUser,
                                report_term: RawReportTerm,
                                page_limit: int | None,
                                page_size: int | None,
                                page_number: int | None) \
-            -> tuple[list[ReportColumn], list[list[FieldValue]]]:
+            -> tuple[list[ReportColumn], list[list[Any]]]:
         """
         Given a quick report, iterate over every page of the report and collect the results
         until there are no remaining pages.
         """
-        user: SapioUser = AliasUtil.to_sapio_user(context)
+        user: SapioUser = context if isinstance(context, SapioUser) else context.user
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
         result = None
         has_next_page: bool = True
-        rows: list[list[FieldValue]] = []
+        rows: list[list[Any]] = []
         cur_page: int = 1
         while has_next_page and (not page_limit or cur_page <= page_limit):
             result = report_man.run_quick_report(report_term, page_size, page_number)
@@ -224,8 +224,8 @@ class CustomReportUtil:
         return result.column_list, rows
 
     @staticmethod
-    def __process_results(rows: list[list[FieldValue]], columns: list[ReportColumn],
-                          filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None) -> list[dict[str, FieldValue]]:
+    def __process_results(rows: list[list[Any]], columns: list[ReportColumn],
+                          filters: dict[str, Iterable[Any]] | None) -> list[dict[str, Any]]:
         """
         Given the results of a report as a list of row values and the report's columns, combine these lists to
         result in a singular list of dictionaries for each row in the results.
@@ -243,11 +243,9 @@ class CustomReportUtil:
             else:
                 encountered_names.append(field_name)
 
-        filters: dict[str, Iterable[FieldValue]] = AliasUtil.to_data_field_names_dict(filters)
-
-        ret: list[dict[str, FieldValue]] = []
+        ret: list[dict[str, Any]] = []
         for row in rows:
-            row_data: dict[str, FieldValue] = {}
+            row_data: dict[str, Any] = {}
             filter_row: bool = False
             for value, column in zip(row, columns):
                 header: str = column.data_field_name

sapiopycommons/general/popup_util.py

@@ -1,5 +1,3 @@
-import warnings
-
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.pojo.datatype.DataType import DataTypeDefinition
 from sapiopylib.rest.pojo.datatype.FieldDefinition import VeloxStringFieldDefinition, AbstractVeloxFieldDefinition, \
@@ -53,7 +51,6 @@ class PopupUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the popup as its client callback request.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         if display_name is None:
             display_name = data_type
         if plural_display_name is None:
@@ -100,7 +97,6 @@ class PopupUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the popup as its client callback request.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         # Get the field definitions of the data type.
         data_type: str = record.data_type_name
         type_man = DataMgmtServer.get_data_type_manager(context.user)
@@ -159,7 +155,6 @@ class PopupUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the popup as its client callback request.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         if max_length is None:
             max_length = len(default_value) if default_value else 100
         string_field = VeloxStringFieldDefinition(data_type, field_name, field_name, default_value=default_value,
@@ -196,7 +191,6 @@ class PopupUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the popup as its client callback request.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         if default_value is None:
             default_value = max(0, min_value)
         integer_field = VeloxIntegerFieldDefinition(data_type, field_name, field_name, default_value=default_value,
@@ -235,7 +229,6 @@ class PopupUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the popup as its client callback request.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         if default_value is None:
             default_value = min_value
         double_field = VeloxDoubleFieldDefinition(data_type, field_name, field_name, default_value=default_value,
@@ -267,7 +260,6 @@ class PopupUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the popup as its client callback request.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         if display_name is None:
             display_name = data_type
         if plural_display_name is None:
@@ -303,7 +295,6 @@ class PopupUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the popup as its client callback request.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         data_types: set[str] = {x.data_type_name for x in records}
         if len(data_types) > 1:
             raise SapioException("Multiple data type names encountered in records list for record table popup.")
@@ -356,7 +347,6 @@ class PopupUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the popup as its client callback request.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         data_types: set[str] = {x.data_type_name for x in records}
         if len(data_types) > 1:
             raise SapioException("Multiple data type names encountered in records list for record table popup.")
@@ -401,7 +391,6 @@ class PopupUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the popup as its client callback request.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         callback = ListDialogRequest(title, multi_select, options,
                                      callback_context_data=request_context)
         return SapioWebhookResult(True, client_callback_request=callback)
@@ -426,7 +415,6 @@ class PopupUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the popup as its client callback request.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         callback = OptionDialogRequest(title, msg, options, default_option, user_can_cancel,
                                        callback_context_data=request_context)
         return SapioWebhookResult(True, client_callback_request=callback)
@@ -449,7 +437,6 @@ class PopupUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the popup as its client callback request.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         return PopupUtil.option_popup(title, msg, ["OK"], 0, user_can_cancel, request_context=request_context)
 
     @staticmethod
@@ -471,7 +458,6 @@ class PopupUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the popup as its client callback request.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         return PopupUtil.option_popup(title, msg, ["Yes", "No"], 0 if default_yes else 1, user_can_cancel,
                                       request_context=request_context)
 
@@ -484,7 +470,6 @@ class PopupUtil:
 
         Deprecated for PopupUtil.text_field_popup.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         return PopupUtil.string_field_popup(title, "", field_name, msg, len(msg), False, data_type,
                                             request_context=request_context, auto_size=True)
 
@@ -496,7 +481,6 @@ class PopupUtil:
 
         Deprecated for PopupUtil.option_popup.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         return PopupUtil.option_popup(title, msg, options, 0, user_can_cancel, request_context=request_context)
 
     @staticmethod
@@ -506,5 +490,4 @@ class PopupUtil:
 
         Deprecated for PopupUtil.ok_popup.
         """
-        warnings.warn("PopupUtil is deprecated as of 24.5+. Use CallbackUtil instead.", DeprecationWarning)
         return PopupUtil.ok_popup(title, msg, False, request_context=request_context)

sapiopycommons/general/time_util.py

@@ -1,12 +1,8 @@
-from __future__ import annotations
-
 import time
 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."""
 
@@ -141,39 +137,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

@@ -6,6 +6,7 @@ from typing import Any
 
 from databind.core import ExtraKeys
 from databind.core.dataclasses import dataclass
+from sapiopylib.rest.pojo.DataRecord import DataRecord
 
 
 @dataclass