sapiopycommons 2025.4.8a474__py3-none-any.whl → 2025.4.9a150__py3-none-any.whl

sapiopycommons/recordmodel/record_handler.py

@@ -1,9 +1,6 @@
 from __future__ import annotations
 
-import io
-import warnings
 from collections.abc import Iterable
-from typing import Collection
 from weakref import WeakValueDictionary
 
 from sapiopylib.rest.DataRecordManagerService import DataRecordManager
@@ -15,28 +12,19 @@ from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
 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, AbstractRecordModelPropertyGetter, \
-    RecordModelPropertyType, AbstractRecordModelPropertyAdder, AbstractRecordModelPropertySetter, \
-    AbstractRecordModelPropertyRemover
+from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
 from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager, RecordModelInstanceManager, \
     RecordModelRelationshipManager
 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 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
+    FieldIdentifierMap, FieldValue, UserIdentifier, FieldIdentifierKey
 from sapiopycommons.general.custom_report_util import CustomReportUtil
 from sapiopycommons.general.exceptions import SapioException
 
-# Aliases for longer name.
-_PropertyGetter = AbstractRecordModelPropertyGetter
-_PropertyAdder = AbstractRecordModelPropertyAdder
-_PropertyRemover = AbstractRecordModelPropertyRemover
-_PropertySetter = AbstractRecordModelPropertySetter
-_PropertyType = RecordModelPropertyType
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
 class RecordHandler:
@@ -69,273 +57,226 @@ class RecordHandler:
         """
         :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 = AliasUtil.to_sapio_user(context)
+        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)
 
-    # CR-47491: Support not providing a wrapper type to receive PyRecordModels instead of WrappedRecordModels.
-    def wrap_model(self, record: DataRecord | PyRecordModel, wrapper_type: type[WrappedType] | None = None) \
-            -> WrappedType | PyRecordModel:
+    def wrap_model(self, record: DataRecord, wrapper_type: type[WrappedType]) -> WrappedType:
         """
-        Shorthand for adding a single data record or PyRecordModel as a WrappedRecordModel.
+        Shorthand for adding a single data record as a record model.
 
-        :param record: The data record or PyRecordModel to wrap.
-        :param wrapper_type: The record model wrapper to use. If not provided, the record is returned as a
-            PyRecordModel instead of a WrappedRecordModel.
+        :param record: The data record to wrap.
+        :param wrapper_type: The record model wrapper to use.
         :return: The record model for the input.
         """
-        if wrapper_type is not None:
-            self.__verify_data_type(record, wrapper_type)
-            if isinstance(record, PyRecordModel):
-                return self.inst_man.wrap(record, wrapper_type)
-            return self.inst_man.add_existing_record_of_type(record, wrapper_type)
-        if isinstance(record, PyRecordModel):
-            return record
-        return self.inst_man.add_existing_record(record)
+        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 | PyRecordModel],
-                    wrapper_type: type[WrappedType] | None = None) \
-            -> list[WrappedType] | list[PyRecordModel]:
+    def wrap_models(self, records: Iterable[DataRecord], wrapper_type: type[WrappedType]) -> list[WrappedType]:
         """
-        Shorthand for adding a list of data records or PyRecordModels as a WrappedRecordModels.
+        Shorthand for adding a list of data records as record models.
 
         :param records: The data records to wrap.
-        :param wrapper_type: The record model wrapper to use. If not provided, the records are returned as
-            PyRecordModels instead of WrappedRecordModels.
+        :param wrapper_type: The record model wrapper to use.
         :return: The record models for the input.
         """
-        return [self.wrap_model(x, wrapper_type) for x in records]
+        self.__verify_data_type(records, wrapper_type)
+        return self.inst_man.add_existing_records_of_type(list(records), wrapper_type)
 
-    # CR-47491: Support providing a data type name string to receive PyRecordModels instead of requiring a WrapperType.
-    # CR-47523: Support a singular field value being provided for the value_list parameter.
-    def query_models(self, wrapper_type: type[WrappedType] | str, field: FieldIdentifier,
-                     value_list: Iterable[FieldValue] | FieldValue,
-                     page_limit: int | None = None, page_size: int | None = None) \
-            -> list[WrappedType] | list[PyRecordModel]:
+    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.
 
-        :param wrapper_type: The record model wrapper to use, or the data type name of the records.
+        :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, or a singular field value that will be automatically
-            converted to a singleton list. Note that field values of None are not supported by this method and will be
-            ignored. If you need to query for records with a null field value, use a custom report.
+        :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. 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. If a data type name was used instead of a model wrapper,
-            then the returned records will be PyRecordModels instead of WrappedRecordModels.
+        :return: The record models for the queried records.
         """
         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] | str, field: FieldIdentifier,
-                             value_list: Iterable[FieldValue] | FieldValue,
-                             page_limit: int | None = None, page_size: int | None = None,
-                             *,
-                             mapping_field: FieldIdentifier | None = None) \
-            -> dict[FieldValue, list[WrappedType] | list[PyRecordModel]]:
+    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.
 
