sapiopycommons 2025.7.10a595__py3-none-any.whl → 2025.7.15a611__py3-none-any.whl

sapiopycommons/recordmodel/record_handler.py

@@ -3,9 +3,13 @@ from __future__ import annotations
 import io
 import warnings
 from collections.abc import Iterable
-from typing import Collection
+from typing import Collection, TypeVar, TypeAlias
 from weakref import WeakValueDictionary
 
+from sapiopycommons.general.aliases import RecordModel, SapioRecord, FieldMap, FieldIdentifier, AliasUtil, \
+    FieldIdentifierMap, FieldValue, UserIdentifier, FieldIdentifierKey, DataTypeIdentifier
+from sapiopycommons.general.custom_report_util import CustomReportUtil
+from sapiopycommons.general.exceptions import SapioException
 from sapiopylib.rest.DataRecordManagerService import DataRecordManager
 from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.CustomReport import CustomReportCriteria, RawReportTerm, ReportColumn
@@ -24,19 +28,23 @@ from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedType, Wr
 from sapiopylib.rest.utils.recordmodel.RelationshipPath import RelationshipPath, RelationshipNode, \
     RelationshipNodeType
 from sapiopylib.rest.utils.recordmodel.ancestry import RecordModelAncestorManager
-from sapiopylib.rest.utils.recordmodel.properties import Parents, Parent, Children, Child, ForwardSideLink
-
-from sapiopycommons.general.aliases import RecordModel, SapioRecord, FieldMap, FieldIdentifier, AliasUtil, \
-    FieldIdentifierMap, FieldValue, UserIdentifier, FieldIdentifierKey, DataTypeIdentifier
-from sapiopycommons.general.custom_report_util import CustomReportUtil
-from sapiopycommons.general.exceptions import SapioException
+from sapiopylib.rest.utils.recordmodel.properties import Parents, Parent, Children, Child, ForwardSideLink, \
+    ReverseSideLink
 
 # Aliases for longer name.
-_PropertyGetter = AbstractRecordModelPropertyGetter
-_PropertyAdder = AbstractRecordModelPropertyAdder
-_PropertyRemover = AbstractRecordModelPropertyRemover
-_PropertySetter = AbstractRecordModelPropertySetter
-_PropertyType = RecordModelPropertyType
+_PropertyGetter: TypeAlias = AbstractRecordModelPropertyGetter
+_PropertyAdder: TypeAlias = AbstractRecordModelPropertyAdder
+_PropertyRemover: TypeAlias = AbstractRecordModelPropertyRemover
+_PropertySetter: TypeAlias = AbstractRecordModelPropertySetter
+_PropertyType: TypeAlias = RecordModelPropertyType
+
+# CR-47717: Use TypeVars in the type hints of certain functions to prevent PyCharm from erroneously flagging certain
+# return type hints as incorrect.
+IsRecordModel = TypeVar('IsRecordModel', bound=RecordModel)
+"""A PyRecordModel or AbstractRecordModel."""
+IsSapioRecord = TypeVar('IsSapioRecord', bound=SapioRecord)
+"""A DataRecord, PyRecordModel, or AbstractRecordModel."""
+
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
 # FR-47575 - Reordered functions so that the Java and Python versions are as close to each other as possible.
@@ -524,9 +532,11 @@ class RecordHandler:
         """
         warnings.warn("Deprecated in favor of the [System/Custom/Quick]ReportRecordAutoPager classes.", DeprecationWarning)
         if isinstance(report_name, str):
+            # noinspection PyDeprecation
             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):
+            # noinspection PyDeprecation
             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):
@@ -539,6 +549,7 @@ 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))
+            # noinspection PyDeprecation
             results: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(self.user, report_name, filters,
                                                                                       page_limit, page_size, page_number)
         else:
@@ -551,7 +562,7 @@ class RecordHandler:
         return self.query_models_by_id(wrapper_type, ids)
 
     @staticmethod
-    def map_by_id(models: Iterable[SapioRecord]) -> dict[int, SapioRecord]:
+    def map_by_id(models: Iterable[IsSapioRecord]) -> dict[int, IsSapioRecord]:
         """
         Map the given records their record IDs.
 
