sapiopycommons 2024.8.19a305__py3-none-any.whl → 2024.8.26a307__py3-none-any.whl

sapiopycommons/files/file_bridge.py

@@ -4,13 +4,14 @@ import urllib.parse
 
 from requests import Response
 from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
+
+from sapiopycommons.general.aliases import UserIdentifier, AliasUtil
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
 class FileBridge:
     @staticmethod
-    def read_file(context: SapioWebhookContext | SapioUser, bridge_name: str, file_path: str,
+    def read_file(context: UserIdentifier, bridge_name: str, file_path: str,
                   base64_decode: bool = True) -> bytes:
         """
         Read a file from FileBridge.
@@ -27,7 +28,7 @@ class FileBridge:
         params = {
             'Filepath': f"bridge://{bridge_name}/{file_path}"
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         response = user.get(sub_path, params)
         user.raise_for_status(response)
 
@@ -37,7 +38,7 @@ class FileBridge:
         return ret_val
 
     @staticmethod
-    def write_file(context: SapioWebhookContext | SapioUser, bridge_name: str, file_path: str,
+    def write_file(context: UserIdentifier, bridge_name: str, file_path: str,
                    file_data: bytes | str) -> None:
         """
         Write a file to FileBridge.
@@ -53,13 +54,13 @@ class FileBridge:
         params = {
             'Filepath': f"bridge://{bridge_name}/{file_path}"
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         with io.BytesIO(file_data.encode() if isinstance(file_data, str) else file_data) as data_stream:
             response = user.post_data_stream(sub_path, params=params, data_stream=data_stream)
         user.raise_for_status(response)
 
     @staticmethod
-    def list_directory(context: SapioWebhookContext | SapioUser, bridge_name: str,
+    def list_directory(context: UserIdentifier, bridge_name: str,
                        file_path: str | None = "") -> list[str]:
         """
         List the contents of a FileBridge directory.
@@ -74,7 +75,7 @@ class FileBridge:
         params = {
             'Filepath': f"bridge://{bridge_name}/{file_path}"
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         response: Response = user.get(sub_path, params=params)
         user.raise_for_status(response)
 
@@ -83,7 +84,7 @@ class FileBridge:
         return [urllib.parse.unquote(value)[path_length:] for value in response_body]
 
     @staticmethod
-    def create_directory(context: SapioWebhookContext | SapioUser, bridge_name: str, file_path: str) -> None:
+    def create_directory(context: UserIdentifier, bridge_name: str, file_path: str) -> None:
         """
         Create a new directory in FileBridge.
 
@@ -97,12 +98,12 @@ class FileBridge:
         params = {
             'Filepath': f"bridge://{bridge_name}/{file_path}"
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         response = user.post(sub_path, params=params)
         user.raise_for_status(response)
 
     @staticmethod
-    def delete_file(context: SapioWebhookContext | SapioUser, bridge_name: str, file_path: str) -> None:
+    def delete_file(context: UserIdentifier, bridge_name: str, file_path: str) -> None:
         """
         Delete an existing file in FileBridge.
 
@@ -115,12 +116,12 @@ class FileBridge:
         params = {
             'Filepath': f"bridge://{bridge_name}/{file_path}"
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         response = user.delete(sub_path, params=params)
         user.raise_for_status(response)
 
     @staticmethod
-    def delete_directory(context: SapioWebhookContext | SapioUser, bridge_name: str, file_path: str) -> None:
+    def delete_directory(context: UserIdentifier, bridge_name: str, file_path: str) -> None:
         """
         Delete an existing directory in FileBridge.
 
@@ -133,6 +134,6 @@ class FileBridge:
         params = {
             'Filepath': f"bridge://{bridge_name}/{file_path}"
         }
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         response = user.delete(sub_path, params=params)
         user.raise_for_status(response)

sapiopycommons/files/file_bridge_handler.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 from abc import abstractmethod, ABC
 from weakref import WeakValueDictionary
 
-from sapiopycommons.files.file_bridge import FileBridge
 from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
+
+from sapiopycommons.files.file_bridge import FileBridge
+from sapiopycommons.general.aliases import AliasUtil, UserIdentifier
 
 
 class FileBridgeHandler:
@@ -27,11 +28,11 @@ class FileBridgeHandler:
     __instances: WeakValueDictionary[str, FileBridgeHandler] = WeakValueDictionary()
     __initialized: bool
 
-    def __new__(cls, context: SapioWebhookContext | SapioUser, bridge_name: str):
+    def __new__(cls, context: UserIdentifier, bridge_name: str):
         """
         :param context: The current webhook context or a user object to send requests from.
         """
-        user = context if isinstance(context, SapioUser) else context.user
+        user = AliasUtil.to_sapio_user(context)
         key = f"{user.__hash__()}:{bridge_name}"
         obj = cls.__instances.get(key)
         if not obj:
@@ -40,7 +41,7 @@ class FileBridgeHandler:
             cls.__instances[key] = obj
         return obj
 
-    def __init__(self, context: SapioWebhookContext | SapioUser, bridge_name: str):
+    def __init__(self, context: UserIdentifier, bridge_name: str):
         """
         :param context: The current webhook context or a user object to send requests from.
         :param bridge_name: The name of the bridge to communicate with. This is the "connection name" in the
@@ -50,7 +51,7 @@ class FileBridgeHandler:
             return
         self.__initialized = True
 
-        self.user = context if isinstance(context, SapioUser) else context.user
+        self.user = AliasUtil.to_sapio_user(context)
         self.__bridge = bridge_name
         self.__file_cache = {}
         self.__files = {}
@@ -327,7 +328,7 @@ class Directory(FileBridgeObject):
         return {x: y for x, y in self.contents.items() if not y.is_file()}
 
 
-def split_path(file_path: str) -> (str, str):
+def split_path(file_path: str) -> tuple[str, str]:
     """
     :param file_path: A file path where directories are separated the "/" characters.
     :return: A tuple of two strings that splits the path on its last slash. The first string is the name of the

sapiopycommons/files/file_data_handler.py

@@ -1,13 +1,10 @@
 import re
 from typing import Any, Callable, Iterable
 
-from sapiopycommons.general.exceptions import SapioException
-
-from sapiopycommons.recordmodel.record_handler import RecordHandler
-
 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
 
 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

sapiopycommons/files/file_validator.py

@@ -7,10 +7,10 @@ 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.WebhookContext import SapioWebhookContext
 
 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,7 +80,7 @@ class FileValidator:
 
         return failed_rows
 
-    def build_violation_report(self, context: SapioWebhookContext | SapioUser,
+    def build_violation_report(self, context: UserIdentifier,
                                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.
@@ -125,7 +125,7 @@ class FileValidator:
         callback.table_dialog("Errors", "The following rule violations were encountered in the provided file.",
                               columns, rows)
 
-    def validate_and_report_errors(self, context: SapioWebhookContext | SapioUser) -> None:
+    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
@@ -509,7 +509,7 @@ class UniqueSystemValueRule(ColumnRule):
     data_type_name: str
     data_field_name: str
 
-    def __init__(self, context: SapioWebhookContext | SapioUser, header: str, data_type_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.
@@ -517,7 +517,7 @@ class UniqueSystemValueRule(ColumnRule):
         :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 = context.user if isinstance(context, SapioWebhookContext) else context
+        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.")
@@ -543,7 +543,7 @@ class ExistingSystemValueRule(ColumnRule):
     data_type_name: str
     data_field_name: str
 
-    def __init__(self, context: SapioWebhookContext | SapioUser, header: str, data_type_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.
@@ -551,7 +551,7 @@ class ExistingSystemValueRule(ColumnRule):
         :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 = context.user if isinstance(context, SapioWebhookContext) else context
+        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.")

sapiopycommons/general/aliases.py

@@ -1,15 +1,19 @@
 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 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
@@ -21,14 +25,23 @@ DataTypeIdentifier = SapioRecord | type[WrappedType] | str
 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, Any]
+FieldMap = dict[str, FieldValue]
 """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.
@@ -98,6 +111,21 @@ class AliasUtil:
         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:
         """
@@ -122,6 +150,26 @@ class AliasUtil:
         """
         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:
         """
@@ -154,6 +202,7 @@ 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())
@@ -171,3 +220,7 @@ 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

sapiopycommons/general/audit_log.py

@@ -1,14 +1,11 @@
 from enum import Enum
-from typing import Any
 
-from sapiopylib.rest.DataRecordManagerService import DataRecordManager
 from sapiopylib.rest.User import SapioUser
-from sapiopylib.rest.pojo.CustomReport import ReportColumn, RawReportTerm, CustomReportCriteria, RawTermOperation, \
-    CompositeReportTerm, CompositeTermOperation
+from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReportCriteria
 from sapiopylib.rest.pojo.datatype.FieldDefinition import FieldType
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
 
-from sapiopycommons.general.aliases import RecordIdentifier, AliasUtil
+from sapiopycommons.customreport.term_builder import TermBuilder
+from sapiopycommons.general.aliases import RecordIdentifier, AliasUtil, UserIdentifier, FieldIdentifier, FieldValue
 from sapiopycommons.general.custom_report_util import CustomReportUtil
 
 EVENTTYPE_COLUMN = "EVENTTYPE"
@@ -99,7 +96,7 @@ class AuditLogEntry:
     def new_value(self) -> str:
         return self.__new_value
 
-    def __init__(self, report_row: dict[str, Any]):
+    def __init__(self, report_row: dict[str, FieldValue]):
         self.__event_type = EventType((report_row[EVENTTYPE_COLUMN]))
         self.__date = report_row[TIMESTAMP_COLUMN]
         self.__data_type_name = report_row[DATATYPENAME_COLUMN]
@@ -131,11 +128,12 @@ class AuditLog:
                          DATA_RECORD_NAME, DATA_FIELD_NAME, ORIGINAL_VALUE, NEW_VALUE]
     user: SapioUser
 
-    def __init__(self, context: SapioWebhookContext | SapioUser):
-        self.user = context if isinstance(context, SapioUser) else context.user
+    def __init__(self, context: UserIdentifier):
+        self.user = AliasUtil.to_sapio_user(context)
 
     @staticmethod
-    def create_data_record_audit_log_report(records: list[RecordIdentifier], fields: list[str] | None = None) -> CustomReportCriteria:
+    def create_data_record_audit_log_report(records: list[RecordIdentifier],
+                                            fields: list[FieldIdentifier] | None = None) -> CustomReportCriteria:
         """
         This method creates a CustomReportCriteria object for running an audit log query based on data records.
 
@@ -147,25 +145,22 @@ class AuditLog:
         :param fields: The data field names to include changes for.
         :return: The constructed CustomReportCriteria object, which can be used to run a report on the audit log.
         """
-        # We need to compile the record ids from these record identifiers as "str" variables, so they can be
-        # concatenated.
+        # Build the raw report term querying for any entry with a matching record ID value to the record ID's
+        # passed in.
         record_ids = AliasUtil.to_record_ids(records)
-        id_strs = [str(id_int) for id_int in record_ids]
-
-        # Next we'll build the raw report term querying for any entry with a matching record id value to the record ID's
-        # passed in
-        root_term = RawReportTerm(AuditLog.AUDIT_LOG_PSEUDO_DATATYPE, RECORDID_COLUMN,
-                                  RawTermOperation.EQUAL_TO_OPERATOR, "{" + ",".join(id_strs) + "}")
+        root_term = TermBuilder.is_term(AuditLog.AUDIT_LOG_PSEUDO_DATATYPE, RECORDID_COLUMN, record_ids)
 
         # If the user passed in any specific fields, then we should limit the query to those fields.
         if fields:
-            field_term = RawReportTerm(AuditLog.AUDIT_LOG_PSEUDO_DATATYPE, DATAFIELDNAME_COLUMN,
-                                       RawTermOperation.EQUAL_TO_OPERATOR, "{" + ",".join(fields) + "}")
-            root_term = CompositeReportTerm(root_term, CompositeTermOperation.AND_OPERATOR, field_term)
+            fields: list[str] = AliasUtil.to_data_field_names(fields)
+            field_term = TermBuilder.is_term(AuditLog.AUDIT_LOG_PSEUDO_DATATYPE, DATAFIELDNAME_COLUMN, fields)
+            root_term = TermBuilder.and_terms(root_term, field_term)
 
         return CustomReportCriteria(AuditLog.AUDIT_LOG_COLUMNS, root_term)
 
-    def run_data_record_audit_log_report(self, records: list[RecordIdentifier], fields: list[str] | None = None) -> dict[RecordIdentifier, list[AuditLogEntry]]:
+    def run_data_record_audit_log_report(self, records: list[RecordIdentifier],
+                                         fields: list[FieldIdentifier] | None = None) \
+            -> dict[RecordIdentifier, list[AuditLogEntry]]:
         """
         This method runs a custom report for changes made to the given data records using the audit log.
         See "create_data_record_audit_log_report" for more details about the data record audit log report.
@@ -175,11 +170,12 @@ class AuditLog:
         :return: A dictionary where the keys are the record identifiers passed in, and the values are a list of
             AuditLogEntry objects which match the record id value of those records.
         """
+        fields: list[str] = AliasUtil.to_data_field_names(fields)
         # First, we must build our report criteria for running the Custom Report.
         criteria = AuditLog.create_data_record_audit_log_report(records, fields)
 
         # Then we must run the custom report using that criteria.
-        raw_report_data: list[dict[str, Any]] = CustomReportUtil.run_custom_report(self.user, criteria)
+        raw_report_data: list[dict[str, FieldValue]] = CustomReportUtil.run_custom_report(self.user, criteria)
 
         # This section will prepare a map matching the original RecordIdentifier by record id.
         # This is because the audit log entries will have record ids, but we want the keys in our result map

sapiopycommons/general/custom_report_util.py

@@ -1,21 +1,21 @@
 from collections.abc import Iterable
-from typing import Any
 
 from sapiopylib.rest.DataMgmtService import DataMgmtServer
 from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.pojo.CustomReport import ReportColumn, CustomReport, CustomReportCriteria, RawReportTerm
-from sapiopylib.rest.pojo.webhook.WebhookContext import SapioWebhookContext
+
+from sapiopycommons.general.aliases import UserIdentifier, FieldValue, AliasUtil, FieldIdentifierKey
 
 
 # FR-46064 - Initial port of PyWebhookUtils to sapiopycommons.
 class CustomReportUtil:
     @staticmethod
-    def run_system_report(context: SapioWebhookContext | SapioUser,
+    def run_system_report(context: UserIdentifier,
                           report_name: str,
-                          filters: dict[str, Iterable[Any]] | None = None,
+                          filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None = None,
                           page_limit: int | None = None,
                           page_size: int | None = None,
-                          page_number: int | None = None) -> list[dict[str, Any]]:
+                          page_number: int | None = None) -> list[dict[str, FieldValue]]:
         """
         Run a system report and return the results of that report as a list of dictionaries for the values of each
         column in each row.
@@ -41,16 +41,16 @@ class CustomReportUtil:
         results: tuple = CustomReportUtil.__exhaust_system_report(context, report_name, page_limit,
                                                                   page_size, page_number)
         columns: list[ReportColumn] = results[0]
-        rows: list[list[Any]] = results[1]
+        rows: list[list[FieldValue]] = results[1]
         return CustomReportUtil.__process_results(rows, columns, filters)
 
     @staticmethod
-    def run_custom_report(context: SapioWebhookContext | SapioUser,
+    def run_custom_report(context: UserIdentifier,
                           report_criteria: CustomReportCriteria,
-                          filters: dict[str, Iterable[Any]] | None = None,
+                          filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None = None,
                           page_limit: int | None = None,
                           page_size: int | None = None,
-                          page_number: int | None = None) -> list[dict[str, Any]]:
+                          page_number: int | None = None) -> list[dict[str, FieldValue]]:
         """
         Run a custom report and return the results of that report as a list of dictionaries for the values of each
         column in each row.
@@ -82,16 +82,16 @@ class CustomReportUtil:
         results: tuple = CustomReportUtil.__exhaust_custom_report(context, report_criteria, page_limit,
                                                                   page_size, page_number)
         columns: list[ReportColumn] = results[0]
-        rows: list[list[Any]] = results[1]
+        rows: list[list[FieldValue]] = results[1]
         return CustomReportUtil.__process_results(rows, columns, filters)
 
     @staticmethod
-    def run_quick_report(context: SapioWebhookContext | SapioUser,
+    def run_quick_report(context: UserIdentifier,
                          report_term: RawReportTerm,
-                         filters: dict[str, Iterable[Any]] | None = None,
+                         filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None = None,
                          page_limit: int | None = None,
                          page_size: int | None = None,
-                         page_number: int | None = None) -> list[dict[str, Any]]:
+                         page_number: int | None = None) -> list[dict[str, FieldValue]]:
         """
         Run a quick report and return the results of that report as a list of dictionaries for the values of each
         column in each row.
@@ -115,11 +115,11 @@ class CustomReportUtil:
         results: tuple = CustomReportUtil.__exhaust_quick_report(context, report_term, page_limit,
                                                                  page_size, page_number)
         columns: list[ReportColumn] = results[0]
-        rows: list[list[Any]] = results[1]
+        rows: list[list[FieldValue]] = results[1]
         return CustomReportUtil.__process_results(rows, columns, filters)
 
     @staticmethod
-    def get_system_report_criteria(context: SapioWebhookContext | SapioUser, report_name: str) -> CustomReport:
+    def get_system_report_criteria(context: UserIdentifier, report_name: str) -> CustomReport:
         """
         Retrieve a custom report from the system given the name of the report. This works by querying the system report
         with a page number and size of 1 to minimize the amount of data transfer needed to retrieve the report's config.
@@ -134,27 +134,27 @@ class CustomReportUtil:
         :param report_name: The name of the system report to run.
         :return: The CustomReport object for the given system report name.
         """
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         report_man = DataMgmtServer.get_custom_report_manager(user)
         return report_man.run_system_report_by_name(report_name, 1, 1)
 
     @staticmethod
-    def __exhaust_system_report(context: SapioWebhookContext | SapioUser,
+    def __exhaust_system_report(context: UserIdentifier,
                                 report_name: str,
                                 page_limit: int | None,
                                 page_size: int | None,
                                 page_number: int | None) \
-            -> tuple[list[ReportColumn], list[list[Any]]]:
+            -> tuple[list[ReportColumn], list[list[FieldValue]]]:
         """
         Given a system report, iterate over every page of the report and collect the results
         until there are no remaining pages.
         """
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
         result = None
         has_next_page: bool = True
-        rows: list[list[Any]] = []
+        rows: list[list[FieldValue]] = []
         cur_page: int = 1
         while has_next_page and (not page_limit or cur_page <= page_limit):
             result = report_man.run_system_report_by_name(report_name, page_size, page_number)
@@ -166,17 +166,17 @@ class CustomReportUtil:
         return result.column_list, rows
 
     @staticmethod
-    def __exhaust_custom_report(context: SapioWebhookContext | SapioUser,
+    def __exhaust_custom_report(context: UserIdentifier,
                                 report: CustomReportCriteria,
                                 page_limit: int | None,
                                 page_size: int | None,
                                 page_number: int | None) \
-            -> tuple[list[ReportColumn], list[list[Any]]]:
+            -> tuple[list[ReportColumn], list[list[FieldValue]]]:
         """
         Given a custom report, iterate over every page of the report and collect the results
         until there are no remaining pages.
         """
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
         result = None
@@ -185,7 +185,7 @@ class CustomReportUtil:
         if page_number is not None:
             report.page_number = page_number
         has_next_page: bool = True
-        rows: list[list[Any]] = []
+        rows: list[list[FieldValue]] = []
         cur_page: int = 1
         while has_next_page and (not page_limit or cur_page <= page_limit):
             result = report_man.run_custom_report(report)
@@ -197,22 +197,22 @@ class CustomReportUtil:
         return result.column_list, rows
 
     @staticmethod
-    def __exhaust_quick_report(context: SapioWebhookContext | SapioUser,
+    def __exhaust_quick_report(context: UserIdentifier,
                                report_term: RawReportTerm,
                                page_limit: int | None,
                                page_size: int | None,
                                page_number: int | None) \
-            -> tuple[list[ReportColumn], list[list[Any]]]:
+            -> tuple[list[ReportColumn], list[list[FieldValue]]]:
         """
         Given a quick report, iterate over every page of the report and collect the results
         until there are no remaining pages.
         """
-        user: SapioUser = context if isinstance(context, SapioUser) else context.user
+        user: SapioUser = AliasUtil.to_sapio_user(context)
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
         result = None
         has_next_page: bool = True
-        rows: list[list[Any]] = []
+        rows: list[list[FieldValue]] = []
         cur_page: int = 1
         while has_next_page and (not page_limit or cur_page <= page_limit):
             result = report_man.run_quick_report(report_term, page_size, page_number)
@@ -224,8 +224,8 @@ class CustomReportUtil:
         return result.column_list, rows
 
     @staticmethod
-    def __process_results(rows: list[list[Any]], columns: list[ReportColumn],
-                          filters: dict[str, Iterable[Any]] | None) -> list[dict[str, Any]]:
+    def __process_results(rows: list[list[FieldValue]], columns: list[ReportColumn],
+                          filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None) -> list[dict[str, FieldValue]]:
         """
         Given the results of a report as a list of row values and the report's columns, combine these lists to
         result in a singular list of dictionaries for each row in the results.
@@ -243,9 +243,11 @@ class CustomReportUtil:
             else:
                 encountered_names.append(field_name)
 
-        ret: list[dict[str, Any]] = []
+        filters: dict[str, Iterable[FieldValue]] = AliasUtil.to_data_field_names_dict(filters)
+
+        ret: list[dict[str, FieldValue]] = []
         for row in rows:
-            row_data: dict[str, Any] = {}
+            row_data: dict[str, FieldValue] = {}
             filter_row: bool = False
             for value, column in zip(row, columns):
                 header: str = column.data_field_name