-        :param wrapper_type: The record model wrapper to use, or the data type name of the records.
+        :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, or a singular field value that will be automatically
-            converted to a singleton list. Note that field values of None are not supported by this method and will be
-            ignored. If you need to query for records with a null field value, use a custom report.
+        :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. 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 a data type name was used instead of a model wrapper, then the returned records will be PyRecordModels
-            instead of WrappedRecordModels.
         """
         if mapping_field is None:
             mapping_field = 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] | str, field: FieldIdentifier,
-                                    value_list: Iterable[FieldValue] | FieldValue,
-                                    page_limit: int | None = None, page_size: int | None = None,
-                                    *,
-                                    mapping_field: FieldIdentifier | None = None) \
-            -> dict[FieldValue, WrappedType | PyRecordModel]:
+    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.
         If any two records share the same field value, throws an exception.
 
-        :param wrapper_type: The record model wrapper to use, or the data type name of the records.
+        :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, or a singular field value that will be automatically
-            converted to a singleton list. Note that field values of None are not supported by this method and will be
-            ignored. If you need to query for records with a null field value, use a custom report.
+        :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. 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 a data type name was used instead of a model wrapper, then the returned records will be PyRecordModels
-            instead of WrappedRecordModels.
         """
         if mapping_field is None:
             mapping_field = 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] | str, field: FieldIdentifier,
-                                   value_list: Iterable[FieldValue] | FieldValue,
+    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] | list[PyRecordModel], DataRecordPojoPageCriteria]:
+            -> tuple[list[WrappedType], DataRecordPojoPageCriteria]:
         """
         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.
 
-        :param wrapper_type: The record model wrapper to use, or the data type name of the records.
+        :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, or a singular field value that will be automatically
-            converted to a singleton list. Note that field values of None are not supported by this method and will be
-            ignored. If you need to query for records with a null field value, use a custom report.
+        :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. 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. If a data type name was used
-            instead of a model wrapper, then the returned records will be PyRecordModels instead of WrappedRecordModels.
+        :return: The record models for the queried records and the final paging criteria.
         """
-        dt: str = AliasUtil.to_data_type_name(wrapper_type)
-        if isinstance(wrapper_type, str):
-            wrapper_type = None
+        dt: str = wrapper_type.get_wrapper_data_type_name()
         field: str = AliasUtil.to_data_field_name(field)
-        if isinstance(value_list, FieldValue):
-            value_list: list[FieldValue] = [value_list]
         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] | str, ids: Iterable[int],
-                           page_limit: int | None = None, page_size: int | None = None) \
-            -> list[WrappedType] | list[PyRecordModel]:
+    def query_models_by_id(self, wrapper_type: type[WrappedType], ids: Iterable[int],
+                           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, or the data type name of the records.
+        :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. If a data type name was used instead of a model wrapper,
-            then the returned records will be PyRecordModels instead of WrappedRecordModels.
+        :return: The record models for the queried records.
         """
         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] | str, ids: Iterable[int],
+    def query_models_by_id_with_criteria(self, wrapper_type: type[WrappedType], ids: Iterable[int],
                                          paging_criteria: DataRecordPojoPageCriteria | None = None,
                                          page_limit: int | None = None) \
-            -> tuple[list[WrappedType] | list[PyRecordModel], DataRecordPojoPageCriteria]:
+            -> tuple[list[WrappedType], DataRecordPojoPageCriteria]:
         """
         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, or the data type name of the records.
+        :param wrapper_type: The record model wrapper to use.
         :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. 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. If a data type name was used
-            instead of a model wrapper, then the returned records will be PyRecordModels instead of WrappedRecordModels.
+        :return: The record models for the queried records and the final paging criteria.
         """
-        dt: str = AliasUtil.to_data_type_name(wrapper_type)
-        if isinstance(wrapper_type, str):
-            wrapper_type = None
+        dt: str = wrapper_type.get_wrapper_data_type_name()
         pager = QueryDataRecordByIdListAutoPager(dt, list(ids), 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_and_map(self, wrapper_type: type[WrappedType] | str, ids: Iterable[int],
+    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 | PyRecordModel]:
+            -> 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, or the data type name of the records.
+        :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.
-            If a data type name was used instead of a model wrapper, then the returned records will be PyRecordModels
-            instead of WrappedRecordModels.
         """
-        return {AliasUtil.to_record_id(x): x for x in self.query_models_by_id(wrapper_type, ids, page_limit, page_size)}
+        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] | str, page_limit: int | None = None,
-                         page_size: int | None = None) -> list[WrappedType] | list[PyRecordModel]:
+    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, or the data type name of the records.
+        :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. 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. If a data type name was used instead of a model wrapper,
-            then the returned records will be PyRecordModels instead of WrappedRecordModels.
+        :return: The record models for the queried records.
         """
         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] | str,
+    def query_all_models_with_criteria(self, wrapper_type: type[WrappedType],
                                        paging_criteria: DataRecordPojoPageCriteria | None = None,
                                        page_limit: int | None = None) \
-            -> tuple[list[WrappedType] | list[PyRecordModel], DataRecordPojoPageCriteria]:
+            -> tuple[list[WrappedType], DataRecordPojoPageCriteria]:
         """
         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, or the data type name of the records.
+        :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. 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. If a data type name was used
-            instead of a model wrapper, then the returned records will be PyRecordModels instead of WrappedRecordModels.
+        :return: The record models for the queried records and the final paging criteria.
         """
-        dt: str = AliasUtil.to_data_type_name(wrapper_type)
-        if isinstance(wrapper_type, str):
-            wrapper_type = None
+        dt: str = wrapper_type.get_wrapper_data_type_name()
         pager = QueryAllRecordsOfTypeAutoPager(dt, 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_report(self, wrapper_type: type[WrappedType] | str,
+    def query_models_by_report(self, wrapper_type: type[WrappedType],
                                report_name: str | RawReportTerm | CustomReportCriteria,
                                filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None = None,
                                page_limit: int | None = None,
                                page_size: int | None = None,
-                               page_number: int | None = None) -> list[WrappedType] | list[PyRecordModel]:
+                               page_number: int | None = None) -> list[WrappedType]:
         """
         Run a report and use the results of that report to query for and return the records in the report results.
         First runs the report, then runs a data record manager query on the results of the custom report.