@@ -560,12 +571,12 @@ class RecordHandler:
         """
         ret_dict: dict[int, SapioRecord] = {}
         for model in models:
-            ret_dict.update({model.record_id: model})
+            ret_dict.update({AliasUtil.to_record_id(model): model})
         return ret_dict
 
     @staticmethod
-    def map_by_field(models: Iterable[SapioRecord], field_name: FieldIdentifier) \
-            -> dict[FieldValue, list[SapioRecord]]:
+    def map_by_field(models: Iterable[IsSapioRecord], field_name: FieldIdentifier) \
+            -> dict[FieldValue, list[IsSapioRecord]]:
         """
         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.
@@ -582,8 +593,8 @@ class RecordHandler:
         return ret_dict
 
     @staticmethod
-    def map_by_unique_field(models: Iterable[SapioRecord], field_name: FieldIdentifier) \
-            -> dict[FieldValue, SapioRecord]:
+    def map_by_unique_field(models: Iterable[IsSapioRecord], field_name: FieldIdentifier) \
+            -> dict[FieldValue, IsSapioRecord]:
         """
         Uniquely map the given records by one of their fields. If any two records share the same field value, throws
         an exception.
@@ -662,7 +673,7 @@ class RecordHandler:
         return RecordHandler.sum_of_field(models, field_name) / len(models)
 
     @staticmethod
-    def get_newest_record(records: Iterable[SapioRecord]) -> SapioRecord:
+    def get_newest_record(records: Iterable[IsSapioRecord]) -> IsSapioRecord:
         """
         Get the newest record from a list of records.
 
@@ -673,7 +684,7 @@ class RecordHandler:
 
     # FR-46696: Add a function for getting the oldest record in a list, just like we have one for the newest record.
     @staticmethod
-    def get_oldest_record(records: Iterable[SapioRecord]) -> SapioRecord:
+    def get_oldest_record(records: Iterable[IsSapioRecord]) -> IsSapioRecord:
         """
         Get the oldest record from a list of records.
 
@@ -683,7 +694,7 @@ class RecordHandler:
         return min(records, key=lambda x: x.record_id)
 
     @staticmethod
-    def get_min_record(records: list[RecordModel], field: FieldIdentifier) -> RecordModel:
+    def get_min_record(records: list[IsSapioRecord], field: FieldIdentifier) -> IsSapioRecord:
         """
         Get the record model with the minimum value of a given field from a list of record models.
 
@@ -695,7 +706,7 @@ class RecordHandler:
         return min(records, key=lambda x: x.get_field_value(field))
 
     @staticmethod
-    def get_max_record(records: list[RecordModel], field: FieldIdentifier) -> RecordModel:
+    def get_max_record(records: list[IsSapioRecord], field: FieldIdentifier) -> IsSapioRecord:
         """
         Get the record model with the maximum value of a given field from a list of record models.
 
@@ -870,7 +881,7 @@ class RecordHandler:
         parent_dt: str = AliasUtil.to_data_type_name(parent_type)
         wrapper: type[WrappedType] | None = parent_type if isinstance(parent_type, type) else None
         record: PyRecordModel = RecordModelInstanceManager.unwrap(record)
-        parent: PyRecordModel | None = record.get_parent_of_type(parent_dt)
+        parent: PyRecordModel | None = record.get(Parent.of_type_name(parent_dt))
         if parent is not None:
             return self.wrap_model(parent, wrapper) if wrapper else parent
         return record.add(Parent.create(wrapper)) if wrapper else record.add(Parent.create_by_name(parent_dt))
@@ -888,7 +899,7 @@ class RecordHandler:
         child_dt: str = AliasUtil.to_data_type_name(child_type)
         wrapper: type[WrappedType] | None = child_type if isinstance(child_type, type) else None
         record: PyRecordModel = RecordModelInstanceManager.unwrap(record)
-        child: PyRecordModel | None = record.get_child_of_type(child_dt)
+        child: PyRecordModel | None = record.get(Child.of_type_name(child_dt))
         if child is not None:
             return self.wrap_model(child, wrapper) if wrapper else child
         return record.add(Child.create(wrapper)) if wrapper else record.add(Child.create_by_name(child_dt))
@@ -908,7 +919,7 @@ class RecordHandler:
         side_link_field: str = AliasUtil.to_data_field_name(side_link_field)
         wrapper: type[WrappedType] | None = side_link_type if isinstance(side_link_type, type) else None
         record: PyRecordModel = RecordModelInstanceManager.unwrap(record)
-        side_link: PyRecordModel | None = record.get_forward_side_link(side_link_field)
+        side_link: PyRecordModel | None = record.get(ForwardSideLink.of(side_link_field))
         if side_link is not None:
             return self.wrap_model(side_link, wrapper) if wrapper else side_link
         side_link: WrappedType | PyRecordModel = self.add_model(side_link_type)
@@ -955,52 +966,63 @@ class RecordHandler:
             if child not in children:
                 record.remove(Child.ref(child))
 
+    # CR-47717: Update the map_[to/by]_[relationship] functions to allow PyRecordModels to be provided and returned
+    # instead of only using WrappedRecordModels and wrapper types.
     @staticmethod
-    def map_to_parent(models: Iterable[WrappedRecordModel], parent_type: type[WrappedType])\
-            -> dict[WrappedRecordModel, WrappedType]:
+    def map_to_parent(models: Iterable[IsRecordModel], parent_type: type[WrappedType] | str) \
+            -> dict[IsRecordModel, WrappedType | PyRecordModel]:
         """
         Map a list of record models to a single parent of a given type. The parents must already be loaded.
 
         :param models: A list of record models.
