sapiopycommons 2024.8.27a310__py3-none-any.whl → 2024.8.28a313__py3-none-any.whl

sapiopycommons/files/file_data_handler.py

@@ -1,11 +1,14 @@
 import re
 from typing import Any, Callable, Iterable
 
-from sapiopycommons.general.aliases import SapioRecord
 from sapiopycommons.general.exceptions import SapioException
-from sapiopycommons.general.time_util import TimeUtil
+
 from sapiopycommons.recordmodel.record_handler import RecordHandler
 
+from sapiopycommons.general.aliases import SapioRecord
+
+from sapiopycommons.general.time_util import TimeUtil
+
 FilterList = Iterable[int] | range | Callable[[int, dict[str, Any]], bool] | None
 """A FilterList is an object used to determine if a row in the file data should be skipped over. This can take the
 form of am iterable (e.g. list, set) of its or a range where row indices in the list or range are skipped, or it can be

sapiopycommons/files/file_util.py

@@ -1,6 +1,4 @@
 import io
-import warnings
-import zipfile
 
 import pandas
 from numpy import dtype
@@ -23,8 +21,7 @@ class FileUtil:
     """
     @staticmethod
     def tokenize_csv(file_bytes: bytes, required_headers: list[str] | None = None, header_row_index: int | None = 0,
-                     seperator: str = ",", *, encoding: str | None = None, exception_on_empty: bool = True) \
-            -> tuple[list[dict[str, str]], list[list[str]]]:
+                     seperator: str = ",") -> tuple[list[dict[str, str]], list[list[str]]]:
         """
         Tokenize a CSV file. The provided file must be uniform. That is, if row 1 has 10 cells, all the rows in the file
         must have 10 cells. Otherwise, the Pandas parser throws a tokenizer exception.
@@ -37,30 +34,22 @@ class FileUtil:
             meaning that required headers are also ignored if any are provided. By default, the first row (0th index)
             is assumed to be the header row.
         :param seperator: The character that separates cells in the table.
-        :param encoding: The encoding used to read the given file bytes. If not provided, uses utf-8. If your file
-            contains a non-utf-8 character, then a UnicodeDecodeError will be thrown. If this happens, consider using
-            ISO-8859-1 as the encoding.
-        :param exception_on_empty: Throw a user error exception if the provided file bytes result in an empty list in
-            the first element of the returned tuple.
         :return: The CSV parsed into a list of dicts where each dict is a row, mapping the headers to the cells for
             that row. Also returns a list of each row above the headers (the metadata), parsed into a list of each cell.
             If the header row index is 0 or None, this list will be empty.
         """
         # Parse the file bytes into two DataFrames. The first is metadata of the file located above the header row,
         # while the second is the body of the file below the header row.
-        file_body, file_metadata = FileUtil.csv_to_data_frames(file_bytes, header_row_index, seperator,
-                                                               encoding=encoding)
+        file_body, file_metadata = FileUtil.csv_to_data_frames(file_bytes, header_row_index, seperator)
         # Parse the metadata from above the header row index into a list of lists.
         metadata: list[list[str]] = FileUtil.data_frame_to_lists(file_metadata)
         # Parse the data from the file body into a list of dicts.
         rows: list[dict[str, str]] = FileUtil.data_frame_to_dicts(file_body, required_headers, header_row_index)
-        if exception_on_empty and not rows:
-            raise SapioUserErrorException("The provided file contains no rows of information below the headers.")
         return rows, metadata
 
     @staticmethod