@@ -345,7 +286,7 @@ class RecordHandler:
 
         Any given custom report criteria should only have columns from a single data type.
 
-        :param wrapper_type: The record model wrapper to use, or the data type name of the records.
+        :param wrapper_type: The record model wrapper to use.
         :param report_name: The name of a system report, or a raw report term for a quick report, or custom report
             criteria for a custom report.
         :param filters: If provided, filter the results of the report using the given mapping of headers to values to
@@ -357,10 +298,8 @@ class RecordHandler:
         :param page_number: The page number to start the search from, If None, starts on the first page.
             If the input report is a custom report criteria, uses the value from the criteria, unless this value is
             not None, in which case it overwrites the given report's value. Note that the number of the first page is 0.
-        :return: The record models for the queried records that matched the given report. If a data type name was used
-            instead of a model wrapper, then the returned records will be PyRecordModels instead of WrappedRecordModels.
+        :return: The record models for the queried records that matched the given report.
         """
-        warnings.warn("Deprecated in favor of the [System/Custom/Quick]ReportRecordAutoPager classes.", DeprecationWarning)
         if isinstance(report_name, str):
             results: list[dict[str, FieldValue]] = CustomReportUtil.run_system_report(self.user, report_name, filters,
                                                                                       page_limit, page_size, page_number)
@@ -368,7 +307,7 @@ class RecordHandler:
             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 = AliasUtil.to_data_type_name(wrapper_type)
+            dt: str = wrapper_type.get_wrapper_data_type_name()
             # Ensure that the root data type is the one we're looking for.
             report_name.root_data_type = dt
             # Raise an exception if any column in the report doesn't match the given data type.
@@ -383,45 +322,40 @@ class RecordHandler:
             raise SapioException("Unrecognized report object.")
 
         # Using the bracket accessor because we want to throw an exception if RecordId doesn't exist in the report.
-        # This should only possibly be the case with system reports, as quick reports will include the record ID, and
+        # This should only possibly be the case with system reports, as quick reports will include the record ID and
         # we forced any given custom report to have a record ID column.
         ids: list[int] = [row["RecordId"] for row in results]
         return self.query_models_by_id(wrapper_type, ids)
 
-    def add_model(self, wrapper_type: type[WrappedType] | str) -> WrappedType | PyRecordModel:
+    def add_model(self, wrapper_type: type[WrappedType]) -> WrappedType:
         """
         Shorthand for using the instance manager to add a new record model of the given type.
 
-        :param wrapper_type: The record model wrapper to use, or the data type name of the record.
-        :return: The newly added record model. If a data type name was used instead of a model wrapper, then the
-            returned record will be a PyRecordModel instead of a WrappedRecordModel.
+        :param wrapper_type: The record model wrapper to use.
+        :return: The newly added record model.
         """
-        return self.add_models(wrapper_type, 1)[0]
+        return self.inst_man.add_new_record_of_type(wrapper_type)
 
-    def add_models(self, wrapper_type: type[WrappedType] | str, num: int) -> list[WrappedType] | list[PyRecordModel]:
+    def add_models(self, wrapper_type: type[WrappedType], num: int) -> list[WrappedType]:
         """
         Shorthand for using the instance manager to add new record models of the given type.
 
-        :param wrapper_type: The record model wrapper to use, or the data type name of the records.
+        :param wrapper_type: The record model wrapper to use.
         :param num: The number of models to create.
-        :return: The newly added record models. If a data type name was used instead of a model wrapper, then the
-            returned records will be PyRecordModels instead of WrappedRecordModels.
+        :return: The newly added record models.
         """
-        if isinstance(wrapper_type, str):
-            return self.inst_man.add_new_records(wrapper_type, num)
         return self.inst_man.add_new_records_of_type(num, wrapper_type)
 
-    def add_models_with_data(self, wrapper_type: type[WrappedType] | str, fields: list[FieldIdentifierMap]) \
-            -> list[WrappedType] | list[PyRecordModel]:
+    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.
 
-        :param wrapper_type: The record model wrapper to use, or the data type name of the records.
+        :param wrapper_type: The record model wrapper to use.
         :param fields: A list of field maps to initialize the record models with.
         :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. If a data type name was used instead of a model wrapper, then the returned
-            records will be PyRecordModels instead of WrappedRecordModels.
+            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))
@@ -429,9 +363,8 @@ class RecordHandler:
             model.set_field_values(field_list)
         return models
 
-    def find_or_add_model(self, wrapper_type: type[WrappedType] | str, primary_identifier: FieldIdentifier,
-                          id_value: FieldValue, secondary_identifiers: FieldIdentifierMap | None = None) \
-            -> WrappedType | PyRecordModel:
+    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
@@ -442,14 +375,12 @@ class RecordHandler:
 
         Makes a webservice call to query for the existing record.
 
-        :param wrapper_type: The record model wrapper to use, or the data type name of the record.
+        :param wrapper_type: The record model wrapper to use.
         :param primary_identifier: The data field name of the field to search on.
         :param id_value: The value of the identifying field to search for.
         :param secondary_identifiers: Optional fields used to filter the records that are returned after searching on
             the primary identifier.
         :return: The record model with the identifying field value, either pulled from the system or newly created.
-            If a data type name was used instead of a model wrapper, then the returned record will be a PyRecordModel
-            instead of a WrappedRecordModel.
         """
         # PR-46335: Initialize the secondary identifiers parameter if None is provided to avoid an exception.
         # If no secondary identifiers were provided, use an empty dictionary.
