sapiopycommons 2025.3.6a451__py3-none-any.whl → 2025.3.6a454__py3-none-any.whl

sapiopycommons/recordmodel/record_handler.py

@@ -70,66 +70,56 @@ class RecordHandler:
         self.rel_man = self.rec_man.relationship_manager
         self.an_man = RecordModelAncestorManager(self.rec_man)
 
-    def wrap_model(self, record: DataRecord, wrapper_type: type[WrappedType] | None = None) \
-            -> WrappedType | PyRecordModel:
+    def wrap_model(self, record: DataRecord, wrapper_type: type[WrappedType]) -> WrappedType:
         """
         Shorthand for adding a single data record as a record model.
 
         :param record: The data record to wrap.
-        :param wrapper_type: The record model wrapper to use. If not provided, the record is returned as a
-            PyRecordModel instead of WrappedRecordModels.
+        :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)
-            return self.inst_man.add_existing_record_of_type(record, wrapper_type)
-        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], 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 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.
         """
-        if wrapper_type is not None:
-            self.__verify_data_type(records, wrapper_type)
-            return self.inst_man.add_existing_records_of_type(list(records), wrapper_type)
-        return self.inst_man.add_existing_records(list(records))
+        self.__verify_data_type(records, wrapper_type)
+        return self.inst_man.add_existing_records_of_type(list(records), wrapper_type)
 
-    def query_models(self, wrapper_type: type[WrappedType] | str, field: FieldIdentifier,
-                     value_list: Iterable[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.
         :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,
+    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] | list[PyRecordModel]]:
+            -> 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.
         :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
@@ -137,24 +127,22 @@ class RecordHandler:
         :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,
+    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 | PyRecordModel]:
+            -> 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.
         :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
@@ -162,32 +150,29 @@ class RecordHandler:
         :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,
+    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.
         :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 = wrapper_type.get_wrapper_data_type_name()
         field: str = AliasUtil.to_data_field_name(field)
@@ -195,111 +180,104 @@ class RecordHandler:
         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)
+        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)}
 
-    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 = 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.
@@ -309,7 +287,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
@@ -321,8 +299,7 @@ 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):
@@ -332,7 +309,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.
@@ -352,38 +329,35 @@ class RecordHandler:
         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.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.
         """
         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))
@@ -391,9 +365,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
@@ -404,14 +377,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.
@@ -432,23 +403,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 = 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
@@ -456,18 +426,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 = 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,
@@ -479,14 +448,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.
@@ -508,8 +475,7 @@ class RecordHandler:
         return self.create_models_with_data(wrapper_type, [secondary_identifiers])[0]
 
     @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.
 
@@ -518,14 +484,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.
 
@@ -534,14 +500,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.
@@ -551,8 +517,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
@@ -563,8 +529,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.
@@ -574,16 +540,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.
 
@@ -592,14 +557,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.
 
@@ -608,14 +573,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.
@@ -625,8 +590,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
@@ -637,8 +602,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.
@@ -648,8 +613,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)
@@ -1107,19 +1072,18 @@ class RecordHandler:
             ret_dict.update({model: self.inst_man.wrap(current[0], wrapper_type) if current else None})
         return ret_dict
 
-    def __find_model(self, wrapper_type: type[WrappedType] | 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():
@@ -1129,7 +1093,7 @@ 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