-        :param parent_type: The record model wrapper of the parent.
+        :param parent_type: The record model wrapper or data type name of the parents. If a data type name is
+            provided, the returned records will be PyRecordModels instead of WrappedRecordModels.
         :return: A dict[ModelType, ParentType]. If an input model doesn't have a parent of the given parent type, then
             it will map to None.
         """
-        return_dict: dict[WrappedRecordModel, WrappedType] = {}
+        return_dict: dict[RecordModel, WrappedType | PyRecordModel] = {}
         for model in models:
-            return_dict[model] = model.get_parent_of_type(parent_type)
+            if isinstance(parent_type, str):
+                return_dict[model] = model.get(Parent.of_type_name(parent_type))
+            else:
+                return_dict[model] = model.get(Parent.of_type(parent_type))
         return return_dict
 
     @staticmethod
-    def map_to_parents(models: Iterable[WrappedRecordModel], parent_type: type[WrappedType]) \
-            -> dict[WrappedRecordModel, list[WrappedType]]:
+    def map_to_parents(models: Iterable[IsRecordModel], parent_type: type[WrappedType] | str) \
+            -> dict[IsRecordModel, list[WrappedType] | list[PyRecordModel]]:
         """
         Map a list of record models to a list parents of a given type. The parents must already be loaded.
 
         :param models: A list of record models.
-        :param parent_type: The record model wrapper of the parents.
+        :param parent_type: The record model wrapper or data type name of the parents. If a data type name is
+            provided, the returned records will be PyRecordModels instead of WrappedRecordModels.
         :return: A dict[ModelType, list[ParentType]]. If an input model doesn't have a parent of the given parent type,
             then it will map to an empty list.
         """
-        return_dict: dict[WrappedRecordModel, list[WrappedType]] = {}
+        return_dict: dict[WrappedRecordModel, list[WrappedType] | list[PyRecordModel]] = {}
         for model in models:
-            return_dict[model] = model.get_parents_of_type(parent_type)
+            if isinstance(parent_type, str):
+                return_dict[model] = model.get(Parents.of_type_name(parent_type))
+            else:
+                return_dict[model] = model.get(Parents.of_type(parent_type))
         return return_dict
 
     @staticmethod
-    def map_by_parent(models: Iterable[WrappedRecordModel], parent_type: type[WrappedType]) \
-            -> dict[WrappedType, WrappedRecordModel]:
+    def map_by_parent(models: Iterable[IsRecordModel], parent_type: type[WrappedType] | str) \
+            -> dict[WrappedType | PyRecordModel, IsRecordModel]:
         """
         Take a list of record models and map them by their parent. Essentially an inversion of map_to_parent.
         If two records share the same parent, an exception will be thrown. The parents must already be loaded.
 
         :param models: A list of record models.
