sapiopycommons 2024.8.19a305__py3-none-any.whl → 2024.8.20a306__py3-none-any.whl

sapiopycommons/processtracking/endpoints.py

@@ -1,12 +1,12 @@
 from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 
-from sapiopycommons.general.aliases import RecordIdentifier, AliasUtil, ExperimentIdentifier
+from sapiopycommons.general.aliases import RecordIdentifier, AliasUtil, ExperimentIdentifier, DataTypeIdentifier, \
+    UserIdentifier
 
 
 class ProcessTracking:
     @staticmethod
-    def assign_to_process(context: SapioWebhookContext | SapioUser, data_type: str, records: list[RecordIdentifier],
+    def assign_to_process(context: UserIdentifier, data_type: DataTypeIdentifier, records: list[RecordIdentifier],
                           process_name: str, step_number: int | None = None, branch_id: int | None = None,
                           request: RecordIdentifier | None = None) -> None:
         """
@@ -27,19 +27,19 @@ class ProcessTracking:
         """
         sub_path = '/ext/process-tracking/assign-to-process'
         payload = {
-            "data-type-name": data_type,
+            "data-type-name": AliasUtil.to_data_type_name(data_type),
             "record-ids": AliasUtil.to_record_ids(records),
             "process-name": process_name,
             "step-number": step_number,
             "branch-id": branch_id,
             "request-record-id": AliasUtil.to_record_ids([request])[0] if request is not None else None
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         response = user.post(sub_path, payload=payload)
         user.raise_for_status(response)
 
     @staticmethod
-    def begin_protocol(context: SapioWebhookContext | SapioUser, data_type: str, records: list[RecordIdentifier],
+    def begin_protocol(context: UserIdentifier, data_type: DataTypeIdentifier, records: list[RecordIdentifier],
                        experiment: ExperimentIdentifier) -> None:
         """
         Begin the assigned processes of the given tracked records as the given experiment. This sets the status of the
@@ -54,16 +54,16 @@ class ProcessTracking:
         """
         sub_path = '/ext/process-tracking/begin-protocol'
         payload = {
-            "data-type-name": data_type,
+            "data-type-name": AliasUtil.to_data_type_name(data_type),
             "record-ids": AliasUtil.to_record_ids(records),
             "experiment-id": AliasUtil.to_notebook_id(experiment),
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         response = user.post(sub_path, payload=payload)
         user.raise_for_status(response)
 
     @staticmethod
-    def complete_protocol(context: SapioWebhookContext | SapioUser, data_type: str, records: list[RecordIdentifier],
+    def complete_protocol(context: UserIdentifier, data_type: DataTypeIdentifier, records: list[RecordIdentifier],
                           experiment: ExperimentIdentifier) -> None:
         """
         Complete the current step that the given tracked records are at given the experiment.
@@ -80,16 +80,16 @@ class ProcessTracking:
         """
         sub_path = '/ext/process-tracking/complete-protocol'
         payload = {
-            "data-type-name": data_type,
+            "data-type-name": AliasUtil.to_data_type_name(data_type),
             "record-ids": AliasUtil.to_record_ids(records),
             "experiment-id": AliasUtil.to_notebook_id(experiment),
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         response = user.post(sub_path, payload=payload)
         user.raise_for_status(response)
 
     @staticmethod
-    def fail(context: SapioWebhookContext | SapioUser, data_type: str, records: list[RecordIdentifier],
+    def fail(context: UserIdentifier, data_type: DataTypeIdentifier, records: list[RecordIdentifier],
              experiment: ExperimentIdentifier) -> None:
         """
         Fail the assigned processes of the given tracked records, changing their statuses to "Failed -". The tracked
@@ -103,16 +103,16 @@ class ProcessTracking:
         """
         sub_path = '/ext/process-tracking/fail'
         payload = {
-            "data-type-name": data_type,
+            "data-type-name": AliasUtil.to_data_type_name(data_type),
             "record-ids": AliasUtil.to_record_ids(records),
             "experiment-id": AliasUtil.to_notebook_id(experiment),
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         response = user.post(sub_path, payload=payload)
         user.raise_for_status(response)
 
     @staticmethod
-    def promote_to_next_by_experiment(context: SapioWebhookContext | SapioUser, data_type: str,
+    def promote_to_next_by_experiment(context: UserIdentifier, data_type: DataTypeIdentifier,
                                       records: list[RecordIdentifier], experiment: ExperimentIdentifier) -> None:
         """
         Promote the status of the given tracked records to the next status in their process using an experiment.
@@ -129,16 +129,16 @@ class ProcessTracking:
         """
         sub_path = '/ext/process-tracking/promote-status-to-next'
         payload = {
-            "data-type-name": data_type,
+            "data-type-name": AliasUtil.to_data_type_name(data_type),
             "record-ids": AliasUtil.to_record_ids(records),
             "experiment-id": AliasUtil.to_notebook_id(experiment),
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         response = user.post(sub_path, payload=payload)
         user.raise_for_status(response)
 
     @staticmethod
-    def promote_to_next_by_step(context: SapioWebhookContext | SapioUser, data_type: str,
+    def promote_to_next_by_step(context: UserIdentifier, data_type: DataTypeIdentifier,
                                 records: list[RecordIdentifier], process_name: str, step_number: int,
                                 branch_id: int | None = None) -> None:
         """
@@ -159,7 +159,7 @@ class ProcessTracking:
         """
         sub_path = '/ext/process-tracking/promote-status-to-next'
         payload = {
-            "data-type-name": data_type,
+            "data-type-name": AliasUtil.to_data_type_name(data_type),
             "record-ids": AliasUtil.to_record_ids(records),
             "current-process-status": {
                 "process-name": process_name,
@@ -167,12 +167,12 @@ class ProcessTracking:
                 "branch-id": branch_id
             }
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         response = user.post(sub_path, payload=payload)
         user.raise_for_status(response)
 
     @staticmethod
-    def reprocess(context: SapioWebhookContext | SapioUser, records: list[RecordIdentifier]) -> None:
+    def reprocess(context: UserIdentifier, records: list[RecordIdentifier]) -> None:
         """
         Reprocess tracked records to a previous step in their process. Reprocessing is controlled by ReturnPoint records
         which are children of the AssignedProcess on the tracked records. Creates a new AssignedProcess record for the
@@ -187,6 +187,6 @@ class ProcessTracking:
         payload = {
             "record-ids": AliasUtil.to_record_ids(records)
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         response = user.post(sub_path, payload=payload)
         user.raise_for_status(response)

sapiopycommons/recordmodel/record_handler.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 from collections.abc import Iterable
-from typing import Any
 from weakref import WeakValueDictionary
 
 from sapiopylib.rest.DataRecordManagerService import DataRecordManager
@@ -11,7 +10,6 @@ from sapiopylib.rest.pojo.DataRecord import DataRecord
 from sapiopylib.rest.pojo.DataRecordPaging import DataRecordPojoPageCriteria
 from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
 from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.autopaging import QueryDataRecordsAutoPager, QueryDataRecordByIdListAutoPager, \
     QueryAllRecordsOfTypeAutoPager
 from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
@@ -22,7 +20,8 @@ from sapiopylib.rest.utils.recordmodel.RelationshipPath import RelationshipPath,
     RelationshipNodeType
 from sapiopylib.rest.utils.recordmodel.ancestry import RecordModelAncestorManager
 
-from sapiopycommons.general.aliases import RecordModel, SapioRecord, FieldMap
+from sapiopycommons.general.aliases import RecordModel, SapioRecord, FieldMap, FieldIdentifier, AliasUtil, \
+    FieldIdentifierMap, FieldValue, UserIdentifier, FieldIdentifierKey
 from sapiopycommons.general.custom_report_util import CustomReportUtil
 from sapiopycommons.general.exceptions import SapioException
 
@@ -42,11 +41,11 @@ class RecordHandler:
     __instances: WeakValueDictionary[SapioUser, RecordHandler] = WeakValueDictionary()
     __initialized: bool
 
-    def __new__(cls, context: SapioWebhookContext | SapioUser):
+    def __new__(cls, context: UserIdentifier):
         """
         :param context: The current webhook context or a user object to send requests from.
         """
-        user = context if isinstance(context, SapioUser) else context.user
+        user = AliasUtil.to_sapio_user(context)
         obj = cls.__instances.get(user)
         if not obj:
             obj = object.__new__(cls)
@@ -54,10 +53,11 @@ class RecordHandler:
             cls.__instances[user] = obj
         return obj
 
-    def __init__(self, context: SapioWebhookContext | SapioUser):
+    def __init__(self, context: UserIdentifier):
         """
         :param context: The current webhook context or a user object to send requests from.
         """
+        self.user = AliasUtil.to_sapio_user(context)
         if self.__initialized:
             return
         self.__initialized = True
@@ -91,7 +91,7 @@ class RecordHandler:
         self.__verify_data_type(records, wrapper_type)
         return self.inst_man.add_existing_records_of_type(list(records), wrapper_type)
 
-    def query_models(self, wrapper_type: type[WrappedType], field: str, value_list: Iterable[Any],
+    def query_models(self, wrapper_type: type[WrappedType], field: FieldIdentifier, value_list: Iterable[FieldValue],
                      page_limit: int | None = None) -> list[WrappedType]:
         """
         Shorthand for using the data record manager to query for a list of data records by field value
@@ -105,9 +105,9 @@ class RecordHandler:
         """
         return self.query_models_with_criteria(wrapper_type, field, value_list, None, page_limit)[0]
 
-    def query_and_map_models(self, wrapper_type: type[WrappedType], field: str, value_list: Iterable[Any],
-                             page_limit: int | None = None, *, mapping_field: str | None = None) \
-            -> dict[Any, list[WrappedType]]:
+    def query_and_map_models(self, wrapper_type: type[WrappedType], field: FieldIdentifier,
+                             value_list: Iterable[FieldValue], page_limit: int | None = None,
+                             *, mapping_field: FieldIdentifier | None = None) -> dict[FieldValue, list[WrappedType]]:
         """
         Shorthand for using query_models to search for records given values on a specific field and then using
         map_by_field to turn the returned list into a dictionary mapping field values to records.
@@ -123,9 +123,10 @@ class RecordHandler:
             mapping_field = field
         return self.map_by_field(self.query_models(wrapper_type, field, value_list, page_limit), mapping_field)
 
-    def query_and_unique_map_models(self, wrapper_type: type[WrappedType], field: str, value_list: Iterable[Any],
-                                    page_limit: int | None = None, *, mapping_field: str | None = None) \
-            -> dict[Any, WrappedType]:
+    def query_and_unique_map_models(self, wrapper_type: type[WrappedType], field: FieldIdentifier,
+                                    value_list: Iterable[FieldValue], page_limit: int | None = None,
+                                    *, mapping_field: FieldIdentifier | None = None) \
+            -> dict[FieldValue, WrappedType]:
         """
         Shorthand for using query_models to search for records given values on a specific field and then using
         map_by_unique_field to turn the returned list into a dictionary mapping field values to records.
@@ -142,7 +143,8 @@ class RecordHandler:
             mapping_field = field
         return self.map_by_unique_field(self.query_models(wrapper_type, field, value_list, page_limit), mapping_field)
 
-    def query_models_with_criteria(self, wrapper_type: type[WrappedType], field: str, value_list: Iterable[Any],
+    def query_models_with_criteria(self, wrapper_type: type[WrappedType], field: FieldIdentifier,
+                                   value_list: Iterable[FieldValue],
                                    paging_criteria: DataRecordPojoPageCriteria | None = None,
                                    page_limit: int | None = None) \
             -> tuple[list[WrappedType], DataRecordPojoPageCriteria]:
@@ -159,6 +161,7 @@ class RecordHandler:
         :return: The record models for the queried records and the final paging criteria.
         """
         dt: str = wrapper_type.get_wrapper_data_type_name()
+        field: str = AliasUtil.to_data_field_name(field)
         pager = QueryDataRecordsAutoPager(dt, field, list(value_list), self.user, paging_criteria)
         pager.max_page = page_limit
         return self.wrap_models(pager.get_all_at_once(), wrapper_type), pager.next_page_criteria
@@ -241,7 +244,7 @@ class RecordHandler:
 
     def query_models_by_report(self, wrapper_type: type[WrappedType],
                                report_name: str | RawReportTerm | CustomReportCriteria,
-                               filters: dict[str, Iterable[Any]] | None = None,
+                               filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None = None,
                                page_limit: int | None = None,
                                page_size: int | None = None,
                                page_number: int | None = None) -> list[WrappedType]:
@@ -269,11 +272,11 @@ class RecordHandler:
         :return: The record models for the queried records that matched the given report.
         """
         if isinstance(report_name, str):
-            results: list[dict[str, Any]] = CustomReportUtil.run_system_report(self.user, report_name, filters,
-                                                                               page_limit, page_size, page_number)
+            results: list[dict[str, FieldValue]] = CustomReportUtil.run_system_report(self.user, report_name, filters,
+                                                                                      page_limit, page_size, page_number)
         elif isinstance(report_name, RawReportTerm):
-            results: list[dict[str, Any]] = CustomReportUtil.run_quick_report(self.user, report_name, filters,
-                                                                              page_limit, page_size, page_number)
+            results: list[dict[str, FieldValue]] = CustomReportUtil.run_quick_report(self.user, report_name, filters,
+                                                                                     page_limit, page_size, page_number)
         elif isinstance(report_name, CustomReportCriteria):
             dt: str = wrapper_type.get_wrapper_data_type_name()
             # Ensure that the root data type is the one we're looking for.
@@ -284,8 +287,8 @@ class RecordHandler:
             # Enforce that the given custom report has a record ID column.
             if not any([x.data_type_name == dt and x.data_field_name == "RecordId" for x in report_name.column_list]):
                 report_name.column_list.append(ReportColumn(dt, "RecordId", FieldType.LONG))
-            results: list[dict[str, Any]] = CustomReportUtil.run_custom_report(self.user, report_name, filters,
-                                                                               page_limit, page_size, page_number)
+            results: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(self.user, report_name, filters,
+                                                                                      page_limit, page_size, page_number)
         else:
             raise SapioException("Unrecognized report object.")
 
@@ -314,7 +317,8 @@ class RecordHandler:
         """
         return self.inst_man.add_new_records_of_type(num, wrapper_type)
 
-    def add_models_with_data(self, wrapper_type: type[WrappedType], fields: list[FieldMap]) -> list[WrappedType]:
+    def add_models_with_data(self, wrapper_type: type[WrappedType], fields: list[FieldIdentifierMap]) \
+            -> list[WrappedType]:
         """
         Shorthand for using the instance manager to add new models of the given type, and then initializing all those
         models with the given fields.
@@ -324,13 +328,14 @@ class RecordHandler:
         :return: The newly added record models with the provided fields set. The records will be in the same order as
             the fields in the fields list.
         """
+        fields: list[FieldMap] = AliasUtil.to_data_field_names_list_dict(fields)
         models: list[WrappedType] = self.add_models(wrapper_type, len(fields))
         for model, field_list in zip(models, fields):
             model.set_field_values(field_list)
         return models
 
-    def find_or_add_model(self, wrapper_type: type[WrappedType], primary_identifier: str, id_value: Any,
-                          secondary_identifiers: FieldMap | None = None) -> WrappedType:
+    def find_or_add_model(self, wrapper_type: type[WrappedType], primary_identifier: FieldIdentifier,
+                          id_value: FieldValue, secondary_identifiers: FieldIdentifierMap | None = None) -> WrappedType:
         """
         Find a unique record that matches the given field values. If no such records exist, add a record model to the
         cache with the identifying fields set to the desired values. This record will be created in the system when
@@ -353,6 +358,8 @@ class RecordHandler:
         if secondary_identifiers is None:
             secondary_identifiers = {}
 
+        primary_identifier: str = AliasUtil.to_data_field_name(primary_identifier)
+        secondary_identifiers: FieldMap = AliasUtil.to_data_field_names_dict(secondary_identifiers)
         unique_record: WrappedType | None = self.__find_model(wrapper_type, primary_identifier, id_value,
                                                               secondary_identifiers)
         # If a unique record matched the identifiers, return it.
@@ -379,7 +386,7 @@ class RecordHandler:
         dt: str = wrapper_type.get_wrapper_data_type_name()
         return self.wrap_models(self.dr_man.add_data_records(dt, num), wrapper_type)
 
-    def create_models_with_data(self, wrapper_type: type[WrappedType], fields: list[FieldMap]) \
+    def create_models_with_data(self, wrapper_type: type[WrappedType], fields: list[FieldIdentifierMap]) \
             -> list[WrappedType]:
         """
         Shorthand for creating new records via the data record manager with field data to initialize the records with
@@ -393,10 +400,12 @@ class RecordHandler:
         :return: The newly created record models.
         """
         dt: str = wrapper_type.get_wrapper_data_type_name()
+        fields: list[FieldMap] = AliasUtil.to_data_field_names_list_dict(fields)
         return self.wrap_models(self.dr_man.add_data_records_with_data(dt, fields), wrapper_type)
 
-    def find_or_create_model(self, wrapper_type: type[WrappedType], primary_identifier: str, id_value: Any,
-                             secondary_identifiers: FieldMap | None = None) -> WrappedType:
+    def find_or_create_model(self, wrapper_type: type[WrappedType], primary_identifier: FieldIdentifier,
+                             id_value: FieldValue, secondary_identifiers: FieldIdentifierMap | None = None) \
+            -> WrappedType:
         """
         Find a unique record that matches the given field values. If no such records exist, create one with the
         identifying fields set to the desired values. If more than one record with the identifying values exists,
@@ -420,6 +429,8 @@ class RecordHandler:
         if secondary_identifiers is None:
             secondary_identifiers = {}
 
+        primary_identifier: str = AliasUtil.to_data_field_name(primary_identifier)
+        secondary_identifiers: FieldMap = AliasUtil.to_data_field_names_dict(secondary_identifiers)
         unique_record: WrappedType | None = self.__find_model(wrapper_type, primary_identifier, id_value,
                                                               secondary_identifiers)
         # If a unique record matched the identifiers, return it.
@@ -579,7 +590,7 @@ class RecordHandler:
         return by_children
 
     @staticmethod
-    def map_to_forward_side_link(models: Iterable[WrappedRecordModel], field_name: str,
+    def map_to_forward_side_link(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
                                  side_link_type: type[WrappedType]) -> dict[WrappedRecordModel, WrappedType]:
         """
         Map a list of record models to their forward side link. The forward side link must already be loaded.
@@ -590,13 +601,14 @@ class RecordHandler:
         :return: A dict[ModelType, SlideLink]. If an input model doesn't have a forward side link of the given type,
             then it will map to None.
         """
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         return_dict: dict[WrappedRecordModel, WrappedType] = {}
         for model in models:
             return_dict[model] = model.get_forward_side_link(field_name, side_link_type)
         return return_dict
 
     @staticmethod
-    def map_by_forward_side_links(models: Iterable[WrappedRecordModel], field_name: str,
+    def map_by_forward_side_links(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
                                   side_link_type: type[WrappedType]) -> dict[WrappedType, list[WrappedRecordModel]]:
         """
         Take a list of record models and map them by their forward side link. Essentially an inversion of
@@ -609,6 +621,7 @@ class RecordHandler:
         :return: A dict[SideLink, list[ModelType]]. If an input model doesn't have a forward side link of the given type
             pointing to it, then it will not be in the resulting dictionary.
         """
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         to_side_link: dict[WrappedRecordModel, WrappedType] = RecordHandler\
             .map_to_forward_side_link(models, field_name, side_link_type)
         by_side_link: dict[WrappedType, list[WrappedRecordModel]] = {}
@@ -619,7 +632,7 @@ class RecordHandler:
         return by_side_link
 
     @staticmethod
-    def map_by_forward_side_link(models: Iterable[WrappedRecordModel], field_name: str,
+    def map_by_forward_side_link(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
                                  side_link_type: type[WrappedType]) -> dict[WrappedType, WrappedRecordModel]:
         """
         Take a list of record models and map them by their forward side link. Essentially an inversion of
@@ -632,6 +645,7 @@ class RecordHandler:
         :return: A dict[SideLink, ModelType]. If an input model doesn't have a forward side link of the given type
             pointing to it, then it will not be in the resulting dictionary.
         """
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         to_side_link: dict[WrappedRecordModel, WrappedType] = RecordHandler\
             .map_to_forward_side_link(models, field_name, side_link_type)
         by_side_link: dict[WrappedType, WrappedRecordModel] = {}
@@ -645,7 +659,7 @@ class RecordHandler:
         return by_side_link
 
     @staticmethod
-    def map_to_reverse_side_links(models: Iterable[WrappedRecordModel], field_name: str,
+    def map_to_reverse_side_links(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
                                   side_link_type: type[WrappedType]) -> dict[WrappedRecordModel, list[WrappedType]]:
         """
         Map a list of record models to a list reverse side links of a given type. The reverse side links must already
@@ -658,13 +672,14 @@ class RecordHandler:
         :return: A dict[ModelType, list[SideLink]]. If an input model doesn't have reverse side links of the given type,
             then it will map to an empty list.
         """
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         return_dict: dict[WrappedRecordModel, list[WrappedType]] = {}
         for model in models:
             return_dict[model] = model.get_reverse_side_link(field_name, side_link_type)
         return return_dict
 
     @staticmethod
-    def map_to_reverse_side_link(models: Iterable[WrappedRecordModel], field_name: str,
+    def map_to_reverse_side_link(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
                                  side_link_type: type[WrappedType]) -> dict[WrappedRecordModel, WrappedType]:
         """
         Map a list of record models to the reverse side link of a given type. If a given record has more than one
@@ -677,6 +692,7 @@ class RecordHandler:
         :return: A dict[ModelType, SideLink]. If an input model doesn't have reverse side links of the given type,
             then it will map to None.
         """
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         return_dict: dict[WrappedRecordModel, WrappedType] = {}
         for model in models:
             links: list[WrappedType] = model.get_reverse_side_link(field_name, side_link_type)
@@ -687,7 +703,7 @@ class RecordHandler:
         return return_dict
 
     @staticmethod
-    def map_by_reverse_side_links(models: Iterable[WrappedRecordModel], field_name: str,
+    def map_by_reverse_side_links(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
                                   side_link_type: type[WrappedType]) -> dict[WrappedType, list[WrappedRecordModel]]:
         """
         Take a list of record models and map them by their reverse side links. Essentially an inversion of
@@ -701,6 +717,7 @@ class RecordHandler:
         :return: A dict[SideLink, list[ModelType]]. If an input model doesn't have reverse side links of the given type
             pointing to it, then it will not be in the resulting dictionary.
         """
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         to_side_links: dict[WrappedRecordModel, list[WrappedType]] = RecordHandler\
             .map_to_reverse_side_links(models, field_name, side_link_type)
         by_side_links: dict[WrappedType, list[WrappedRecordModel]] = {}
@@ -710,7 +727,7 @@ class RecordHandler:
         return by_side_links
 
     @staticmethod
-    def map_by_reverse_side_link(models: Iterable[WrappedRecordModel], field_name: str,
+    def map_by_reverse_side_link(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
                                  side_link_type: type[WrappedType]) -> dict[WrappedType, WrappedRecordModel]:
         """
         Take a list of record models and map them by their reverse side link. Essentially an inversion of
@@ -724,6 +741,7 @@ class RecordHandler:
         :return: A dict[SideLink, ModelType]. If an input model doesn't have a reverse side link of the given type
             pointing to it, then it will not be in the resulting dictionary.
         """
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         to_side_link: dict[WrappedRecordModel, WrappedType] = RecordHandler\
             .map_to_reverse_side_link(models, field_name, side_link_type)
         by_side_link: dict[WrappedType, WrappedRecordModel] = {}
@@ -750,7 +768,8 @@ class RecordHandler:
         return ret_dict
 
     @staticmethod
-    def map_by_field(models: Iterable[SapioRecord], field_name: str) -> dict[Any, list[SapioRecord]]:
+    def map_by_field(models: Iterable[SapioRecord], field_name: FieldIdentifier) \
+            -> dict[FieldValue, list[SapioRecord]]:
         """
         Map the given records by one of their fields. If any two records share the same field value, they'll appear in
         the same value list.
@@ -759,14 +778,16 @@ class RecordHandler:
         :param field_name: The field name to map against.
         :return: A dict mapping field values to the records with that value.
         """
-        ret_dict: dict[Any, list[SapioRecord]] = {}
+        field_name: str = AliasUtil.to_data_field_name(field_name)
+        ret_dict: dict[FieldValue, list[SapioRecord]] = {}
         for model in models:
-            val: Any = model.get_field_value(field_name)
+            val: FieldValue = model.get_field_value(field_name)
             ret_dict.setdefault(val, []).append(model)
         return ret_dict
 
     @staticmethod
-    def map_by_unique_field(models: Iterable[SapioRecord], field_name: str) -> dict[Any, SapioRecord]:
+    def map_by_unique_field(models: Iterable[SapioRecord], field_name: FieldIdentifier) \
+            -> dict[FieldValue, SapioRecord]:
         """
         Uniquely map the given records by one of their fields. If any two records share the same field value, throws
         an exception.
@@ -775,16 +796,17 @@ class RecordHandler:
         :param field_name: The field name to map against.
         :return: A dict mapping field values to the record with that value.
         """
-        ret_dict: dict[Any, SapioRecord] = {}
+        field_name: str = AliasUtil.to_data_field_name(field_name)
+        ret_dict: dict[FieldValue, SapioRecord] = {}
         for model in models:
-            val: Any = model.get_field_value(field_name)
+            val: FieldValue = model.get_field_value(field_name)
             if val in ret_dict:
                 raise SapioException(f"Value {val} encountered more than once in models list.")
             ret_dict.update({val: model})
         return ret_dict
 
     @staticmethod
-    def sum_of_field(models: Iterable[SapioRecord], field_name: str) -> float:
+    def sum_of_field(models: Iterable[SapioRecord], field_name: FieldIdentifier) -> float:
         """
         Sum up the numeric value of a given field across all input models. Excepts that all given models have a value.
         If the field is an integer field, the value will be converted to a float.
@@ -793,13 +815,14 @@ class RecordHandler:
         :param field_name: The name of the numeric field to sum.
         :return: The sum of the field values for the collection of models.
         """
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         field_sum: float = 0
         for model in models:
             field_sum += float(model.get_field_value(field_name))
         return field_sum
 
     @staticmethod
-    def mean_of_field(models: Iterable[SapioRecord], field_name: str) -> float:
+    def mean_of_field(models: Iterable[SapioRecord], field_name: FieldIdentifier) -> float:
         """
         Calculate the mean of the numeric value of a given field across all input models. Excepts that all given models
         have a value. If the field is an integer field, the value will be converted to a float.
@@ -840,8 +863,8 @@ class RecordHandler:
         return oldest
 
     @staticmethod
-    def values_to_field_maps(field_name: str, values: Iterable[Any], existing_fields: list[FieldMap] | None = None) \
-            -> list[FieldMap]:
+    def values_to_field_maps(field_name: FieldIdentifier, values: Iterable[FieldValue],
+                             existing_fields: list[FieldIdentifier] | None = None) -> list[FieldMap]:
         """
         Add a list of values for a specific field to a list of dictionaries pairing each value to that field name.
 
@@ -852,6 +875,8 @@ class RecordHandler:
         :return: A fields map list that contains the given values mapped by the given field name.
         """
         # Update the existing fields map list if one is given.
+        field_name: str = AliasUtil.to_data_field_name(field_name)
+        existing_fields: list[FieldMap] = AliasUtil.to_data_field_names_list_dict(existing_fields)
         if existing_fields:
             values = list(values)
             # The number of new values must match the length of the existing fields list.
@@ -1016,8 +1041,8 @@ class RecordHandler:
             ret_dict.update({model: self.inst_man.wrap(current[0], wrapper_type) if current else None})
         return ret_dict
 
-    def __find_model(self, wrapper_type: type[WrappedType], primary_identifier: str, id_value: Any,
-                     secondary_identifiers: FieldMap | None = None) -> WrappedType | None:
+    def __find_model(self, wrapper_type: type[WrappedType], primary_identifier: str, id_value: FieldValue,
+                     secondary_identifiers: FieldIdentifierMap | None = None) -> WrappedType | None:
         """
         Find a record from the system that matches the given field values. The primary identifier and value is used
         to query for the record, then the secondary identifiers may be optionally provided to further filter the

sapiopycommons/rules/eln_rule_handler.py

@@ -9,7 +9,7 @@ from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager, RecordModelInstanceManager
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
-from sapiopycommons.general.aliases import FieldMap
+from sapiopycommons.general.aliases import FieldMap, AliasUtil, DataTypeIdentifier
 from sapiopycommons.general.exceptions import SapioException
 
 
@@ -125,7 +125,7 @@ class ElnRuleHandler:
         """
         return list(self.__entry_to_field_maps.keys())
 
-    def get_records(self, data_type: str, entry: str | None = None) -> list[DataRecord]:
+    def get_records(self, data_type: DataTypeIdentifier, entry: str | None = None) -> list[DataRecord]:
         """
         Get records from the cached context with the given data type. Capable of being filtered to searching within
         the context of an entry name. If the given data type or entry does not exist in the context,
@@ -136,11 +136,12 @@ class ElnRuleHandler:
             type from every entry. If an entry is provided, but it does not exist in the context, returns an empty list.
         :return: The records from the context that match the input parameters.
         """
+        data_type: str = AliasUtil.to_data_type_name(data_type)
         records: dict[str, set[DataRecord]] = self.__entry_to_records.get(entry, {}) if entry else self.__records
         return list(records.get(data_type, []))
 
     # FR-46701: Add functions to the rule handlers for accessing the field maps of inaccessible records in the context.
-    def get_field_maps(self, data_type: str, entry: str | None = None) -> list[FieldMap]:
+    def get_field_maps(self, data_type: DataTypeIdentifier, entry: str | None = None) -> list[FieldMap]:
         """
         Get field maps from the cached context with the given data type. Capable of being filtered to searching within
         the context of an entry name. If the given data type or entry does not exist in the context,
@@ -156,6 +157,7 @@ class ElnRuleHandler:
             list.
         :return: The field maps from the context that match the input parameters.
         """
+        data_type: str = AliasUtil.to_data_type_name(data_type)
         field_maps: dict[str, dict[int, FieldMap]] = self.__entry_to_field_maps.get(entry, {}) if entry else self.__field_maps
         return list(field_maps.get(data_type, {}).values())
 

sapiopycommons/rules/on_save_rule_handler.py

@@ -9,7 +9,7 @@ from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager, RecordModelInstanceManager
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType
 
-from sapiopycommons.general.aliases import FieldMap
+from sapiopycommons.general.aliases import FieldMap, DataTypeIdentifier, AliasUtil
 from sapiopycommons.general.exceptions import SapioException
 
 
@@ -121,7 +121,7 @@ class OnSaveRuleHandler:
         """
         return list(self.__base_id_to_field_maps.keys())
 
-    def get_records(self, data_type: str, record_id: int | None = None) -> list[DataRecord]:
+    def get_records(self, data_type: DataTypeIdentifier, record_id: int | None = None) -> list[DataRecord]:
         """
         Get records from the cached context with the given data type. Capable of being filtered to searching within
         the context of a record ID. If the given data type or record ID does not exist in the context,
@@ -132,11 +132,12 @@ class OnSaveRuleHandler:
             data type from every ID. If an ID is provided, but it does not exist in the context, returns an empty list.
         :return: The records from the context that match the input parameters.
         """
+        data_type: str = AliasUtil.to_data_type_name(data_type)
         records: dict[str, set[DataRecord]] = self.__base_id_to_records.get(record_id, {}) if record_id else self.__records
         return list(records.get(data_type, []))
 
     # FR-46701: Add functions to the rule handlers for accessing the field maps of inaccessible records in the context.
-    def get_field_maps(self, data_type: str, record_id: int | None = None) -> list[FieldMap]:
+    def get_field_maps(self, data_type: DataTypeIdentifier, record_id: int | None = None) -> list[FieldMap]:
         """
         Get field maps from the cached context with the given data type. Capable of being filtered to searching within
         the context of a record ID. If the given data type or record ID does not exist in the context,
@@ -152,6 +153,7 @@ class OnSaveRuleHandler:
             list.
         :return: The field maps from the context that match the input parameters.
         """
+        data_type: str = AliasUtil.to_data_type_name(data_type)
         field_maps: dict[str, dict[int, FieldMap]] = self.__base_id_to_field_maps.get(record_id, {}) if record_id else self.__field_maps
         return list(field_maps.get(data_type, {}).values())