sapiopycommons 2024.8.29a317__py3-none-any.whl → 2024.8.30a320__py3-none-any.whl

sapiopycommons/recordmodel/record_handler.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from collections.abc import Iterable
-from typing import Any
+from weakref import WeakValueDictionary
 
 from sapiopylib.rest.DataRecordManagerService import DataRecordManager
 from sapiopylib.rest.User import SapioUser
@@ -7,7 +9,7 @@ from sapiopylib.rest.pojo.CustomReport import CustomReportCriteria, RawReportTer
 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.webhook.WebhookContext import SapioWebhookContext
+from sapiopylib.rest.pojo.eln.SapioELNEnums import ElnBaseDataType
 from sapiopylib.rest.utils.autopaging import QueryDataRecordsAutoPager, QueryDataRecordByIdListAutoPager, \
     QueryAllRecordsOfTypeAutoPager
 from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
@@ -16,8 +18,10 @@ from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelMana
 from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType, WrappedRecordModel
 from sapiopylib.rest.utils.recordmodel.RelationshipPath import RelationshipPath, RelationshipNode, \
     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
 
@@ -32,16 +36,38 @@ class RecordHandler:
     rec_man: RecordModelManager
     inst_man: RecordModelInstanceManager
     rel_man: RecordModelRelationshipManager
+    an_man: RecordModelAncestorManager
+
+    __instances: WeakValueDictionary[SapioUser, RecordHandler] = WeakValueDictionary()
+    __initialized: bool
 
-    def __init__(self, context: SapioWebhookContext | SapioUser):
+    def __new__(cls, context: UserIdentifier):
         """
         :param context: The current webhook context or a user object to send requests from.
         """
+        user = AliasUtil.to_sapio_user(context)
+        obj = cls.__instances.get(user)
+        if not obj:
+            obj = object.__new__(cls)
+            obj.__initialized = False
+            cls.__instances[user] = obj
+        return obj
+
+    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
+
         self.user = context if isinstance(context, SapioUser) else context.user
         self.dr_man = DataRecordManager(self.user)
         self.rec_man = RecordModelManager(self.user)
         self.inst_man = self.rec_man.instance_manager
         self.rel_man = self.rec_man.relationship_manager
+        self.an_man = RecordModelAncestorManager(self.rec_man)
 
     def wrap_model(self, record: DataRecord, wrapper_type: type[WrappedType]) -> WrappedType:
         """
@@ -51,6 +77,7 @@ class RecordHandler:
         :param wrapper_type: The record model wrapper to use.
         :return: The record model for the input.
         """
+        self.__verify_data_type([record], wrapper_type)
         return self.inst_man.add_existing_record_of_type(record, wrapper_type)
 
     def wrap_models(self, records: Iterable[DataRecord], wrapper_type: type[WrappedType]) -> list[WrappedType]:
@@ -61,10 +88,11 @@ class RecordHandler:
         :param wrapper_type: The record model wrapper to use.
         :return: The record models for the input.
         """
+        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],
-                     page_limit: int | None = None) -> list[WrappedType]:
+    def query_models(self, wrapper_type: type[WrappedType], field: FieldIdentifier, value_list: Iterable[FieldValue],
+                     page_limit: int | None = None, page_size: int | None = None) -> list[WrappedType]:
         """
         Shorthand for using the data record manager to query for a list of data records by field value
         and then converting the results into a list of record models.
@@ -72,14 +100,20 @@ class RecordHandler:
         :param wrapper_type: The record model wrapper to use.
         :param field: The field to query on.
         :param value_list: The values of the field to query on.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
+            only functions if you set a page size or the platform enforces a page size.
+        :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
         :return: The record models for the queried records.
         """
-        return self.query_models_with_criteria(wrapper_type, field, value_list, None, page_limit)[0]
+        criteria: DataRecordPojoPageCriteria | None = None
+        if page_size is not None:
+            criteria = DataRecordPojoPageCriteria(page_size=page_size)
+        return self.query_models_with_criteria(wrapper_type, field, value_list, criteria, 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,
+                             page_size: 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.
@@ -87,17 +121,21 @@ class RecordHandler:
         :param wrapper_type: The record model wrapper to use.
         :param field: The field to query and map on.
         :param value_list: The values of the field to query on.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
+            only functions if you set a page size or the platform enforces a page size.
+        :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
         :param mapping_field: If provided, use this field to map against instead of the field that was queried on.
         :return: The record models for the queried records mapped by field values to the records with that value.
         """
         if mapping_field is None:
             mapping_field = field