-        :param parent_type: The record model wrapper of the parents.
+        :param parent_type: The record model wrapper or data type name of the parents. If a data type name is
+            provided, the returned records will be PyRecordModels instead of WrappedRecordModels.
         :return: A dict[ParentType, ModelType]. If an input model doesn't have a parent of the given parent type,
             then it will not be in the resulting dictionary.
         """
-        to_parent: dict[WrappedRecordModel, WrappedType] = RecordHandler.map_to_parent(models, parent_type)
-        by_parent: dict[WrappedType, WrappedRecordModel] = {}
+        to_parent: dict[RecordModel, WrappedType | PyRecordModel] = RecordHandler.map_to_parent(models, parent_type)
+        by_parent: dict[WrappedType | PyRecordModel, RecordModel] = {}
         for record, parent in to_parent.items():
             if parent is None:
                 continue
@@ -1011,70 +1033,81 @@ class RecordHandler:
         return by_parent
 
     @staticmethod
-    def map_by_parents(models: Iterable[WrappedRecordModel], parent_type: type[WrappedType]) \
-            -> dict[WrappedType, list[WrappedRecordModel]]:
+    def map_by_parents(models: Iterable[IsRecordModel], parent_type: type[WrappedType] | str) \
+            -> dict[WrappedType | PyRecordModel, list[IsRecordModel]]:
         """
         Take a list of record models and map them by their parents. Essentially an inversion of map_to_parents. Input
         models that share a parent will end up in the same list. The parents must already be loaded.
 
         :param models: A list of record models.
-        :param parent_type: The record model wrapper of the parents.
+        :param parent_type: The record model wrapper or data type name of the parents. If a data type name is
+            provided, the returned records will be PyRecordModels instead of WrappedRecordModels.
         :return: A dict[ParentType, list[ModelType]]. If an input model doesn't have a parent of the given parent type,
             then it will not be in the resulting dictionary.
         """
-        to_parents: dict[WrappedRecordModel, list[WrappedType]] = RecordHandler.map_to_parents(models, parent_type)
-        by_parents: dict[WrappedType, list[WrappedRecordModel]] = {}
+        to_parents: dict[RecordModel, list[WrappedType] | list[PyRecordModel]] = RecordHandler\
+            .map_to_parents(models, parent_type)
+        by_parents: dict[WrappedType | PyRecordModel, list[RecordModel]] = {}
         for record, parents in to_parents.items():
             for parent in parents:
                 by_parents.setdefault(parent, []).append(record)
         return by_parents
 
     @staticmethod
-    def map_to_child(models: Iterable[WrappedRecordModel], child_type: type[WrappedType])\
-            -> dict[WrappedRecordModel, WrappedType]:
+    def map_to_child(models: Iterable[IsRecordModel], child_type: type[WrappedType] | str) \
+            -> dict[IsRecordModel, WrappedType | PyRecordModel]:
         """
         Map a list of record models to a single child of a given type. The children must already be loaded.
 
         :param models: A list of record models.
-        :param child_type: The record model wrapper of the child.
+        :param child_type: The record model wrapper or data type name of the children. If a data type name is
+            provided, the returned records will be PyRecordModels instead of WrappedRecordModels.
         :return: A dict[ModelType, ChildType]. If an input model doesn't have a child of the given child type, then
             it will map to None.
         """
-        return_dict: dict[WrappedRecordModel, WrappedType] = {}
+        return_dict: dict[RecordModel, WrappedType | PyRecordModel] = {}
         for model in models:
-            return_dict[model] = model.get_child_of_type(child_type)
+            if isinstance(child_type, str):
+                return_dict[model] = model.get(Child.of_type_name(child_type))
+            else:
+                return_dict[model] = model.get(Child.of_type(child_type))
         return return_dict
 
     @staticmethod
-    def map_to_children(models: Iterable[WrappedRecordModel], child_type: type[WrappedType]) \
-            -> dict[WrappedRecordModel, list[WrappedType]]:
+    def map_to_children(models: Iterable[IsRecordModel], child_type: type[WrappedType] | str) \
+            -> dict[IsRecordModel, list[WrappedType] | PyRecordModel]:
         """
         Map a list of record models to a list children of a given type. The children must already be loaded.
 
         :param models: A list of record models.