@@ -470,25 +401,22 @@ class RecordHandler:
         secondary_identifiers.update({primary_identifier: id_value})
         return self.add_models_with_data(wrapper_type, [secondary_identifiers])[0]
 
-    def create_models(self, wrapper_type: type[WrappedType] | str, num: int) -> list[WrappedType] | list[PyRecordModel]:
+    def create_models(self, wrapper_type: type[WrappedType], num: int) -> list[WrappedType]:
         """
         Shorthand for creating new records via the data record manager and then returning them as wrapped
         record models. Useful in cases where your record model needs to have a valid record ID.
 
         Makes a webservice call to create the data records.
 
-        :param wrapper_type: The record model wrapper to use, or the data type name of the records.
+        :param wrapper_type: The record model wrapper to use.
         :param num: The number of new records to create.
-        :return: The newly created record models. If a data type name was used instead of a model wrapper, then the
-            returned records will be PyRecordModels instead of WrappedRecordModels.
+        :return: The newly created record models.
         """
-        dt: str = AliasUtil.to_data_type_name(wrapper_type)
-        if isinstance(wrapper_type, str):
-            wrapper_type = None
+        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] | str, fields: list[FieldIdentifierMap]) \
-            -> list[WrappedType] | list[PyRecordModel]:
+    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
         and then returning them as wrapped record models. Useful in cases where your record model needs to have a valid
@@ -496,20 +424,17 @@ class RecordHandler:
 
         Makes a webservice call to create the data records.
 
-        :param wrapper_type: The record model wrapper to use, or the data type name of the records.
+        :param wrapper_type: The record model wrapper to use.
         :param fields: The field map list to initialize the new data records with.
-        :return: The newly created record models. If a data type name was used instead of a model wrapper, then the
-            returned records will be PyRecordModels instead of WrappedRecordModels.
+        :return: The newly created record models.
         """
-        dt: str = AliasUtil.to_data_type_name(wrapper_type)
-        if isinstance(wrapper_type, str):
-            wrapper_type = None
+        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] | str, primary_identifier: FieldIdentifier,
+    def find_or_create_model(self, wrapper_type: type[WrappedType], primary_identifier: FieldIdentifier,
                              id_value: FieldValue, secondary_identifiers: FieldIdentifierMap | None = None) \
-            -> WrappedType | PyRecordModel:
+            -> 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,
@@ -521,14 +446,12 @@ class RecordHandler:
         Makes a webservice call to query for the existing record. Makes an additional webservice call if the record
         needs to be created.
 
-        :param wrapper_type: The record model wrapper to use, or the data type name of the record.
+        :param wrapper_type: The record model wrapper to use.
         :param primary_identifier: The data field name of the field to search on.
         :param id_value: The value of the identifying field to search for.
         :param secondary_identifiers: Optional fields used to filter the records that are returned after searching on
             the primary identifier.
         :return: The record model with the identifying field value, either pulled from the system or newly created.
-            If a data type name was used instead of a model wrapper, then the returned record will be a PyRecordModel
-            instead of a WrappedRecordModel.
         """
         # PR-46335: Initialize the secondary identifiers parameter if None is provided to avoid an exception.
         # If no secondary identifiers were provided, use an empty dictionary.
@@ -549,281 +472,8 @@ class RecordHandler:
         secondary_identifiers.update({primary_identifier: id_value})
         return self.create_models_with_data(wrapper_type, [secondary_identifiers])[0]
 