-        return self.map_by_field(self.query_models(wrapper_type, field, value_list, page_limit), mapping_field)
+        return self.map_by_field(self.query_models(wrapper_type, field, value_list, page_limit, page_size),
+                                 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,
+                                    page_size: 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.
@@ -106,15 +144,19 @@ class RecordHandler:
         :param wrapper_type: The record model wrapper to use.
         :param field: The field to query and map on.
         :param value_list: The values of the field to query on.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
+            only functions if you set a page size or the platform enforces a page size.
+        :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
         :param mapping_field: If provided, use this field to map against instead of the field that was queried on.
         :return: The record models for the queried records mapped by field values to the record with that value.
         """
         if mapping_field is None:
             mapping_field = field
-        return self.map_by_unique_field(self.query_models(wrapper_type, field, value_list, page_limit), mapping_field)
+        return self.map_by_unique_field(self.query_models(wrapper_type, field, value_list, page_limit, page_size),
+                                        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]:
@@ -127,26 +169,33 @@ class RecordHandler:
         :param value_list: The values of the field to query on.
         :param paging_criteria: The paging criteria to start the query with.
         :param page_limit: The maximum number of pages to query from the starting criteria. If None, exhausts all
-            possible pages.
+            possible pages. This parameter only functions if you set a page size in the paging criteria or the platform
+            enforces a page size.
         :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
 
     def query_models_by_id(self, wrapper_type: type[WrappedType], ids: Iterable[int],
-                           page_limit: int | None = None) -> list[WrappedType]:
+                           page_limit: int | None = None, page_size: int | None = None) -> list[WrappedType]:
         """
         Shorthand for using the data record manager to query for a list of data records by record ID
         and then converting the results into a list of record models.
 
         :param wrapper_type: The record model wrapper to use.
         :param ids: The list of record IDs to query.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
+            only functions if you set a page size or the platform enforces a page size.
+        :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
         :return: The record models for the queried records.
         """
-        return self.query_models_by_id_with_criteria(wrapper_type, ids, None, page_limit)[0]
+        criteria: DataRecordPojoPageCriteria | None = None
+        if page_size is not None:
+            criteria = DataRecordPojoPageCriteria(page_size=page_size)
+        return self.query_models_by_id_with_criteria(wrapper_type, ids, criteria, page_limit)[0]
 
     def query_models_by_id_with_criteria(self, wrapper_type: type[WrappedType], ids: Iterable[int],
                                          paging_criteria: DataRecordPojoPageCriteria | None = None,
@@ -160,7 +209,8 @@ class RecordHandler:
         :param ids: The list of record IDs to query.
         :param paging_criteria: The paging criteria to start the query with.
         :param page_limit: The maximum number of pages to query from the starting criteria. If None, exhausts all
-            possible pages.
+            possible pages. This parameter only functions if you set a page size in the paging criteria or the platform
+            enforces a page size.
         :return: The record models for the queried records and the final paging criteria.
         """
         dt: str = wrapper_type.get_wrapper_data_type_name()
@@ -168,16 +218,38 @@ class RecordHandler:
         pager.max_page = page_limit
         return self.wrap_models(pager.get_all_at_once(), wrapper_type), pager.next_page_criteria
 
-    def query_all_models(self, wrapper_type: type[WrappedType], page_limit: int | None = None) -> list[WrappedType]:
+    def query_models_by_id_and_map(self, wrapper_type: type[WrappedType], ids: Iterable[int],
+                                   page_limit: int | None = None, page_size: int | None = None) \
+            -> dict[int, WrappedType]:
+        """
+        Shorthand for using the data record manager to query for a list of data records by record ID
+        and then converting the results into a dictionary of record ID to the record model for that ID.
+
+        :param wrapper_type: The record model wrapper to use.
+        :param ids: The list of record IDs to query.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
+            only functions if you set a page size or the platform enforces a page size.
+        :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
+        :return: The record models for the queried records mapped in a dictionary by their record ID.
+        """
+        return {x.record_id: x for x in self.query_models_by_id(wrapper_type, ids, page_limit, page_size)}
+
+    def query_all_models(self, wrapper_type: type[WrappedType], page_limit: int | None = None,
+                         page_size: int | None = None) -> list[WrappedType]:
         """
         Shorthand for using the data record manager to query for all data records of a given type
         and then converting the results into a list of record models.
 
         :param wrapper_type: The record model wrapper to use.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
+            only functions if you set a page size or the platform enforces a page size.
+        :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
         :return: The record models for the queried records.
         """
-        return self.query_all_models_with_criteria(wrapper_type, None, page_limit)[0]
+        criteria: DataRecordPojoPageCriteria | None = None
+        if page_size is not None:
+            criteria = DataRecordPojoPageCriteria(page_size=page_size)
+        return self.query_all_models_with_criteria(wrapper_type, criteria, page_limit)[0]
 
     def query_all_models_with_criteria(self, wrapper_type: type[WrappedType],
                                        paging_criteria: DataRecordPojoPageCriteria | None = None,
@@ -190,7 +262,8 @@ class RecordHandler:
         :param wrapper_type: The record model wrapper to use.
         :param paging_criteria: The paging criteria to start the query with.
         :param page_limit: The maximum number of pages to query from the starting criteria. If None, exhausts all
-            possible pages.
+            possible pages. This parameter only functions if you set a page size in the paging criteria or the platform
+            enforces a page size.
         :return: The record models for the queried records and the final paging criteria.
         """
         dt: str = wrapper_type.get_wrapper_data_type_name()
@@ -200,7 +273,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]:
@@ -228,11 +301,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.
@@ -243,8 +316,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.")
 
@@ -273,7 +346,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.
@@ -283,13 +357,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
@@ -312,6 +387,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.
@@ -338,7 +415,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
@@ -352,10 +429,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,
@@ -379,6 +458,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.
@@ -497,7 +578,7 @@ class RecordHandler:
 
     @staticmethod
     def map_by_child(models: Iterable[RecordModel], child_type: type[WrappedType]) \
-            -> dict[WrappedType, list[RecordModel]]:
+            -> dict[WrappedType, RecordModel]:
         """
         Take a list of record models and map them by their children. Essentially an inversion of map_to_child.
         If two records share the same child, an exception will be thrown. The children must already be loaded.
@@ -538,7 +619,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.
@@ -549,13 +630,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
@@ -568,6 +650,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]] = {}
@@ -578,7 +661,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
@@ -591,6 +674,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] = {}
@@ -604,7 +688,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
@@ -617,13 +701,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
@@ -636,6 +721,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)
@@ -646,7 +732,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
@@ -660,6 +746,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]] = {}
@@ -669,7 +756,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
@@ -683,6 +770,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] = {}
@@ -709,7 +797,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.
@@ -718,14 +807,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.
@@ -734,16 +825,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.
@@ -752,13 +844,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.
@@ -799,8 +892,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.
 