-    def tokenize_xlsx(file_bytes: bytes, required_headers: list[str] | None = None, header_row_index: int | None = 0,
-                      *, exception_on_empty: bool = True) -> tuple[list[dict[str, str]], list[list[str]]]:
+    def tokenize_xlsx(file_bytes: bytes, required_headers: list[str] | None = None, header_row_index: int | None = 0) \
+            -> tuple[list[dict[str, str]], list[list[str]]]:
         """
         Tokenize an XLSX file row by row.
 
@@ -71,8 +60,6 @@ class FileUtil:
             row is returned in the metadata list. If input is None, then no row is considered to be the header row,
             meaning that required headers are also ignored if any are provided. By default, the first row (0th index)
             is assumed to be the header row.
-        :param exception_on_empty: Throw a user error exception if the provided file bytes result in an empty list in
-            the first element of the returned tuple.
         :return: The XLSX parsed into a list of dicts where each dict is a row, mapping the headers to the cells for
             that row. Also returns a list of each row above the headers (the metadata), parsed into a list of each cell.
             If the header row index is 0 or None, this list will be empty.
@@ -84,13 +71,11 @@ class FileUtil:
         metadata: list[list[str]] = FileUtil.data_frame_to_lists(file_metadata)
         # Parse the data from the file body into a list of dicts.
         rows: list[dict[str, str]] = FileUtil.data_frame_to_dicts(file_body, required_headers, header_row_index)
-        if exception_on_empty and not rows:
-            raise SapioUserErrorException("The provided file contains no rows of information below the headers.")
         return rows, metadata
 
     @staticmethod
-    def csv_to_data_frames(file_bytes: bytes, header_row_index: int | None = 0, seperator: str = ",",
-                           *, encoding: str | None = None) -> tuple[DataFrame, DataFrame | None]:
+    def csv_to_data_frames(file_bytes: bytes, header_row_index: int | None = 0, seperator: str = ",") \
+            -> tuple[DataFrame, DataFrame | None]:
         """
         Parse the file bytes for a CSV into DataFrames. The provided file must be uniform. That is, if row 1 has 10
         cells, all the rows in the file must have 10 cells. Otherwise, the Pandas parser throws a tokenizer exception.
@@ -101,9 +86,6 @@ class FileUtil:
             meaning that required headers are also ignored if any are provided. By default, the first row (0th index)
             is assumed to be the header row.
         :param seperator: The character that separates cells in the table.
-        :param encoding: The encoding used to read the given file bytes. If not provided, uses utf-8. If your file
-            contains a non-utf-8 character, then a UnicodeDecodeError will be thrown. If this happens, consider using
-            ISO-8859-1 as the encoding.
         :return: A tuple of two DataFrames. The first is the frame for the CSV table body, while the second is for the
             metadata from above the header row, or None if there is no metadata.
         """
@@ -115,13 +97,13 @@ class FileUtil:
                 # can throw off the header row index.
                 file_metadata = pandas.read_csv(file_io, header=None, dtype=dtype(str),
                                                 skiprows=lambda x: x >= header_row_index,
-                                                skip_blank_lines=False, sep=seperator, encoding=encoding)
+                                                skip_blank_lines=False, sep=seperator)
         with io.BytesIO(file_bytes) as file_io:
             # The use of the dtype argument is to ensure that everything from the file gets read as a string. Added
             # because some numerical values would get ".0" appended to them, even when casting the DataFrame cell to a
             # string.
             file_body: DataFrame = pandas.read_csv(file_io, header=header_row_index, dtype=dtype(str),
-                                                   skip_blank_lines=False, sep=seperator, encoding=encoding)
+                                                   skip_blank_lines=False, sep=seperator)
 
         return file_body, file_metadata
 
@@ -240,7 +222,7 @@ class FileUtil:
         :param file_data: The CSV file to be converted.
         :return: The bytes of the CSV file converted to an XLSX file.
         """
-        with (io.BytesIO(file_data.encode() if isinstance(file_data, str) else file_data)) as csv:
+        with (io.BytesIO(file_data) if isinstance(file_data, bytes) else io.StringIO(file_data)) as csv:
             # Setting header to false makes pandas read the CSV as-is.
             data_frame = pandas.read_csv(csv, sep=",", header=None)
 
@@ -284,20 +266,6 @@ class FileUtil:
             file_bytes: bytes = buffer.getvalue()
         return file_bytes
 
-    @staticmethod
-    def zip_files(files: dict[str, str | bytes]) -> bytes:
-        """
-        Create a zip file for a collection of files.
-
-        :param files: A dictionary of file name to file data as a string or bytes.
-        :return: The bytes for a zip file containing the input files.
-        """
-        zip_buffer: io.BytesIO = io.BytesIO()
-        with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
-            for file_name, file_data in files.items():
-                zip_file.writestr(file_name, file_data)
-        return zip_buffer.getvalue()
-
     # Deprecated functions:
 
     # FR-46097 - Add write file request shorthand functions to FileUtil.