-    # FR-47525: Add functions for getting and setting record image bytes.
-    def get_record_image(self, record: SapioRecord) -> bytes:
-        """
-        Retrieve the record image for a given record.
-
-        :param record: The record model to retrieve the image of.
-        :return: The file bytes of the given record's image.
-        """
-        record: DataRecord = AliasUtil.to_data_record(record)
-        with io.BytesIO() as data_sink:
-            def consume_data(chunk: bytes):
-                data_sink.write(chunk)
-
-            self.dr_man.get_record_image(record, consume_data)
-            data_sink.flush()
-            data_sink.seek(0)
-            file_bytes = data_sink.read()
-        return file_bytes
-
-    def set_record_image(self, record: SapioRecord, file_data: str | bytes) -> None:
-        """
-        Set the record image for a given record.
-
-        :param record: The record model to set the image of.
-        :param file_data: The file data of the image to set on the record.
-        """
-        record: DataRecord = AliasUtil.to_data_record(record)
-        with io.BytesIO(file_data.encode() if isinstance(file_data, str) else file_data) as stream:
-            self.dr_man.set_record_image(record, stream)
-
-    # FR-47522: Add RecordHandler functions that copy from the RecordModelUtil class in our Java utilities.
-    @staticmethod
-    def get_values_list(records: list[RecordModel], field: FieldIdentifier) -> list[FieldValue]:
-        """
-        Get a list of field values from a list of record models.
-
-        :param records: The list of record models to get the field values from.
-        :param field: The field to get the values of.
-        :return: A list of field values from the input record models. The values are in the same order as the input
-            record models.
-        """
-        field: str = AliasUtil.to_data_field_name(field)
-        return [x.get_field_value(field) for x in records]
-
-    @staticmethod
-    def get_values_set(records: list[RecordModel], field: FieldIdentifier) -> set[FieldValue]:
-        """
-        Get a set of field values from a list of record models.
-
-        :param records: The list of record models to get the field values from.
-        :param field: The field to get the values of.
-        :return: A set of field values from the input record models.
-        """
-        field: str = AliasUtil.to_data_field_name(field)
-        return {x.get_field_value(field) for x in records}
-
-    @staticmethod
-    def set_values(records: list[RecordModel], field: FieldIdentifier, value: FieldValue) -> None:
-        """
-        Set the value of a field on a list of record models.
-
-        :param records: The list of record models to set the field value on.
-        :param field: The field to set the value of.
-        :param value: The value to set the field to for all input records.
-        """
-        field: str = AliasUtil.to_data_field_name(field)
-        for record in records:
-            record.set_field_value(field, value)
-
-    @staticmethod
-    def get_min_record(records: list[RecordModel], field: FieldIdentifier) -> RecordModel:
-        """
-        Get the record model with the minimum value of a given field from a list of record models.
-
-        :param records: The list of record models to search through.
-        :param field: The field to find the minimum value of.
-        :return: The record model with the minimum value of the given field.
-        """
-        field: str = AliasUtil.to_data_field_name(field)
-        return min(records, key=lambda x: x.get_field_value(field))
-
-    @staticmethod
-    def get_max_record(records: list[RecordModel], field: FieldIdentifier) -> RecordModel:
-        """
-        Get the record model with the maximum value of a given field from a list of record models.
-
-        :param records: The list of record models to search through.
-        :param field: The field to find the maximum value of.
-        :return: The record model with the maximum value of the given field.
-        """
-        field: str = AliasUtil.to_data_field_name(field)
-        return max(records, key=lambda x: x.get_field_value(field))
-
-    @staticmethod
-    def get_from_all(records: Iterable[RecordModel], getter: _PropertyGetter[_PropertyType]) -> list[_PropertyType]:
-        """
-        Use a getter property on all records in a list of record models. For example, you can iterate over a list of
-        record models using a getter of Ancestors.of_type(SampleModel) to get all the SampleModel ancestors from each
-        record.
-
-        :param records: The list of record models to get the property from.
-        :param getter: The getter to use to get the property from each record.
-        :return: A list of the property values from the input record models. The value at the matching index of the
-            input records is the results of using the getter on that record.
-        """
-        return [x.get(getter) for x in records]
-
-    @staticmethod
-    def set_on_all(records: Iterable[RecordModel], setter: _PropertySetter[_PropertyType]) -> list[_PropertyType]:
-        """
-        Use a setter property on all records in a list of record models. For example, you can iterate over a list of
-        record models user a setter of ForwardSideLink.ref(field_name, record) to set a forward side link on each
-        record.
-
-        :param records: The list of record models to set the property on.
-        :param setter: The setter to use to set the property on each record.
-        :return: A list of the property values that were set on the input record models. The value at the matching index
-            of the input records is the results of using the setter on that record.
-        """
-        return [x.set(setter) for x in records]
-
-    @staticmethod
-    def add_to_all(records: Iterable[RecordModel], adder: _PropertyAdder[_PropertyType]) -> list[_PropertyType]:
-        """
-        Use an adder property on all records in a list of record models. For example, you can iterate over a list of
-        record models using an adder of Child.create(SampleModel) to create a new SampleModel child on each record.
-
-        :param records: The list of record models to add the property to.
-        :param adder: The adder to use to add the property to each record.
-        :return: A list of the property values that were added to the input record models. The value at the matching
-            index of the input records is the results of using the adder on that record.
-        """
-        return [x.add(adder) for x in records]
-
-    @staticmethod
-    def remove_from_all(records: Iterable[RecordModel], remover: _PropertyRemover[_PropertyType]) -> list[_PropertyType]:
-        """
-        Use a remover property on all records in a list of record models. For example, you can iterate over a list of
-        record models using a remover of Parents.ref(records) to remove a list of parents from each record.
-
-        :param records: The list of record models to remove the property from.
-        :param remover: The remover to use to remove the property from each record.
-        :return: A list of the property values that were removed from the input record models. The value at the matching
-            index of the input records is the results of using the remover on that record.
-        """
-        return [x.remove(remover) for x in records]
-
-    # FR-47527: Created functions for manipulating relationships between records,
-    def get_extension(self, model: RecordModel, wrapper_type: type[WrappedType] | str) \
-            -> WrappedType | PyRecordModel | None:
-        """
-        Given a record with an extension record related to it, return the extension record as a record model.
-        This will retrieve an extension record without doing a webservice request to the server. The input record and
-        extension record will be considered related to one another if you later use load_child or load_parent on the
-        input record or extension record respectively.
-
-        :param model: The record model to get the extension for.
-        :param wrapper_type: The record model wrapper to use, or the data type name of the extension record. If a data
-            type name is provided, the returned record will be a PyRecordModel instead of a WrappedRecordModel.
-        :return: The extension record model for the input record model, or None if no extension record exists.
-        """
-        ext_dt: str = AliasUtil.to_data_type_name(wrapper_type)
-        ext_fields: FieldMap = {}
-        for field, value in AliasUtil.to_field_map(model).items():
-            if field.startswith(ext_dt + "."):
-                ext_fields[field.removeprefix(ext_dt + ".")] = value
-        if not ext_fields or ext_fields.get("RecordId") is None:
-            return None
-        ext_rec: DataRecord = DataRecord(ext_dt, ext_fields.get("RecordId"), ext_fields)
-        ext_model: WrappedType | PyRecordModel = self.wrap_model(ext_rec, wrapper_type)
-        self._spoof_child_load(model, ext_model)
-        self._spoof_parent_load(ext_model, model)
-        return ext_model
-
-    def get_or_add_parent(self, record: RecordModel, parent_type: type[WrappedType] | str) \
-            -> WrappedType | PyRecordModel:
-        """
-        Given a record model, retrieve the singular parent record model of a given type. If a parent of the given type
-        does not exist, a new one will be created. The parents of the given data type must already be loaded.
-
-        :param record: The record model to get the parent of.
-        :param parent_type: The record model wrapper of the parent, or the data type name of the parent. If a data type
-            name is provided, the returned record will be a PyRecordModel instead of a WrappedRecordModel.
-        :return: The parent record model of the given type.
-        """
-        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)
-        if parent is not None:
-            return self.wrap_model(record, wrapper) if wrapper else parent
-        return record.add(Parent.create(wrapper)) if wrapper else record.add(Parent.create_by_name(parent_dt))
-
-    def get_or_add_child(self, record: RecordModel, child_type: type[WrappedType] | str) -> WrappedType | PyRecordModel:
-        """
-        Given a record model, retrieve the singular child record model of a given type. If a child of the given type
-        does not exist, a new one will be created. The children of the given data type must already be loaded.
-
-        :param record: The record model to get the child of.
-        :param child_type: The record model wrapper of the child, or the data type name of the child. If a data type
-            name is provided, the returned record will be a PyRecordModel instead of a WrappedRecordModel.
-        :return: The child record model of the given type.
-        """
-        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)
-        if child is not None:
-            return self.wrap_model(record, wrapper) if wrapper else child
-        return record.add(Child.create(wrapper)) if wrapper else record.add(Child.create_by_name(child_dt))
-
-    def get_or_add_side_link(self, record: RecordModel, side_link_field: FieldIdentifier,
-                             side_link_type: type[WrappedType] | str) -> WrappedType | PyRecordModel:
-        """
-        Given a record model, retrieve the singular side link record model of a given type. If a side link of the given
-        type does not exist, a new one will be created. The side links of the given data type must already be loaded.
-
-        :param record: The record model to get the side link of.
-        :param side_link_field: The field name of the side link to get.
-        :param side_link_type: The record model wrapper of the side link, or the data type name of the side link. If a
-            data type name is provided, the returned record will be a PyRecordModel instead of a WrappedRecordModel.
-        :return: The side link record model of the given type.
-        """
-        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)
-        if side_link is not None:
-            return self.wrap_model(record, wrapper) if wrapper else side_link
-        side_link: WrappedType | PyRecordModel = self.add_model(side_link_type)
-        return record.add(ForwardSideLink.ref(side_link_field, side_link))
-
-    @staticmethod
-    def set_parents(record: RecordModel, parents: Iterable[RecordModel], parent_type: DataTypeIdentifier) -> None:
-        """
-        Set the parents of a record model to a list of parent record models of a given type. The parents of the given
-        data type must already be loaded. This method will add the parents to the record model if they are not already
-        parents, and remove any existing parents that are not in the input list.
-
-        :param record: The record model to set the parents of.
-        :param parents: The list of parent record models to set as the parents of the input record model.
-        :param parent_type: The data type identifier of the parent record models.
-        """
-        parent_dt: str = AliasUtil.to_data_type_name(parent_type)
-        existing_parents: list[PyRecordModel] = record.get(Parents.of_type_name(parent_dt))
-        for parent in parents:
-            if parent not in existing_parents:
-                record.add(Parent.ref(parent))
-        for parent in existing_parents:
-            if parent not in parents:
-                record.remove(Parent.ref(parent))
-
-    @staticmethod
-    def set_children(record: RecordModel, children: Iterable[RecordModel], child_type: DataTypeIdentifier) -> None:
-        """
-        Set the children of a record model to a list of child record models of a given type. The children of the given
-        data type must already be loaded. This method will add the children to the record model if they are not already
-        children, and remove any existing children that are not in the input list.
-
-        :param record: The record model to set the children of.
-        :param children: The list of child record models to set as the children of the input record model.
-        :param child_type: The data type identifier of the child record models.
-        """
-        child_dt: str = AliasUtil.to_data_type_name(child_type)
-        existing_children: list[PyRecordModel] = record.get(Children.of_type_name(child_dt))
-        for child in children:
-            if child not in existing_children:
-                record.add(Child.ref(child))
-        for child in existing_children:
-            if child not in children:
-                record.remove(Child.ref(child))
-
     @staticmethod