@@ -811,6 +904,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.
@@ -831,8 +926,6 @@ class RecordHandler:
         path, if any. The hierarchy must be linear (1:1 relationship between data types at every step) and the
         relationship path must already be loaded.
 
-        Currently, the relationship path may only contain parent/child nodes.
-
         :param models: A list of record models.
         :param path: The relationship path to follow.
         :param wrapper_type: The record model wrapper to use.
@@ -843,15 +936,44 @@ class RecordHandler:
         # PR-46832: Update path traversal to account for changes to RelationshipPath in Sapiopylib.
         path: list[RelationshipNode] = path.path
         for model in models:
-            current: PyRecordModel = model if isinstance(model, PyRecordModel) else model.backing_model
+            current: PyRecordModel | None = model if isinstance(model, PyRecordModel) else model.backing_model
             for node in path:
-                direction = node.direction
+                data_type: str = node.data_type_name
+                direction: RelationshipNodeType = node.direction
                 if current is None:
                     break
                 if direction == RelationshipNodeType.CHILD:
-                    current = current.get_child_of_type(node.data_type_name)
+                    current = current.get_child_of_type(data_type)
                 elif direction == RelationshipNodeType.PARENT:
-                    current = current.get_parent_of_type(node.data_type_name)
+                    current = current.get_parent_of_type(data_type)
+                elif direction == RelationshipNodeType.ANCESTOR:
+                    ancestors: list[PyRecordModel] = list(self.an_man.get_ancestors_of_type(current, data_type))
+                    if not ancestors:
+                        current = None
+                    elif len(ancestors) > 1:
+                        raise SapioException(f"Hierarchy contains multiple ancestors of type {data_type}.")
+                    else:
+                        current = ancestors[0]
+                elif direction == RelationshipNodeType.DESCENDANT:
+                    descendants: list[PyRecordModel] = list(self.an_man.get_descendant_of_type(current, data_type))
+                    if not descendants:
+                        current = None
+                    elif len(descendants) > 1:
+                        raise SapioException(f"Hierarchy contains multiple descendants of type {data_type}.")
+                    else:
+                        current = descendants[0]
+                elif direction == RelationshipNodeType.FORWARD_SIDE_LINK:
+                    current = current.get_forward_side_link(node.data_field_name)
+                elif direction == RelationshipNodeType.REVERSE_SIDE_LINK:
+                    field_name: str = node.data_field_name
+                    reverse_links: list[PyRecordModel] = current.get_reverse_side_link(field_name, data_type)
+                    if not reverse_links:
+                        current = None
+                    elif len(reverse_links) > 1:
+                        raise SapioException(f"Hierarchy contains multiple reverse links of type {data_type} on field "
+                                             f"{field_name}.")
+                    else:
+                        current = reverse_links[0]
                 else:
                     raise SapioException("Unsupported path direction.")
             ret_dict.update({model: self.inst_man.wrap(current, wrapper_type) if current else None})