-        :param child_type: The record model wrapper of the children.
+        :param child_type: The record model wrapper or data type name of the children. If a data type name is
+            provided, the returned records will be PyRecordModels instead of WrappedRecordModels.
         :return: A dict[ModelType, list[ChildType]]. If an input model doesn't have children of the given child type,
             then it will map to an empty list.
         """
-        return_dict: dict[WrappedRecordModel, list[WrappedType]] = {}
+        return_dict: dict[RecordModel, list[WrappedType] | list[PyRecordModel]] = {}
         for model in models:
-            return_dict[model] = model.get_children_of_type(child_type)
+            if isinstance(child_type, str):
+                return_dict[model] = model.get(Children.of_type_name(child_type))
+            else:
+                return_dict[model] = model.get(Children.of_type(child_type))
         return return_dict
 
     @staticmethod
-    def map_by_child(models: Iterable[WrappedRecordModel], child_type: type[WrappedType]) \
-            -> dict[WrappedType, WrappedRecordModel]:
+    def map_by_child(models: Iterable[IsRecordModel], child_type: type[WrappedType] | str) \
+            -> dict[WrappedType | str, IsRecordModel]:
         """
         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.
 
         :param models: A list of record models.
-        :param child_type: The record model wrapper of the children.
+        :param child_type: The record model wrapper or data type name of the children. If a data type name is
+            provided, the returned records will be PyRecordModels instead of WrappedRecordModels.
         :return: A dict[ChildType, ModelType]. If an input model doesn't have a child of the given child type,
             then it will not be in the resulting dictionary.
         """
-        to_child: dict[WrappedRecordModel, WrappedType] = RecordHandler.map_to_child(models, child_type)
-        by_child: dict[WrappedType, WrappedRecordModel] = {}
+        to_child: dict[RecordModel, WrappedType | PyRecordModel] = RecordHandler.map_to_child(models, child_type)
+        by_child: dict[WrappedType | PyRecordModel, RecordModel] = {}
         for record, child in to_child.items():
             if child is None:
                 continue
@@ -1085,45 +1118,50 @@ class RecordHandler:
         return by_child
 
     @staticmethod
-    def map_by_children(models: Iterable[WrappedRecordModel], child_type: type[WrappedType]) \
-            -> dict[WrappedType, list[WrappedRecordModel]]:
+    def map_by_children(models: Iterable[IsRecordModel], child_type: type[WrappedType] | str) \
+            -> dict[WrappedType | PyRecordModel, list[IsRecordModel]]:
         """
         Take a list of record models and map them by their children. Essentially an inversion of map_to_children. Input
         models that share a child will end up in the same list. The children must already be loaded.
 
         :param models: A list of record models.
-        :param child_type: The record model wrapper of the children.
+        :param child_type: The record model wrapper or data type name of the children. If a data type name is
+            provided, the returned records will be PyRecordModels instead of WrappedRecordModels.
         :return: A dict[ChildType, list[ModelType]]. If an input model doesn't have children of the given child type,
             then it will not be in the resulting dictionary.
         """
-        to_children: dict[WrappedRecordModel, list[WrappedType]] = RecordHandler.map_to_children(models, child_type)
-        by_children: dict[WrappedType, list[WrappedRecordModel]] = {}
+        to_children: dict[RecordModel, list[WrappedType] | list[PyRecordModel]] = RecordHandler\
+            .map_to_children(models, child_type)
+        by_children: dict[WrappedType | PyRecordModel, list[RecordModel]] = {}
         for record, children in to_children.items():
             for child in children:
                 by_children.setdefault(child, []).append(record)
         return by_children
 
     @staticmethod
-    def map_to_forward_side_link(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
-                                 side_link_type: type[WrappedType]) -> dict[WrappedRecordModel, WrappedType]:
+    def map_to_forward_side_link(models: Iterable[IsRecordModel], field_name: FieldIdentifier,
+                                 side_link_type: type[WrappedType] | None) \
+            -> dict[IsRecordModel, WrappedType | PyRecordModel]:
         """
         Map a list of record models to their forward side link. The forward side link must already be loaded.
 
         :param models: A list of record models.
         :param field_name: The field name on the record models where the side link is located.
-        :param side_link_type: The record model wrapper of the forward side link.
+        :param side_link_type: The record model wrapper of the forward side link. If None, the side links will
+            be returned as PyRecordModels instead of WrappedRecordModels.
         :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] = {}
+        return_dict: dict[RecordModel, WrappedType | PyRecordModel] = {}
         for model in models:
-            return_dict[model] = model.get_forward_side_link(field_name, side_link_type)
+            return_dict[model] = model.get(ForwardSideLink.of(field_name, side_link_type))
         return return_dict
 
     @staticmethod
-    def map_by_forward_side_link(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
-                                 side_link_type: type[WrappedType]) -> dict[WrappedType, WrappedRecordModel]:
+    def map_by_forward_side_link(models: Iterable[IsRecordModel], field_name: FieldIdentifier,
+                                 side_link_type: type[WrappedType] | None) \
+            -> dict[WrappedType | PyRecordModel, IsRecordModel]:
         """
         Take a list of record models and map them by their forward side link. Essentially an inversion of
         map_to_forward_side_link, but if two records share the same forward link, an exception is thrown.
@@ -1131,14 +1169,15 @@ class RecordHandler:
 
         :param models: A list of record models.
         :param field_name: The field name on the record models where the side link is located.
-        :param side_link_type: The record model wrapper of the forward side links.
+        :param side_link_type: The record model wrapper of the forward side links. If None, the side links will
+            be returned as PyRecordModels instead of WrappedRecordModels.
         :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\
+        to_side_link: dict[RecordModel, WrappedType | PyRecordModel] = RecordHandler\
             .map_to_forward_side_link(models, field_name, side_link_type)
-        by_side_link: dict[WrappedType, WrappedRecordModel] = {}
+        by_side_link: dict[WrappedType | PyRecordModel, RecordModel] = {}
         for record, side_link in to_side_link.items():
             if side_link is None:
                 continue
@@ -1149,8 +1188,9 @@ class RecordHandler:
         return by_side_link
 
     @staticmethod
-    def map_by_forward_side_links(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
-                                  side_link_type: type[WrappedType]) -> dict[WrappedType, list[WrappedRecordModel]]:
+    def map_by_forward_side_links(models: Iterable[IsRecordModel], field_name: FieldIdentifier,
+                                  side_link_type: type[WrappedType] | None) \
+            -> dict[WrappedType | PyRecordModel, list[IsRecordModel]]:
         """
         Take a list of record models and map them by their forward side link. Essentially an inversion of
         map_to_forward_side_link. Input models that share a forward side link will end up in the same list.
@@ -1158,14 +1198,15 @@ class RecordHandler:
 
         :param models: A list of record models.
         :param field_name: The field name on the record models where the side link is located.
-        :param side_link_type: The record model wrapper of the forward side links.
+        :param side_link_type: The record model wrapper of the forward side links. If None, the side links will
+            be returned as PyRecordModels instead of WrappedRecordModels.
         :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\
+        to_side_link: dict[RecordModel, WrappedType | PyRecordModel] = RecordHandler\
             .map_to_forward_side_link(models, field_name, side_link_type)
-        by_side_link: dict[WrappedType, list[WrappedRecordModel]] = {}
+        by_side_link: dict[WrappedType | PyRecordModel, list[RecordModel]] = {}
         for record, side_link in to_side_link.items():
             if side_link is None:
                 continue
@@ -1173,8 +1214,9 @@ class RecordHandler:
         return by_side_link
 
     @staticmethod
-    def map_to_reverse_side_link(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
-                                 side_link_type: type[WrappedType]) -> dict[WrappedRecordModel, WrappedType]:
+    def map_to_reverse_side_link(models: Iterable[IsRecordModel], field_name: FieldIdentifier,
+                                 side_link_type: type[WrappedType] | str) \
+            -> dict[IsRecordModel, WrappedType | PyRecordModel]:
         """
         Map a list of record models to the reverse side link of a given type. If a given record has more than one
         reverse side link of this type, an exception is thrown. The reverse side links must already be loaded.
@@ -1182,14 +1224,18 @@ class RecordHandler:
         :param models: A list of record models.
         :param field_name: The field name on the side linked model where the side link to the given record models is
             located.
-        :param side_link_type: The record model wrapper of the reverse side links.
+        :param side_link_type: The record model wrapper or data type name of the reverse side links. If a data type
+            name is provided, the returned records will be PyRecordModels instead of WrappedRecordModels.
         :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] = {}
+        return_dict: dict[RecordModel, WrappedType | PyRecordModel] = {}
         for model in models:
-            links: list[WrappedType] = model.get_reverse_side_link(field_name, side_link_type)
+            if isinstance(side_link_type, str):
+                links: list[WrappedType] = model.get(ReverseSideLink.of(side_link_type, field_name))
+            else:
+                links: list[WrappedType] = model.get(ReverseSideLink.of_type(side_link_type, field_name))
             if len(links) > 1:
                 raise SapioException(f"Model {model.data_type_name} {model.record_id} has more than one reverse link "
                                      f"of type {side_link_type.get_wrapper_data_type_name()}.")
@@ -1197,8 +1243,9 @@ class RecordHandler:
         return return_dict
 
     @staticmethod
-    def map_to_reverse_side_links(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
-                                  side_link_type: type[WrappedType]) -> dict[WrappedRecordModel, list[WrappedType]]:
+    def map_to_reverse_side_links(models: Iterable[IsRecordModel], field_name: FieldIdentifier,
+                                  side_link_type: type[WrappedType] | str) \
+            -> dict[IsRecordModel, list[WrappedType] | list[PyRecordModel]]:
         """
         Map a list of record models to a list reverse side links of a given type. The reverse side links must already
         be loaded.