@@ -315,8 +283,6 @@ class FileUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the write request as its client callback request.
         """
-        warnings.warn("FileUtil.write_file is deprecated as of 24.5+. Use CallbackUtil.write_file instead.",
-                      DeprecationWarning)
         return SapioWebhookResult(True, client_callback_request=WriteFileRequest(file_bytes, file_name,
                                                                                  request_context))
 
@@ -333,8 +299,6 @@ class FileUtil:
         :param request_context: Context that will be returned to the webhook server in the client callback result.
         :return: A SapioWebhookResult with the write request as its client callback request.
         """
-        warnings.warn("FileUtil.write_files is deprecated as of 24.5+. Use CallbackUtil.write_file instead.",
-                      DeprecationWarning)
         return SapioWebhookResult(True, client_callback_request=MultiFileRequest(files, request_context))
 
     @staticmethod
@@ -362,8 +326,6 @@ class FileUtil:
             1 - The file name of the requested file if the user provided one.
             2 - The file bytes of the requested file if the user provided one.
         """
-        warnings.warn("FileUtil.request_file is deprecated as of 24.5+. Use CallbackUtil.request_file instead.",
-                      DeprecationWarning)
         client_callback = context.client_callback_result
         result_context: str | None = client_callback.callback_context_data if client_callback else None
         # If the user cancels, terminate the interaction.
@@ -416,8 +378,6 @@ class FileUtil:
             May also contain a result that will terminate the client interaction if the user canceled the prompt.
             1 - A dictionary that maps the file names to the file bytes for each provided file.
         """
-        warnings.warn("FileUtil.request_files is deprecated as of 24.5+. Use CallbackUtil.request_files instead.",
-                      DeprecationWarning)
         client_callback = context.client_callback_result
         result_context: str | None = client_callback.callback_context_data if client_callback else None
         # If the user cancels, terminate the interaction.
@@ -460,7 +420,7 @@ class FileUtil:
         if len(allowed_extensions) != 0:
             matches: bool = False
             for ext in allowed_extensions:
-                if file_path.endswith("." + ext.lstrip(".")):
+                if file_path.endswith("." + ext):
                     matches = True
                     break
             if matches is False:

sapiopycommons/files/file_validator.py

@@ -4,15 +4,12 @@ from abc import abstractmethod
 from typing import Any
 
 from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.CustomReport import RawReportTerm, RawTermOperation
 from sapiopylib.rest.pojo.datatype.FieldDefinition import VeloxIntegerFieldDefinition, VeloxStringFieldDefinition, \
     AbstractVeloxFieldDefinition
+from sapiopylib.rest.pojo.webhook.WebhookResult import SapioWebhookResult
 
 from sapiopycommons.callbacks.callback_util import CallbackUtil
 from sapiopycommons.files.file_data_handler import FileDataHandler, FilterList
-from sapiopycommons.general.aliases import UserIdentifier, AliasUtil
-from sapiopycommons.general.custom_report_util import CustomReportUtil
-from sapiopycommons.general.exceptions import SapioUserCancelledException
 from sapiopycommons.general.time_util import TimeUtil
 
 
@@ -80,10 +77,10 @@ class FileValidator:
 
         return failed_rows
 