@@ -864,8 +986,6 @@ class RecordHandler:
         path, if any. The hierarchy may be non-linear (1:Many relationships between data types are allowed) and the
         relationship path must already be loaded.
 
-        Currently, the relationship path may only contain parent/child nodes.
-
         :param models: A list of record models.
         :param path: The relationship path to follow.
         :param wrapper_type: The record model wrapper to use.
@@ -880,14 +1000,23 @@ class RecordHandler:
             next_search: set[PyRecordModel] = set()
             # Exhaust the records at each step in the path, then use those records for the next step.
             for node in path:
-                direction = node.direction
+                data_type: str = node.data_type_name
+                direction: RelationshipNodeType = node.direction
                 if len(current_search) == 0:
                     break
                 for search in current_search:
                     if direction == RelationshipNodeType.CHILD:
-                        next_search.update(search.get_children_of_type(node.data_type_name))
+                        next_search.update(search.get_children_of_type(data_type))
                     elif direction == RelationshipNodeType.PARENT:
-                        next_search.update(search.get_parents_of_type(node.data_type_name))
+                        next_search.update(search.get_parents_of_type(data_type))
+                    elif direction == RelationshipNodeType.ANCESTOR:
+                        next_search.update(self.an_man.get_ancestors_of_type(search, data_type))
+                    elif direction == RelationshipNodeType.DESCENDANT:
+                        next_search.update(self.an_man.get_descendant_of_type(search, data_type))
+                    elif direction == RelationshipNodeType.FORWARD_SIDE_LINK:
+                        next_search.add(search.get_forward_side_link(node.data_field_name))
+                    elif direction == RelationshipNodeType.REVERSE_SIDE_LINK:
+                        next_search.update(search.get_reverse_side_link(node.data_field_name, data_type))
                     else:
                         raise SapioException("Unsupported path direction.")
                 current_search = next_search
@@ -908,8 +1037,6 @@ class RecordHandler:
         relationships (e.g. a sample which is aliquoted to a number of samples, then those aliquots are pooled back
         together into a single sample).
 
-        Currently, the relationship path may only contain parent/child nodes.
-
         :param models: A list of record models.
         :param path: The relationship path to follow.
         :param wrapper_type: The record model wrapper to use.
@@ -922,20 +1049,29 @@ class RecordHandler:
         for model in models:
             current: list[PyRecordModel] = [model if isinstance(model, PyRecordModel) else model.backing_model]
             for node in path:
-                direction = node.direction
+                data_type: str = node.data_type_name
+                direction: RelationshipNodeType = node.direction
                 if len(current) == 0:
                     break
                 if direction == RelationshipNodeType.CHILD:
-                    current = current[0].get_children_of_type(node.data_type_name)
+                    current = current[0].get_children_of_type(data_type)
                 elif direction == RelationshipNodeType.PARENT:
-                    current = current[0].get_parents_of_type(node.data_type_name)
+                    current = current[0].get_parents_of_type(data_type)
+                elif direction == RelationshipNodeType.ANCESTOR:
+                    current = list(self.an_man.get_ancestors_of_type(current[0], data_type))
+                elif direction == RelationshipNodeType.DESCENDANT:
+                    current = list(self.an_man.get_descendant_of_type(current[0], data_type))
+                elif direction == RelationshipNodeType.FORWARD_SIDE_LINK:
+                    current = [current[0].get_forward_side_link(node.data_field_name)]
+                elif direction == RelationshipNodeType.REVERSE_SIDE_LINK:
+                    current = current[0].get_reverse_side_link(node.data_field_name, data_type)
                 else:
                     raise SapioException("Unsupported path direction.")
             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
@@ -959,3 +1095,18 @@ class RecordHandler:
                                          f"encountered in system that matches all provided identifiers.")
                 unique_record = result
         return unique_record
+
+    @staticmethod
+    def __verify_data_type(records: Iterable[DataRecord], wrapper_type: type[WrappedType]) -> None:
+        """
+        Throw an exception if the data type of the given records and wrapper don't match.
+        """
+        model_type: str = wrapper_type.get_wrapper_data_type_name()
+        for record in records:
+            record_type: str = record.data_type_name
+            # Account for ELN data type records.
+            if ElnBaseDataType.is_eln_type(record_type):
+                record_type = ElnBaseDataType.get_base_type(record_type).data_type_name
+            if record_type != model_type:
+                raise SapioException(f"Data record of type {record_type} cannot be wrapped by the record model wrapper "
+                                     f"of type {model_type}")