@@ -1206,19 +1253,24 @@ class RecordHandler:
         :param models: A list of record models.
         :param field_name: The field name on the side linked model where the side link to the given record models is
             located.
-        :param side_link_type: The record model wrapper of the reverse side links.
+        :param side_link_type: The record model wrapper or data type name of the reverse side links. If a data type
+            name is provided, the returned records will be PyRecordModels instead of WrappedRecordModels.
         :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]] = {}
+        return_dict: dict[RecordModel, list[WrappedType] | list[PyRecordModel]] = {}
         for model in models:
-            return_dict[model] = model.get_reverse_side_link(field_name, side_link_type)
+            if isinstance(side_link_type, str):
+                return_dict[model] = model.get(ReverseSideLink.of(side_link_type, field_name))
+            else:
+                return_dict[model] = model.get(ReverseSideLink.of_type(side_link_type, field_name))
         return return_dict
 
     @staticmethod
-    def map_by_reverse_side_link(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
-                                 side_link_type: type[WrappedType]) -> dict[WrappedType, WrappedRecordModel]:
+    def map_by_reverse_side_link(models: Iterable[IsRecordModel], field_name: FieldIdentifier,
+                                 side_link_type: type[WrappedType] | str) \
+            -> dict[WrappedType | PyRecordModel, IsRecordModel]:
         """
         Take a list of record models and map them by their reverse side link. Essentially an inversion of
         map_to_reverse_side_link. If two records share the same reverse side link, an exception is thrown.
@@ -1227,14 +1279,15 @@ class RecordHandler:
         :param models: A list of record models.
         :param field_name: The field name on the side linked model where the side link to the given record models is
             located.
-        :param side_link_type: The record model wrapper of the reverse side links.
+        :param side_link_type: The record model wrapper or data type name of the reverse side links. If a data type
+            name is provided, the returned records will be PyRecordModels instead of WrappedRecordModels.
         :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\
+        to_side_link: dict[RecordModel, WrappedType | PyRecordModel] = RecordHandler\
             .map_to_reverse_side_link(models, field_name, side_link_type)
-        by_side_link: dict[WrappedType, WrappedRecordModel] = {}
+        by_side_link: dict[WrappedType | PyRecordModel, RecordModel] = {}
         for record, side_link in to_side_link.items():
             if side_link is None:
                 continue
@@ -1245,8 +1298,8 @@ class RecordHandler:
         return by_side_link
 
     @staticmethod
-    def map_by_reverse_side_links(models: Iterable[WrappedRecordModel], field_name: FieldIdentifier,
-                                  side_link_type: type[WrappedType]) -> dict[WrappedType, list[WrappedRecordModel]]:
+    def map_by_reverse_side_links(models: Iterable[IsRecordModel], field_name: FieldIdentifier,
+                                  side_link_type: type[WrappedType] | str) -> dict[WrappedType | PyRecordModel, list[IsRecordModel]]:
         """
         Take a list of record models and map them by their reverse side links. Essentially an inversion of
         map_to_reverse_side_links. Input models that share a reverse side link will end up in the same list.
@@ -1255,7 +1308,8 @@ class RecordHandler:
         :param models: A list of record models.
         :param field_name: The field name on the side linked model where the side link to the given record models is
             located.