-    def map_to_parent(models: Iterable[WrappedRecordModel], parent_type: type[WrappedType])\
-            -> dict[WrappedRecordModel, WrappedType]:
+    def map_to_parent(models: Iterable[RecordModel], parent_type: type[WrappedType]) -> dict[RecordModel, WrappedType]:
         """
         Map a list of record models to a single parent of a given type. The parents must already be loaded.
 
@@ -832,14 +482,14 @@ class RecordHandler:
         :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] = {}
         for model in models:
             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[RecordModel], parent_type: type[WrappedType]) \
+            -> dict[RecordModel, list[WrappedType]]:
         """
         Map a list of record models to a list parents of a given type. The parents must already be loaded.
 
@@ -848,14 +498,14 @@ class RecordHandler:
         :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[RecordModel, list[WrappedType]] = {}
         for model in models:
             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[RecordModel], parent_type: type[WrappedType]) \
+            -> dict[WrappedType, RecordModel]:
         """
         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.
@@ -865,8 +515,8 @@ class RecordHandler:
         :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] = RecordHandler.map_to_parent(models, parent_type)
+        by_parent: dict[WrappedType, RecordModel] = {}
         for record, parent in to_parent.items():
             if parent is None:
                 continue
@@ -877,8 +527,8 @@ 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[RecordModel], parent_type: type[WrappedType]) \
+            -> dict[WrappedType, list[RecordModel]]:
         """
         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.
@@ -888,16 +538,15 @@ class RecordHandler:
         :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]] = RecordHandler.map_to_parents(models, parent_type)
+        by_parents: dict[WrappedType, 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[RecordModel], child_type: type[WrappedType]) -> dict[RecordModel, WrappedType]:
         """
         Map a list of record models to a single child of a given type. The children must already be loaded.
 
@@ -906,14 +555,14 @@ class RecordHandler:
         :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] = {}
         for model in models:
             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[RecordModel], child_type: type[WrappedType]) \
+            -> dict[RecordModel, list[WrappedType]]:
         """
         Map a list of record models to a list children of a given type. The children must already be loaded.
 
@@ -922,14 +571,14 @@ class RecordHandler:
         :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]] = {}
         for model in models:
             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[RecordModel], child_type: type[WrappedType]) \
+            -> 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.
@@ -939,8 +588,8 @@ class RecordHandler:
         :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] = RecordHandler.map_to_child(models, child_type)
+        by_child: dict[WrappedType, RecordModel] = {}
         for record, child in to_child.items():
             if child is None:
                 continue
@@ -951,8 +600,8 @@ 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[RecordModel], child_type: type[WrappedType]) \
+            -> dict[WrappedType, list[RecordModel]]:
         """
         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.
@@ -962,8 +611,8 @@ class RecordHandler:
         :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]] = RecordHandler.map_to_children(models, child_type)
+        by_children: dict[WrappedType, list[RecordModel]] = {}
         for record, children in to_children.items():
             for child in children:
                 by_children.setdefault(child, []).append(record)
@@ -1202,7 +851,7 @@ class RecordHandler:
         return field_sum
 
     @staticmethod
-    def mean_of_field(models: Collection[SapioRecord], field_name: FieldIdentifier) -> 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.
@@ -1211,7 +860,7 @@ class RecordHandler:
         :param field_name: The name of the numeric field to mean.
         :return: The mean of the field values for the collection of models.
         """
-        return RecordHandler.sum_of_field(models, field_name) / len(models)
+        return RecordHandler.sum_of_field(models, field_name) / len(list(models))
 
     @staticmethod
     def get_newest_record(records: Iterable[SapioRecord]) -> SapioRecord:
@@ -1221,7 +870,11 @@ class RecordHandler:
         :param records: The list of records.
         :return: The input record with the highest record ID. None if the input list is empty.
         """
-        return max(records, key=lambda x: x.record_id)
+        newest: SapioRecord | None = None
+        for record in records:
+            if newest is None or record.record_id > newest.record_id:
+                newest = record
+        return newest
 
     # FR-46696: Add a function for getting the oldest record in a list, just like we have one for the newest record.
     @staticmethod
@@ -1232,18 +885,22 @@ class RecordHandler:
         :param records: The list of records.
         :return: The input record with the lowest record ID. None if the input list is empty.
         """
-        return min(records, key=lambda x: x.record_id)
+        oldest: SapioRecord | None = None
+        for record in records:
+            if oldest is None or record.record_id < oldest.record_id:
+                oldest = record
+        return oldest
 
     @staticmethod
     def values_to_field_maps(field_name: FieldIdentifier, values: Iterable[FieldValue],
-                             existing_fields: list[FieldMap] | None = None) -> list[FieldMap]:
+                             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.
 
         :param field_name: The name of the field that the values are from.
         :param values: A list of field values.
         :param existing_fields: An optional existing fields map list to add the new values to. Values are added in the
-            list in the same order that they appear. If no existing fields are provided, returns a new fields map list.
+          list in the same order that they appear. If no existing fields are provided, returns a new fields map list.
         :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.
@@ -1262,9 +919,8 @@ 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,
-                        wrapper_type: type[WrappedType] | None = None) \
-            -> dict[RecordModel, WrappedType | PyRecordModel | None]:
+    def get_linear_path(self, models: Iterable[RecordModel], path: RelationshipPath, wrapper_type: type[WrappedType]) \
+            -> dict[RecordModel, WrappedType | 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
@@ -1272,8 +928,7 @@ class RecordHandler:
 
         :param models: A list of record models.
         :param path: The relationship path to follow.
-        :param wrapper_type: The record model wrapper to use on the record at the end of the path. If not provided,
-            the record will be a PyRecordModel instead of a WrappedRecordModel.
+        :param wrapper_type: The record model wrapper to use.
         :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.
         """
@@ -1321,12 +976,11 @@ class RecordHandler:
                         current = reverse_links[0]
                 else:
                     raise SapioException("Unsupported path direction.")
-            ret_dict.update({model: self.wrap_model(current, wrapper_type) if current else None})
+            ret_dict.update({model: self.inst_man.wrap(current, wrapper_type) if current else None})
         return ret_dict
 
     def get_branching_path(self, models: Iterable[RecordModel], path: RelationshipPath,
-                           wrapper_type: type[WrappedType] | None = None)\
-            -> dict[RecordModel, list[WrappedType] | list[PyRecordModel]]:
+                           wrapper_type: type[WrappedType]) -> dict[RecordModel, list[WrappedType]]:
         """
         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
@@ -1334,8 +988,7 @@ class RecordHandler:
 
         :param models: A list of record models.
         :param path: The relationship path to follow.
-        :param wrapper_type: The record model wrapper to use on the records at the end of the path. If not provided,
-            the records will be PyRecordModels instead of WrappedRecordModels.
+        :param wrapper_type: The record model wrapper to use.
         :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.
         """
@@ -1368,14 +1021,13 @@ class RecordHandler:
                         raise SapioException("Unsupported path direction.")
                 current_search = next_search
                 next_search = set()
-            ret_dict.update({model: self.wrap_models(current_search, wrapper_type)})
+            ret_dict.update({model: self.inst_man.wrap_list(list(current_search), wrapper_type)})
         return ret_dict
 
     # 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,
-                      wrapper_type: type[WrappedType] | None = None) \
-            -> dict[RecordModel, WrappedType | PyRecordModel | None]:
+    def get_flat_path(self, models: Iterable[RecordModel], path: RelationshipPath, wrapper_type: type[WrappedType]) \
+            -> dict[RecordModel, WrappedType | 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
@@ -1387,8 +1039,7 @@ class RecordHandler:
 
         :param models: A list of record models.
         :param path: The relationship path to follow.
-        :param wrapper_type: The record model wrapper to use on the record at the end of the path. If not provided,
-            the record will be a PyRecordModel instead of a WrappedRecordModel.
+        :param wrapper_type: The record model wrapper to use.
         :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.
         """
@@ -1416,22 +1067,21 @@ class RecordHandler:
                     current = current[0].get_reverse_side_link(data_type, node.data_field_name)
                 else:
                     raise SapioException("Unsupported path direction.")
-            ret_dict.update({model: self.wrap_model(current[0], wrapper_type) if current else None})
+            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] | str, primary_identifier: str, id_value: FieldValue,
-                     secondary_identifiers: FieldIdentifierMap | None = None) -> WrappedType | PyRecordModel | 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
         returned results. If no record is found with these filters, returns None.
         """
         # Query for all records that match the primary identifier.
-        results: list[WrappedType] | list[PyRecordModel] = self.query_models(wrapper_type, primary_identifier,
-                                                                             [id_value])
+        results: list[WrappedType] = self.query_models(wrapper_type, primary_identifier, [id_value])
 
         # Find the one record, if any, that matches the secondary identifiers.
-        unique_record: WrappedType | PyRecordModel | None = None
+        unique_record: WrappedType | None = None
         for result in results:
             matches_all: bool = True
             for field, value in secondary_identifiers.items():
@@ -1441,60 +1091,22 @@ class RecordHandler:
             if matches_all:
                 # If a previous record in the results already matched all identifiers, then throw an exception.
                 if unique_record is not None:
-                    raise SapioException(f"More than one record of type {AliasUtil.to_data_type_name(wrapper_type)} "
+                    raise SapioException(f"More than one record of type {wrapper_type.get_wrapper_data_type_name()} "
                                          f"encountered in system that matches all provided identifiers.")
                 unique_record = result
         return unique_record
 
     @staticmethod
-    def __verify_data_type(record: DataRecord | PyRecordModel, wrapper_type: type[WrappedType]) -> None:
+    def __verify_data_type(records: Iterable[DataRecord], wrapper_type: type[WrappedType]) -> None:
         """
-        Throw an exception if the data type of the given record and wrapper don't match.
+        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()
-        record_type: str = AliasUtil.to_data_type_name(record)
-        # 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}")
-
-    @staticmethod
-    def _spoof_child_load(model: RecordModel, child: RecordModel) -> None:
-        """
-        Spoof the loading of a child record on a record model. This is useful for when you have records that you know
-        are related but didn't use the relationship manager to load the relationship, which would make a webservice
-        call.
-        """
-        RecordHandler._spoof_children_load(model, [child])
-
-    @staticmethod
-    def _spoof_children_load(model: RecordModel, children: list[RecordModel]) -> None:
-        """
-        Spoof the loading of child records on a record model. This is useful for when you have records that you know
-        are related but didn't use the relationship manager to load the relationship, which would make a webservice
-        """
-        model: PyRecordModel = RecordModelInstanceManager.unwrap(model)
-        child_dt: str = AliasUtil.to_singular_data_type_name(children)
-        # noinspection PyProtectedMember
-        model._mark_children_loaded(child_dt, RecordModelInstanceManager.unwrap_list(children))
-
-    @staticmethod
-    def _spoof_parent_load(model: RecordModel, parent: RecordModel) -> None:
-        """
-        Spoof the loading of a parent record on a record model. This is useful for when you have records that you know
-        are related but didn't use the relationship manager to load the relationship, which would make a webservice
-        """
-        RecordHandler._spoof_parents_load(model, [parent])
-
-    @staticmethod
-    def _spoof_parents_load(model: RecordModel, parents: list[RecordModel]) -> None:
-        """
-        Spoof the loading of parent records on a record model. This is useful for when you have records that you know
-        are related but didn't use the relationship manager to load the relationship, which would make a webservice
-        """
-        model: PyRecordModel = RecordModelInstanceManager.unwrap(model)
-        parent_dt: str = AliasUtil.to_singular_data_type_name(parents)
-        # noinspection PyProtectedMember
-        model._mark_children_loaded(parent_dt, RecordModelInstanceManager.unwrap_list(parents))
+        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}")