-    def build_violation_report(self, context: UserIdentifier,
+    def build_violation_report(self, context: SapioWebhookResult | SapioUser,
                                rule_violations: dict[int, list[ValidationRule]]) -> None:
         """
-        Display a simple report of any rule violations in the file to the user as a table dialog.
+        Build a simple report of any rule violations in the file to display to the user as a table dialog.
 
         :param context: The current webhook context or a user object to send requests from.
         :param rule_violations: A dict of rule violations generated by a call to validate_file.
@@ -121,24 +118,9 @@ class FileValidator:
                         "Reason": violation.reason[:2000]
                     })
 
-        callback = CallbackUtil(context)
-        callback.table_dialog("Errors", "The following rule violations were encountered in the provided file.",
-                              columns, rows)
-
-    def validate_and_report_errors(self, context: UserIdentifier) -> None:
-        """
-        Validate the file. If any rule violations are found, display a simple report of any rule violations in the file
-        to the user as a table dialog and throw a SapioUserCancelled exception after the user acknowledges the dialog
-        to end the webhook interaction.
-
-        Shorthand for calling validate_file() and then build_violation_report() if there are any errors.
-
-        :param context: The current webhook context or a user object to send requests from.
-        """
-        violations = self.validate_file()
-        if violations:
-            self.build_violation_report(context, violations)
-            raise SapioUserCancelledException()
+        callback_util = CallbackUtil(context)
+        callback_util.table_dialog("Errors", "The following rule violations were encountered in the provided file.",
+                                   columns, rows)
 
 
 class ValidationRule:
@@ -498,71 +480,3 @@ class ContainsSubstringFromCellRule(RowRule):
 
     def validate(self, row: dict[str, Any]) -> bool:
         return row.get(self.second) in row.get(self.first)
-
-
-class UniqueSystemValueRule(ColumnRule):
-    """
-    Requires that every cell in the column has a value that is not already in use in the system for a given data type
-    and field name.
-    """
-    user: SapioUser
-    data_type_name: str
-    data_field_name: str
-
-    def __init__(self, context: UserIdentifier, header: str, data_type_name: str,
-                 data_field_name: str):
-        """
-        :param context: The current webhook context or a user object to send requests from.
-        :param header: The header that this rule acts upon.
-        :param data_type_name: The data type name to search on.
-        :param data_field_name: The data field name to search on. This is expected to be a string field.
-        """
-        self.user = AliasUtil.to_sapio_user(context)
-        self.data_type_name = data_type_name
-        self.data_field_name = data_field_name
-        super().__init__(header, f"This value already exists in the system.")
-
-    def validate(self, rows: list[dict[str, Any]]) -> list[int]:
-        file_handler = FileDataHandler(rows)
-        values: list[str] = file_handler.get_values_list(self.header)
-
-        # Run a quick report for all records of this type that match these field values.
-        term = RawReportTerm(self.data_type_name, self.data_field_name, RawTermOperation.EQUAL_TO_OPERATOR,
-                             "{" + ",".join(values) + "}")
-        results: list[dict[str, Any]] = CustomReportUtil.run_quick_report(self.user, term)
-        existing_values: list[Any] = [x.get(self.data_field_name) for x in results]
-        return file_handler.get_in_list(self.header, existing_values)
-
-
-class ExistingSystemValueRule(ColumnRule):
-    """
-    Requires that every cell in the column has a value that is already in use in the system for a given data type
-    and field name.
-    """
-    user: SapioUser
-    data_type_name: str
-    data_field_name: str
-
-    def __init__(self, context: UserIdentifier, header: str, data_type_name: str,
-                 data_field_name: str):
-        """
-        :param context: The current webhook context or a user object to send requests from.
-        :param header: The header that this rule acts upon.
-        :param data_type_name: The data type name to search on.
-        :param data_field_name: The data field name to search on. This is expected to be a string field.
-        """
-        self.user = AliasUtil.to_sapio_user(context)
-        self.data_type_name = data_type_name
-        self.data_field_name = data_field_name
-        super().__init__(header, f"This value doesn't exist in the system.")
-
-    def validate(self, rows: list[dict[str, Any]]) -> list[int]:
-        file_handler = FileDataHandler(rows)
-        values: list[str] = file_handler.get_values_list(self.header)
-
-        # Run a quick report for all records of this type that match these field values.
-        term = RawReportTerm(self.data_type_name, self.data_field_name, RawTermOperation.EQUAL_TO_OPERATOR,
-                             "{" + ",".join(values) + "}")
-        results: list[dict[str, Any]] = CustomReportUtil.run_quick_report(self.user, term)
-        existing_values: list[Any] = [x.get(self.data_field_name) for x in results]
-        return file_handler.get_not_in_list(self.header, existing_values)

sapiopycommons/files/file_writer.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import warnings
 from abc import abstractmethod
 from enum import Enum
 from typing import Any
@@ -19,7 +18,7 @@ class FileWriter:
     body: list[list[Any]]
     delimiter: str
     line_break: str
-    column_definitions: dict[str, ColumnDef]
+    column_definitions: list[ColumnDef]
 
     def __init__(self, headers: list[str], delimiter: str = ",", line_break: str = "\r\n"):
         """
@@ -31,7 +30,7 @@ class FileWriter:
         self.delimiter = delimiter
         self.line_break = line_break
         self.body = []
-        self.column_definitions = {}
+        self.column_definitions = []
 
     def add_row_list(self, row: list[Any]) -> None:
         """
@@ -66,49 +65,21 @@ class FileWriter:
             new_row.append(row.get(header, ""))
         self.body.append(new_row)
 
-    def add_column_definition(self, header: str, column_def: ColumnDef) -> None:
+    def add_column_definitions(self, column_defs: list[ColumnDef]) -> None:
         """
-        Add a new column definition to this FileWriter for a specific header.
+        Add new column definitions to this FileWriter. Column definitions are evaluated in the order they are added,
+        meaning that they map to the header with the equivalent index. Before the file is built, the number of column
+        definitions must equal the number of headers if any column definition is provided.
 
-        ColumnDefs are only used if the build_file function is provided with a list of RowBundles. Every header must
-        have a column definition if this is the case.
+        ColumnDefs are only used if the build_file function is provided with a list of RowBundles.
 
         Custom column definitions can be created by defining a class that extends ColumnDef and implements the print
         method.
 
-        :param column_def: A column definitions to be used to construct the file when build_file is
+        :param column_defs: A list of column definitions to be used to construct the file when build_file is
             called.
-        :param header: The header that this column definition is for. If a header is provided that isn't in the headers
-            list, the header is appended to the end of the list.
         """
-        if header not in self.headers:
-            self.headers.append(header)
-        self.column_definitions[header] = column_def
-
-    def add_column_definitions(self, column_defs: dict[str, ColumnDef]) -> None:
-        """
-        Add new column definitions to this FileWriter.
-
-        ColumnDefs are only used if the build_file function is provided with a list of RowBundles. Every header must
-        have a column definition if this is the case.
-
-        Custom column definitions can be created by defining a class that extends ColumnDef and implements the print
-        method.
-
-        :param column_defs: A dictionary of header names to column definitions to be used to construct the file when
-            build_file is called.
-        """
-        # For backwards compatibility purposes, if column definitions are provided as a list,
-        # add them in order of appearance of the headers. This will only work if the headers are defined first, though.
-        if isinstance(column_defs, list):
-            warnings.warn("Adding column definitions is no longer expected as a list. Continuing to provide a list to "
-                          "this function may result in undesirable behavior.", UserWarning)
-            if not self.headers:
-                raise SapioException("No headers provided to FileWriter before the column definitions were added.")
-            for header, column_def in zip(self.headers, column_defs):
-                self.column_definitions[header] = column_def
-        for header, column_def in column_defs.items():
-            self.add_column_definition(header, column_def)
+        self.column_definitions.extend(column_defs)
 
     def build_file(self, rows: list[RowBundle] | None = None, sorter=None, reverse: bool = False) -> str:
         """
@@ -129,10 +100,11 @@ class FileWriter:
         """
         # If any column definitions have been provided, the number of column definitions and headers must be equal.
         if self.column_definitions:
-            for header in self.headers:
-                if header not in self.column_definitions:
-                    raise SapioException(f"FileWriter has no column definition for the header {header}. If any column "
-                                         f"definitions are provided, then all headers must have a column definition.")
+            def_count: int = len(self.column_definitions)
+            header_count: int = len(self.headers)
+            if def_count != header_count:
+                raise SapioException(f"FileWriter has {def_count} column definitions defined but {header_count} "
+                                     f"headers. The number of column definitions must equal the number of headers.")
         # If any RowBundles have been provided, there must be column definitions for mapping them to the file.
         elif rows:
             raise SapioException(f"FileWriter was given RowBundles but contains no column definitions for mapping "
@@ -158,8 +130,7 @@ class FileWriter:
         rows.sort(key=lambda x: x.index)
         for row in rows:
             new_row: list[Any] = []
-            for header in self.headers:
-                column = self.column_definitions[header]
+            for column in self.column_definitions:
                 if column.may_skip and row.may_skip:
                     new_row.append("")
                 else:

sapiopycommons/general/aliases.py

@@ -1,47 +1,24 @@
 from collections.abc import Iterable
 from typing import Any
 
-from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.DataRecord import DataRecord
-from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
 from sapiopylib.rest.pojo.eln.ElnExperiment import ElnExperiment
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 from sapiopylib.rest.utils.Protocols import ElnExperimentProtocol
 from sapiopylib.rest.utils.recordmodel.PyRecordModel import PyRecordModel
-from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedRecordModel, WrappedType, WrapperField
+from sapiopylib.rest.utils.recordmodel.RecordModelWrapper import WrappedRecordModel, WrappedType
 
-from sapiopycommons.general.exceptions import SapioException
-
-FieldValue = int | float | str | bool | None
-"""Allowable values for fields in the system."""
 RecordModel = PyRecordModel | WrappedRecordModel | WrappedType
 """Different forms that a record model could take."""
 SapioRecord = DataRecord | RecordModel
 """A record could be provided as either a DataRecord, PyRecordModel, or WrappedRecordModel (WrappedType)."""
 RecordIdentifier = SapioRecord | int
 """A RecordIdentifier is either a record type or an integer for the record's record ID."""
-DataTypeIdentifier = SapioRecord | type[WrappedType] | str
-"""A DataTypeIdentifier is either a SapioRecord, a record model wrapper type, or a string."""
-FieldIdentifier = WrapperField | str | tuple[str, FieldType]
-"""A FieldIdentifier is either wrapper field from a record model wrapper, a string, or a tuple of string
-and field type."""
-FieldIdentifierKey = WrapperField | str
-"""A FieldIdentifierKey is a FieldIdentifier, except it can't be a tuple, s tuples can't be used as keys in
-dictionaries.."""
-HasFieldWrappers = type[WrappedType] | WrappedRecordModel
-"""An identifier for classes that have wrapper fields."""
 ExperimentIdentifier = ElnExperimentProtocol | ElnExperiment | int
 """An ExperimentIdentifier is either an experiment protocol, experiment, or an integer for te experiment's notebook
 ID."""
-FieldMap = dict[str, FieldValue]
+FieldMap = dict[str, Any]
 """A field map is simply a dict of data field names to values. The purpose of aliasing this is to help distinguish
 any random dict in a webhook from one which is explicitly used for record fields."""
-FieldIdentifierMap = dict[FieldIdentifierKey, FieldValue]
-"""A field identifier map is the same thing as a field map, except the keys can be field identifiers instead
-of just strings. Note that although one of the allowed field identifiers is a tuple, you can't use tuples as
-keys in a dictionary."""
-UserIdentifier = SapioWebhookContext | SapioUser
-"""An identifier for classes from which a user object can be used for sending requests."""
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
@@ -73,123 +50,7 @@ class AliasUtil:
 
         :return: A list of record IDs for the input records.
         """
-        return [(AliasUtil.to_record_id(x)) for x in records]
-
-    @staticmethod
-    def to_record_id(record: RecordIdentifier):
-        """
-        Convert a single variable that could be either an integer, DataRecord, PyRecordModel,
-        or WrappedRecordModel to just an integer (taking the record ID from the record).
-
-        :return: A record ID for the input record.
-        """
-        return record if isinstance(record, int) else record.record_id
-
-    @staticmethod
-    def to_data_type_name(value: DataTypeIdentifier) -> str:
-        """
-        Convert a given value to a data type name.
-
-        :param value: A value which is a string, record, or record model type.
-        :return: A string of the data type name of the input value.
-        """
-        if isinstance(value, str):
-            return value
-        if isinstance(value, SapioRecord):
-            return value.data_type_name
-        return value.get_wrapper_data_type_name()
-
-    @staticmethod
-    def to_data_type_names(values: Iterable[DataTypeIdentifier], return_set: bool = False) -> list[str] | set[str]:
-        """
-        Convert a given iterable of values to a list or set of data type names.
-
-        :param values: An iterable of values which are strings, records, or record model types.
-        :param return_set: If true, return a set instead of a list.
-        :return: A list or set of strings of the data type name of the input value.
-        """
-        values = [AliasUtil.to_data_type_name(x) for x in values]
-        return set(values) if return_set else values
-
-    @staticmethod
-    def to_singular_data_type_name(values: Iterable[DataTypeIdentifier]) -> str:
-        """
-        Convert a given iterable of values to a singular data type name that they share. Throws an exception if more
-        than one data type name exists in the provided list of identifiers.
-
-        :param values: An iterable of values which are strings, records, or record model types.
-        :return: The single data type name that the input vales share.
-        """
-        data_types: set[str] = AliasUtil.to_data_type_names(values, True)
-        if len(data_types) > 1:
-            raise SapioException(f"Provided values contain multiple data types: {data_types}. "
-                                 f"Only expecting a single data type.")
-        return data_types.pop()
-
-    @staticmethod
-    def to_data_field_name(value: FieldIdentifier) -> str:
-        """
-        Convert a string or WrapperField to a data field name string.
-
-        :param value: A string or WrapperField.
-        :return: A string of the data field name of the input value.
-        """
-        if isinstance(value, tuple):
-            return value[0]
-        if isinstance(value, WrapperField):
-            return value.field_name
-        return value
-
-    @staticmethod
-    def to_data_field_names(values: Iterable[FieldIdentifier]) -> list[str]:
-        """
-        Convert an iterable of strings or WrapperFields to a list of data field name strings.
-
-        :param values: An iterable of strings or WrapperFields.
-        :return: A list of strings of the data field names of the input values.
-        """
-        return [AliasUtil.to_data_field_name(x) for x in values]
-
-    @staticmethod
-    def to_data_field_names_dict(values: dict[FieldIdentifierKey, Any]) -> dict[str, Any]:
-        """
-        Take a dictionary whose keys are field identifiers and convert them all to strings for the data field name.
-
-        :param values: A dictionary of field identifiers to field values.
-        :return: A dictionary of strings of the data field names to field values for the input values.
-        """
-        ret_dict: dict[str, FieldValue] = {}
-        for field, value in values.items():
-            ret_dict[AliasUtil.to_data_field_name(field)] = value
-        return ret_dict
-
-    @staticmethod
-    def to_data_field_names_list_dict(values: list[dict[FieldIdentifierKey, Any]]) -> list[dict[str, Any]]:
-        ret_list: list[dict[str, Any]] = []
-        for field_map in values:
-            ret_list.append(AliasUtil.to_data_field_names_dict(field_map))
-        return ret_list
-
-    @staticmethod
-    def to_field_type(field: FieldIdentifier, data_type: HasFieldWrappers | None = None) -> FieldType:
-        """
-        Convert a given field identifier to the field type for that field.
-
-        :param field: A string or WrapperField.
-        :param data_type: If the field is provided as a string, then a record model wrapper or wrapped record model
-            must be provided to determine the field type.
-        :return: The field type of the given field.
-        """
-        if isinstance(field, tuple):
-            return field[1]
-        if isinstance(field, WrapperField):
-            return field.field_type
-        for var in dir(data_type):
-            attr = getattr(data_type, var)
-            if isinstance(attr, WrapperField) and attr.field_name == field:
-                return attr.field_type
-        raise SapioException(f"The wrapper of data type \"{data_type.get_wrapper_data_type_name()}\" doesn't have a "
-                             f"field with the name \"{field}\",")
+        return [(x if isinstance(x, int) else x.record_id) for x in records]
 
     @staticmethod
     def to_field_map_lists(records: Iterable[SapioRecord]) -> list[FieldMap]:
@@ -202,7 +63,6 @@ class AliasUtil:
         field_map_list: list[FieldMap] = []
         for record in records:
             if isinstance(record, DataRecord):
-                # noinspection PyTypeChecker
                 field_map_list.append(record.get_fields())
             else:
                 field_map_list.append(record.fields.copy_to_dict())
@@ -220,7 +80,3 @@ class AliasUtil:
         if isinstance(experiment, ElnExperiment):
             return experiment.notebook_experiment_id
         return experiment.get_id()
-    
-    @staticmethod
-    def to_sapio_user(context: UserIdentifier) -> SapioUser:
-        return context if isinstance(context, SapioUser) else context.user