-        :param side_link_type: The record model wrapper of the reverse side links.
+        :param side_link_type: The record model wrapper or data type name of the reverse side links. If a data type
+            name is provided, the returned records will be PyRecordModels instead of WrappedRecordModels.
         :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.
         """
@@ -1270,9 +1324,9 @@ class RecordHandler:
 
     # FR-46155: Update relationship path traversing functions to be non-static and take in a wrapper type so that the
     # output can be wrapped instead of requiring the user to wrap the output.
-    def get_linear_path(self, models: Iterable[RecordModel], path: RelationshipPath,
+    def get_linear_path(self, models: Iterable[IsRecordModel], path: RelationshipPath,
                         wrapper_type: type[WrappedType] | None = None) \
-            -> dict[RecordModel, WrappedType | PyRecordModel | None]:
+            -> dict[IsRecordModel, WrappedType | PyRecordModel | None]:
         """
         Given a relationship path, travel the path starting from the input models. Returns the record at the end of the
         path, if any. The hierarchy must be linear (1:1 relationship between data types at every step) and the
@@ -1285,7 +1339,7 @@ class RecordHandler:
         :return: Each record model mapped to the record at the end of the path starting from itself. If the end of the
             path couldn't be reached, the record will map to None.
         """
-        ret_dict: dict[RecordModel, WrappedType | None] = {}
+        ret_dict: dict[RecordModel, WrappedType | PyRecordModel | None] = {}
         # PR-46832: Update path traversal to account for changes to RelationshipPath in Sapiopylib.
         path: list[RelationshipNode] = path.path
         for model in models:
@@ -1332,9 +1386,9 @@ class RecordHandler:
             ret_dict.update({model: self.wrap_model(current, wrapper_type) if current else None})
         return ret_dict
 
-    def get_branching_path(self, models: Iterable[RecordModel], path: RelationshipPath,
+    def get_branching_path(self, models: Iterable[IsRecordModel], path: RelationshipPath,
                            wrapper_type: type[WrappedType] | None = None)\
-            -> dict[RecordModel, list[WrappedType] | list[PyRecordModel]]:
+            -> dict[IsRecordModel, list[WrappedType] | list[PyRecordModel]]:
         """
         Given a relationship path, travel the path starting from the input models. Returns the record at the end of the
         path, if any. The hierarchy may be non-linear (1:Many relationships between data types are allowed) and the
@@ -1347,7 +1401,7 @@ class RecordHandler:
         :return: Each record model mapped to the records at the end of the path starting from itself. If the end of the
             path couldn't be reached, the record will map to an empty list.
         """
-        ret_dict: dict[RecordModel, list[WrappedType]] = {}
+        ret_dict: dict[RecordModel, list[WrappedType] | list[PyRecordModel]] = {}
         # PR-46832: Update path traversal to account for changes to RelationshipPath in Sapiopylib.
         path: list[RelationshipNode] = path.path
         for model in models:
@@ -1383,9 +1437,9 @@ class RecordHandler:
 
     # FR-46155: Create a relationship traversing function that returns a single function at the end of the path like
     # get_linear_path but can handle branching paths in the middle of the search like get_branching_path.
-    def get_flat_path(self, models: Iterable[RecordModel], path: RelationshipPath,
+    def get_flat_path(self, models: Iterable[IsRecordModel], path: RelationshipPath,
                       wrapper_type: type[WrappedType] | None = None) \
-            -> dict[RecordModel, WrappedType | PyRecordModel | None]:
+            -> dict[IsRecordModel, WrappedType | PyRecordModel | None]:
         """
         Given a relationship path, travel the path starting from the input models. Returns the record at the end of the
         path, if any. The hierarchy may be non-linear (1:Many relationships between data types are allowed) and the
@@ -1402,7 +1456,7 @@ class RecordHandler:
         :return: Each record model mapped to the record at the end of the path starting from itself. If the end of the
             path couldn't be reached, the record will map to None.
         """
-        ret_dict: dict[RecordModel, WrappedType | None] = {}
+        ret_dict: dict[RecordModel, WrappedType | PyRecordModel | None] = {}
         # PR-46832: Update path traversal to account for changes to RelationshipPath in Sapiopylib.
         path: list[RelationshipNode] = path.path
         for model in models: