sapiopycommons 2024.11.21a370__py3-none-any.whl → 2024.11.22a371__py3-none-any.whl

sapiopycommons/callbacks/field_builder.py

@@ -6,6 +6,7 @@ from sapiopylib.rest.pojo.datatype.FieldDefinition import VeloxStringFieldDefini
     VeloxLongFieldDefinition, VeloxPickListFieldDefinition, VeloxSelectionFieldDefinition, VeloxShortFieldDefinition, \
     SapioDoubleFormat, ListMode
 
+from sapiopycommons.general.aliases import FieldIdentifier, DataTypeIdentifier, AliasUtil
 from sapiopycommons.general.exceptions import SapioException
 
 
@@ -55,16 +56,17 @@ class FieldBuilder:
     """
     data_type: str
 
-    def __init__(self, data_type: str = "Default"):
+    def __init__(self, data_type: DataTypeIdentifier = "Default"):
         """
         :param data_type: The data type name that fields created from this builder will use as their data type.
         """
-        self.data_type = data_type
+        self.data_type = AliasUtil.to_data_type_name(data_type)
 
-    def accession_field(self, field_name: str, sequence_key: str, prefix: str | None = None, suffix: str | None = None,
-                        number_of_digits: int = 8, starting_value: int = 1, link_out: dict[str, str] | None = None,
-                        abstract_info: AnyFieldInfo | None = None, *, data_type_name: str | None = None,
-                        display_name: str | None = None) -> VeloxAccessionFieldDefinition:
+    def accession_field(self, field_name: FieldIdentifier, sequence_key: str, prefix: str | None = None,
+                        suffix: str | None = None, number_of_digits: int = 8, starting_value: int = 1,
+                        link_out: dict[str, str] | None = None, abstract_info: AnyFieldInfo | None = None, *,
+                        data_type_name: DataTypeIdentifier | None = None, display_name: str | None = None) \
+            -> VeloxAccessionFieldDefinition:
         """
         Create an accession field definition. Accession fields are text fields which generate a unique value
         that has not been used before, incrementing from the most recently generated value. This can be used when a
@@ -98,10 +100,10 @@ class FieldBuilder:
             field name doubles as the display name.
         :return: An accession field definition with settings from the input criteria.
         """
+        data_type_name: str = AliasUtil.to_data_type_name(data_type_name) if data_type_name else self.data_type
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         if abstract_info is None:
             abstract_info = AnyFieldInfo()
-        if not data_type_name:
-            data_type_name = self.data_type
         if not display_name:
             display_name = field_name
         # Accession fields lock editable to false.
@@ -110,10 +112,11 @@ class FieldBuilder:
         # The unique parameter has no effect, so just always set it to false.
         return VeloxAccessionFieldDefinition(data_type_name, field_name, display_name, sequence_key, prefix, suffix,
                                              number_of_digits, False, starting_value, link_out, link_out_url,
-                                             kwargs=abstract_info.__dict__)
+                                             **abstract_info.__dict__)
 
-    def boolean_field(self, field_name: str, default_value: bool | None = False, abstract_info: AnyFieldInfo | None = None,
-                      *, data_type_name: str | None = None, display_name: str | None = None) -> VeloxBooleanFieldDefinition:
+    def boolean_field(self, field_name: FieldIdentifier, default_value: bool | None = False,
+                      abstract_info: AnyFieldInfo | None = None, *, data_type_name: DataTypeIdentifier | None = None,
+                      display_name: str | None = None) -> VeloxBooleanFieldDefinition:
         """
         Create a boolean field definition. Boolean fields are fields which may have a value of true or false.
         They appear as a checkbox in the UI. Boolean fields may also have a value of null if the field is not required.
@@ -128,20 +131,21 @@ class FieldBuilder:
             field name doubles as the display name.
         :return: A boolean field definition with settings from the input criteria.
         """
+        data_type_name: str = AliasUtil.to_data_type_name(data_type_name) if data_type_name else self.data_type
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         if abstract_info is None:
             abstract_info = AnyFieldInfo()
             # Boolean fields assume that they are required if no abstract info is provided.
             abstract_info.required = True
-        if not data_type_name:
-            data_type_name = self.data_type
         if not display_name:
             display_name = field_name
         return VeloxBooleanFieldDefinition(data_type_name, field_name, display_name, default_value,
-                                           kwargs=abstract_info.__dict__)
+                                           **abstract_info.__dict__)
 
-    def date_field(self, field_name: str, default_value: int | None = None, date_time_format: str = "MMM dd, yyyy",
+    def date_field(self, field_name: FieldIdentifier, default_value: int | None = None, date_time_format: str = "MMM dd, yyyy",
                    static_date: bool = False, abstract_info: AnyFieldInfo | None = None, *,
-                   data_type_name: str | None = None, display_name: str | None = None) -> VeloxDateFieldDefinition:
+                   data_type_name: DataTypeIdentifier | None = None, display_name: str | None = None) \
+            -> VeloxDateFieldDefinition:
         """
         Create a date field definition. Date fields store date and time information as an integer
         representing the number of milliseconds since the unix epoch. This timestamp is then displayed to users in a
@@ -162,18 +166,18 @@ class FieldBuilder:
             field name doubles as the display name.
         :return: A date field definition with settings from the input criteria.
         """
+        data_type_name: str = AliasUtil.to_data_type_name(data_type_name) if data_type_name else self.data_type
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         if abstract_info is None:
             abstract_info = AnyFieldInfo()
-        if not data_type_name:
-            data_type_name = self.data_type
         if not display_name:
             display_name = field_name
         return VeloxDateFieldDefinition(data_type_name, field_name, display_name, date_time_format, default_value,
-                                        static_date, kwargs=abstract_info.__dict__)
+                                        static_date, **abstract_info.__dict__)
 
-    def date_range_field(self, field_name: str, default_value: str | DateRange | None = None,
+    def date_range_field(self, field_name: FieldIdentifier, default_value: str | DateRange | None = None,
                          date_time_format: str = "MMM dd, yyyy", static_date: bool = False,
-                         abstract_info: AnyFieldInfo | None = None, *, data_type_name: str | None = None,
+                         abstract_info: AnyFieldInfo | None = None, *, data_type_name: DataTypeIdentifier | None = None,
                          display_name: str | None = None) -> VeloxDateRangeFieldDefinition:
         """
         Create a date range field definition. Date range fields store two unix epoch timestamps as a string of the
@@ -198,20 +202,20 @@ class FieldBuilder:
             field name doubles as the display name.
         :return: A date range field definition with settings from the input criteria.
         """
+        data_type_name: str = AliasUtil.to_data_type_name(data_type_name) if data_type_name else self.data_type
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         if abstract_info is None:
             abstract_info = AnyFieldInfo()
-        if not data_type_name:
-            data_type_name = self.data_type
         if not display_name:
             display_name = field_name
         if isinstance(default_value, DateRange):
             default_value = str(default_value)
         return VeloxDateRangeFieldDefinition(data_type_name, field_name, display_name, date_time_format, static_date,
-                                             default_value, kwargs=abstract_info.__dict__)
+                                             default_value, **abstract_info.__dict__)
 
-    def double_field(self, field_name: str, default_value: float | None = None, min_value: float = -10.**120,
+    def double_field(self, field_name: FieldIdentifier, default_value: float | None = None, min_value: float = -10.**120,
                      max_value: float = 10.**120, precision: int = 1, double_format: SapioDoubleFormat | None = None,
-                     abstract_info: AnyFieldInfo | None = None, *, data_type_name: str | None = None,
+                     abstract_info: AnyFieldInfo | None = None, *, data_type_name: DataTypeIdentifier | None = None,
                      display_name: str | None = None) -> VeloxDoubleFieldDefinition:
         """
         Create a double field definition. Double fields represent decimal numerical values. They can also
@@ -232,17 +236,17 @@ class FieldBuilder:
             field name doubles as the display name.
         :return: A double field definition with settings from the input criteria.
         """
+        data_type_name: str = AliasUtil.to_data_type_name(data_type_name) if data_type_name else self.data_type
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         if abstract_info is None:
             abstract_info = AnyFieldInfo()
-        if not data_type_name:
-            data_type_name = self.data_type
         if not display_name:
             display_name = field_name
         return VeloxDoubleFieldDefinition(data_type_name, field_name, display_name, min_value, max_value, default_value,
-                                          precision, double_format, kwargs=abstract_info.__dict__)
+                                          precision, double_format, **abstract_info.__dict__)
 
-    def enum_field(self, field_name: str, options: list[str], default_value: int | None = None,
-                   abstract_info: AnyFieldInfo | None = None, *, data_type_name: str | None = None,
+    def enum_field(self, field_name: FieldIdentifier, options: list[str], default_value: int | None = None,
+                   abstract_info: AnyFieldInfo | None = None, *, data_type_name: DataTypeIdentifier | None = None,
                    display_name: str | None = None) -> VeloxEnumFieldDefinition:
         """
         Create an enum field definition. Enum fields allow for the display of a list of options as a field
@@ -268,18 +272,19 @@ class FieldBuilder:
             field name doubles as the display name.
         :return: An enum field definition with settings from the input criteria.
         """
+        data_type_name: str = AliasUtil.to_data_type_name(data_type_name) if data_type_name else self.data_type
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         if abstract_info is None:
             abstract_info = AnyFieldInfo()
-        if not data_type_name:
-            data_type_name = self.data_type
         if not display_name:
             display_name = field_name
         return VeloxEnumFieldDefinition(data_type_name, field_name, display_name, default_value, options,
-                                        kwargs=abstract_info.__dict__)
+                                        **abstract_info.__dict__)
 
-    def int_field(self, field_name: str, default_value: int | None = None, min_value: int = -2**31,
+    def int_field(self, field_name: FieldIdentifier, default_value: int | None = None, min_value: int = -2**31,
                   max_value: int = 2**31 - 1, unique_value: bool = False, abstract_info: AnyFieldInfo | None = None, *,
-                  data_type_name: str | None = None, display_name: str | None = None) -> VeloxIntegerFieldDefinition:
+                  data_type_name: DataTypeIdentifier | None = None, display_name: str | None = None) \
+            -> VeloxIntegerFieldDefinition:
         """
         Create an integer field definition. Integer fields are 32-bit whole numbers.
 
@@ -296,18 +301,19 @@ class FieldBuilder:
             field name doubles as the display name.
         :return: An integer field definition with settings from the input criteria.
         """
+        data_type_name: str = AliasUtil.to_data_type_name(data_type_name) if data_type_name else self.data_type
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         if abstract_info is None:
             abstract_info = AnyFieldInfo()
-        if not data_type_name:
-            data_type_name = self.data_type
         if not display_name:
             display_name = field_name
         return VeloxIntegerFieldDefinition(data_type_name, field_name, display_name, min_value, max_value,
-                                           default_value, unique_value, kwargs=abstract_info.__dict__)
+                                           default_value, unique_value, **abstract_info.__dict__)
 
-    def long_field(self, field_name: str, default_value: int | None = None, min_value: int = -2**63,
+    def long_field(self, field_name: FieldIdentifier, default_value: int | None = None, min_value: int = -2**63,
                    max_value: int = 2**63 - 1, unique_value: bool = False, abstract_info: AnyFieldInfo | None = None, *,
-                   data_type_name: str | None = None, display_name: str | None = None) -> VeloxLongFieldDefinition:
+                   data_type_name: DataTypeIdentifier | None = None, display_name: str | None = None) \
+            -> VeloxLongFieldDefinition:
         """
         Create a long field definition. Long fields are 64-bit whole numbers.
 
@@ -324,18 +330,19 @@ class FieldBuilder:
             field name doubles as the display name.
         :return: A long field definition with settings from the input criteria.
         """
+        data_type_name: str = AliasUtil.to_data_type_name(data_type_name) if data_type_name else self.data_type
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         if abstract_info is None:
             abstract_info = AnyFieldInfo()
-        if not data_type_name:
-            data_type_name = self.data_type
         if not display_name:
             display_name = field_name
         return VeloxLongFieldDefinition(data_type_name, field_name, display_name, min_value, max_value, default_value,
-                                        unique_value, kwargs=abstract_info.__dict__)
+                                        unique_value, **abstract_info.__dict__)
 
-    def pick_list_field(self, field_name: str, pick_list_name: str, default_value: str | None = None,
+    def pick_list_field(self, field_name: FieldIdentifier, pick_list_name: str, default_value: str | None = None,
                         direct_edit: bool = False, abstract_info: AnyFieldInfo | None = None, *,
-                        data_type_name: str | None = None, display_name: str | None = None) -> VeloxPickListFieldDefinition:
+                        data_type_name: DataTypeIdentifier | None = None, display_name: str | None = None) \
+            -> VeloxPickListFieldDefinition:
         """
         Create a pick list field definition. Pick list fields are string fields that display a drop-down list of options
         when being edited by a user. The list of options is backed by a pick list defined in the list manager sections
@@ -355,22 +362,22 @@ class FieldBuilder:
             field name doubles as the display name.
         :return: A pick list field definition with settings from the input criteria.
         """
+        data_type_name: str = AliasUtil.to_data_type_name(data_type_name) if data_type_name else self.data_type
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         if abstract_info is None:
             abstract_info = AnyFieldInfo()
-        if not data_type_name:
-            data_type_name = self.data_type
         if not display_name:
             display_name = field_name
         return VeloxPickListFieldDefinition(data_type_name, field_name, display_name, pick_list_name, default_value,
-                                            direct_edit, kwargs=abstract_info.__dict__)
+                                            direct_edit, **abstract_info.__dict__)
 
-    def selection_list_field(self, field_name: str, default_value: str | None = None, direct_edit: bool = False,
-                             multi_select: bool = False, unique_value: bool = False,
+    def selection_list_field(self, field_name: FieldIdentifier, default_value: str | None = None,
+                             direct_edit: bool = False, multi_select: bool = False, unique_value: bool = False,
                              abstract_info: AnyFieldInfo | None = None, *, pick_list_name: str | None = None,
                              custom_report_name: str | None = None, plugin_name: str | None = None,
                              static_values: list[str] | None = None, user_list: bool = False,
                              user_group_list: bool = False, non_api_user_list: bool = False,
-                             data_type_name: str | None = None, display_name: str | None = None) \
+                             data_type_name: DataTypeIdentifier | None = None, display_name: str | None = None) \
             -> VeloxSelectionFieldDefinition:
         """
         Create a selection list field definition. Selection list fields are string fields that display a drop-down list
@@ -401,10 +408,10 @@ class FieldBuilder:
             field name doubles as the display name.
         :return: A selection list field definition with settings from the input criteria.
         """
+        data_type_name: str = AliasUtil.to_data_type_name(data_type_name) if data_type_name else self.data_type
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         if abstract_info is None:
             abstract_info = AnyFieldInfo()
-        if not data_type_name:
-            data_type_name = self.data_type
         if not display_name:
             display_name = field_name
 
@@ -443,11 +450,12 @@ class FieldBuilder:
                                              list_mode, unique_value, multi_select,
                                              default_value, pick_list_name, custom_report_name,
                                              plugin_name, direct_edit, static_values,
-                                             kwargs=abstract_info.__dict__)
+                                             **abstract_info.__dict__)
 
-    def short_field(self, field_name: str, default_value: int | None = None, min_value: int = -2**15,
+    def short_field(self, field_name: FieldIdentifier, default_value: int | None = None, min_value: int = -2**15,
                     max_value: int = 2**15 - 1, unique_value: bool = False, abstract_info: AnyFieldInfo | None = None,
-                    *, data_type_name: str | None = None, display_name: str | None = None) -> VeloxShortFieldDefinition:
+                    *, data_type_name: DataTypeIdentifier | None = None, display_name: str | None = None) \
+            -> VeloxShortFieldDefinition:
         """
         Create a short field definition. Short fields are 16-bit whole numbers.
 
@@ -464,21 +472,21 @@ class FieldBuilder:
             field name doubles as the display name.
         :return: A short field definition with settings from the input criteria.
         """
+        data_type_name: str = AliasUtil.to_data_type_name(data_type_name) if data_type_name else self.data_type
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         if abstract_info is None:
             abstract_info = AnyFieldInfo()
-        if not data_type_name:
-            data_type_name = self.data_type
         if not display_name:
             display_name = field_name
         return VeloxShortFieldDefinition(data_type_name, field_name, display_name, min_value, max_value, default_value,
-                                         unique_value, kwargs=abstract_info.__dict__)
-
-    def string_field(self, field_name: str,
-                     default_value: str | None = None, max_length: int = 100, unique_value: bool = False,
-                     html_editor: bool = False, string_format: SapioStringFormat | None = None, num_lines: int = 1,
-                     auto_size: bool = False, link_out: dict[str, str] | None = None,
-                     field_validator: FieldValidator | None = None, abstract_info: AnyFieldInfo | None = None, *,
-                     data_type_name: str | None = None, display_name: str | None = None) -> VeloxStringFieldDefinition:
+                                         unique_value, **abstract_info.__dict__)
+
+    def string_field(self, field_name: FieldIdentifier, default_value: str | None = None, max_length: int = 100,
+                     unique_value: bool = False, html_editor: bool = False,
+                     string_format: SapioStringFormat | None = None, num_lines: int = 1, auto_size: bool = False,
+                     link_out: dict[str, str] | None = None, field_validator: FieldValidator | None = None,
+                     abstract_info: AnyFieldInfo | None = None, *, data_type_name: DataTypeIdentifier | None = None,
+                     display_name: str | None = None) -> VeloxStringFieldDefinition:
         """
         Create a string field definition. String fields represent text, and are highly customizable, allowing the
         field to be plain text or rich HTML, take up one line of space or multiple on a form, format as emails or
@@ -516,16 +524,16 @@ class FieldBuilder:
             field name doubles as the display name.
         :return: A string field definition with settings from the input criteria.
         """
+        data_type_name: str = AliasUtil.to_data_type_name(data_type_name) if data_type_name else self.data_type
+        field_name: str = AliasUtil.to_data_field_name(field_name)
         if abstract_info is None:
             abstract_info = AnyFieldInfo()
-        if not data_type_name:
-            data_type_name = self.data_type
         if not display_name:
             display_name = field_name
         link_out, link_out_url = self._convert_link_out(link_out)
         return VeloxStringFieldDefinition(data_type_name, field_name, display_name, default_value, max_length,
                                           unique_value, html_editor, string_format, num_lines, auto_size, link_out,
-                                          link_out_url, field_validator, kwargs=abstract_info.__dict__)
+                                          link_out_url, field_validator, **abstract_info.__dict__)
 
     @staticmethod
     def _convert_link_out(link_out: dict[str, str] | None) -> tuple[bool, str | None]:

sapiopycommons/general/custom_report_util.py

@@ -29,8 +29,10 @@ class CustomReportUtil:
             filter on. Only those headers that both the filters and the custom report share will take effect. That is,
             any filters that have a header name that isn't in the custom report will be ignored.
         :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
-        :param page_size: The size of each page of results in the search. If None, the page size is set by the server.
-        :param page_number: The page number to start the search from, If None, starts on the first page.
+        :param page_size: The size of each page of results in the search. If None, the page size is set by the server,
+            which may be unlimited.
+        :param page_number: The page number to start the search from, If None, starts on the first page. Note that the
+            number of the first page is 0.
         :return: The results of the report listed row by row, mapping each cell to the header it is under. The header
             values in the dicts are the data field names of the columns.
             If two columns in the search have the same data field name but differing data type names, then the
@@ -38,11 +40,11 @@ class CustomReportUtil:
             had a Sample column with a data field name of Identifier and a Request column with the same data field name,
             then the dictionary keys for these columns would be Sample.Identifier and Request.Identifier respectively.
         """
-        results: tuple = CustomReportUtil.__exhaust_system_report(context, report_name, page_limit,
-                                                                  page_size, page_number)
+        results: tuple = CustomReportUtil._exhaust_system_report(context, report_name, page_limit,
+                                                                 page_size, page_number)
         columns: list[ReportColumn] = results[0]
         rows: list[list[FieldValue]] = results[1]
-        return CustomReportUtil.__process_results(rows, columns, filters)
+        return CustomReportUtil._process_results(rows, columns, filters)
 
     @staticmethod
     def run_custom_report(context: UserIdentifier,
@@ -71,7 +73,8 @@ class CustomReportUtil:
         :param page_size: The size of each page of results in the search. If None, uses the value from the given report
             criteria. If not None, overwrites the value from the given report criteria.
         :param page_number: The page number to start the search from, If None, uses the value from the given report
-            criteria. If not None, overwrites the value from the given report criteria.
+            criteria. If not None, overwrites the value from the given report criteria. Note that the number of the
+            first page is 0.
         :return: The results of the report listed row by row, mapping each cell to the header it is under. The header
             values in the dicts are the data field names of the columns.
             If two columns in the search have the same data field name but differing data type names, then the
@@ -79,11 +82,11 @@ class CustomReportUtil:
             had a Sample column with a data field name of Identifier and a Request column with the same data field name,
             then the dictionary keys for these columns would be Sample.Identifier and Request.Identifier respectively.
         """
-        results: tuple = CustomReportUtil.__exhaust_custom_report(context, report_criteria, page_limit,
-                                                                  page_size, page_number)
+        results: tuple = CustomReportUtil._exhaust_custom_report(context, report_criteria, page_limit,
+                                                                 page_size, page_number)
         columns: list[ReportColumn] = results[0]
         rows: list[list[FieldValue]] = results[1]
-        return CustomReportUtil.__process_results(rows, columns, filters)
+        return CustomReportUtil._process_results(rows, columns, filters)
 
     @staticmethod
     def run_quick_report(context: UserIdentifier,
@@ -107,16 +110,18 @@ class CustomReportUtil:
             filter on. Only those headers that both the filters and the custom report share will take effect. That is,
             any filters that have a header name that isn't in the custom report will be ignored.
         :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
-        :param page_size: The size of each page of results in the search. If None, the page size is set by the server.
-        :param page_number: The page number to start the search from, If None, starts on the first page.
+        :param page_size: The size of each page of results in the search. If None, the page size is set by the server,
+            which may be unlimited.
+        :param page_number: The page number to start the search from, If None, starts on the first page. Note that the
+            number of the first page is 0.
         :return: The results of the report listed row by row, mapping each cell to the header it is under. The header
             values in the dicts are the data field names of the columns.
         """
-        results: tuple = CustomReportUtil.__exhaust_quick_report(context, report_term, page_limit,
-                                                                 page_size, page_number)
+        results: tuple = CustomReportUtil._exhaust_quick_report(context, report_term, page_limit,
+                                                                page_size, page_number)
         columns: list[ReportColumn] = results[0]
         rows: list[list[FieldValue]] = results[1]
-        return CustomReportUtil.__process_results(rows, columns, filters)
+        return CustomReportUtil._process_results(rows, columns, filters)
 
     @staticmethod
     def get_system_report_criteria(context: UserIdentifier, report_name: str) -> CustomReport:
@@ -136,14 +141,14 @@ class CustomReportUtil:
         """
         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)
+        return report_man.run_system_report_by_name(report_name, 1, 0)
 
     @staticmethod
-    def __exhaust_system_report(context: UserIdentifier,
-                                report_name: str,
-                                page_limit: int | None,
-                                page_size: int | None,
-                                page_number: int | None) \
+    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[FieldValue]]]:
         """
         Given a system report, iterate over every page of the report and collect the results
@@ -152,6 +157,11 @@ class CustomReportUtil:
         user: SapioUser = AliasUtil.to_sapio_user(context)
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
+        # If a page size was provided but no page number was provided, then set the page number to 0,
+        # as both parameters are necessary in order to get paged results.
+        if page_size is not None and page_number is None:
+            page_number = 0
+
         result = None
         has_next_page: bool = True
         rows: list[list[FieldValue]] = []
@@ -159,18 +169,18 @@ class CustomReportUtil:
         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)
             page_size = result.page_size
-            page_number = result.page_number
+            page_number = result.page_number + 1
             has_next_page = result.has_next_page
             rows.extend(result.result_table)
             cur_page += 1
         return result.column_list, rows
 
     @staticmethod
-    def __exhaust_custom_report(context: UserIdentifier,
-                                report: CustomReportCriteria,
-                                page_limit: int | None,
-                                page_size: int | None,
-                                page_number: int | None) \
+    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[FieldValue]]]:
         """
         Given a custom report, iterate over every page of the report and collect the results
@@ -179,6 +189,11 @@ class CustomReportUtil:
         user: SapioUser = AliasUtil.to_sapio_user(context)
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
+        # If a page size was provided but no page number was provided, then set the page number to 0,
+        # as both parameters are necessary in order to get paged results.
+        if page_size is not None and page_number is None:
+            page_number = 0
+
         result = None
         if page_size is not None:
             report.page_size = page_size
@@ -190,18 +205,18 @@ class CustomReportUtil:
         while has_next_page and (not page_limit or cur_page <= page_limit):
             result = report_man.run_custom_report(report)
             report.page_size = result.page_size
-            report.page_number = result.page_number
+            report.page_number = result.page_number + 1
             has_next_page = result.has_next_page
             rows.extend(result.result_table)
             cur_page += 1
         return result.column_list, rows
 
     @staticmethod
-    def __exhaust_quick_report(context: UserIdentifier,
-                               report_term: RawReportTerm,
-                               page_limit: int | None,
-                               page_size: int | None,
-                               page_number: int | None) \
+    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[FieldValue]]]:
         """
         Given a quick report, iterate over every page of the report and collect the results
@@ -210,6 +225,11 @@ class CustomReportUtil:
         user: SapioUser = AliasUtil.to_sapio_user(context)
         report_man = DataMgmtServer.get_custom_report_manager(user)
 
+        # If a page size was provided but no page number was provided, then set the page number to 0,
+        # as both parameters are necessary in order to get paged results.
+        if page_size is not None and page_number is None:
+            page_number = 0
+
         result = None
         has_next_page: bool = True
         rows: list[list[FieldValue]] = []
@@ -217,15 +237,15 @@ class CustomReportUtil:
         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)
             page_size = result.page_size
-            page_number = result.page_number
+            page_number = result.page_number + 1
             has_next_page = result.has_next_page
             rows.extend(result.result_table)
             cur_page += 1
         return result.column_list, rows
 
     @staticmethod
-    def __process_results(rows: list[list[FieldValue]], columns: list[ReportColumn],
-                          filters: dict[FieldIdentifierKey, Iterable[FieldValue]] | None) -> list[dict[str, FieldValue]]:
+    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.

sapiopycommons/recordmodel/record_handler.py

@@ -297,7 +297,7 @@ class RecordHandler:
             not None, in which case it overwrites the given report's value.
         :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.
+            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 isinstance(report_name, str):
@@ -966,7 +966,7 @@ class RecordHandler:
                     current = current.get_forward_side_link(node.data_field_name)
                 elif direction == RelationshipNodeType.REVERSE_SIDE_LINK:
                     field_name: str = node.data_field_name
-                    reverse_links: list[PyRecordModel] = current.get_reverse_side_link(field_name, data_type)
+                    reverse_links: list[PyRecordModel] = current.get_reverse_side_link(data_type, field_name)
                     if not reverse_links:
                         current = None
                     elif len(reverse_links) > 1:
@@ -1016,7 +1016,7 @@ class RecordHandler:
                     elif direction == RelationshipNodeType.FORWARD_SIDE_LINK:
                         next_search.add(search.get_forward_side_link(node.data_field_name))
                     elif direction == RelationshipNodeType.REVERSE_SIDE_LINK:
-                        next_search.update(search.get_reverse_side_link(node.data_field_name, data_type))
+                        next_search.update(search.get_reverse_side_link(data_type, node.data_field_name))
                     else:
                         raise SapioException("Unsupported path direction.")
                 current_search = next_search
@@ -1064,7 +1064,7 @@ class RecordHandler:
                 elif direction == RelationshipNodeType.FORWARD_SIDE_LINK:
                     current = [current[0].get_forward_side_link(node.data_field_name)]
                 elif direction == RelationshipNodeType.REVERSE_SIDE_LINK:
-                    current = current[0].get_reverse_side_link(node.data_field_name, data_type)
+                    current = current[0].get_reverse_side_link(data_type, node.data_field_name)
                 else:
                     raise SapioException("Unsupported path direction.")
             ret_dict.update({model: self.inst_man.wrap(current[0], wrapper_type) if current else None})

sapiopycommons/sftpconnect/sftp_builder.py

@@ -4,6 +4,7 @@ from enum import Enum
 import paramiko
 from paramiko import pkey
 from paramiko.sftp_client import SFTPClient
+
 from sapiopycommons.general.exceptions import SapioException
 
 

sapiopycommons/webhook/webhook_handlers.py

@@ -190,7 +190,7 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
         Handle a generic exception which isn't one of the handled Sapio exceptions.
 
         Default behavior returns a false webhook result with a generic error message as display text informing the user
-        to contact Sapio support. Additionally, the stace trace of the exception that was thrown is logged to the
+        to contact Sapio support. Additionally, the stack trace of the exception that was thrown is logged to the
         execution log for the webhook call in the system.
 
         :param e: The exception that was raised.
@@ -214,22 +214,24 @@ class CommonsWebhookHandler(AbstractWebhookHandler):
 
         :param e: The exception that was raised.
         :return: An optional SapioWebhookResult. May return a custom message to the client that wouldn't have been
-            sent by one of the normal exception handlers, or may return None if no result needs returned. It a result is
+            sent by one of the normal exception handlers, or may return None if no result needs returned. If a result is
             returned, then the default behavior of other exception handlers is skipped.
         """
         return None
 
     def log_info(self, msg: str) -> None:
         """
-        Write an info message to the webhook server log. Log destination is stdout. This message will be prepended with
-        the user's username and the experiment ID of the experiment they are in, if any.
+        Write an info message to the webhook server log. Log destination is stdout. This message will include
+        information about the user's group, their location in the system, the webhook invocation type, and other
+        important information that can be gathered from the context that is useful for debugging.
         """
         self.logger.info(self._format_log(msg, "log_info call"))
 
     def log_error(self, msg: str) -> None:
         """
-        Write an error message to the webhook server log. Log destination is stderr. This message will be prepended with
-        the user's username and the experiment ID of the experiment they are in, if any.
+        Write an info message to the webhook server log. Log destination is stdout. This message will include
+        information about the user's group, their location in the system, the webhook invocation type, and other
+        important information that can be gathered from the context that is useful for debugging.
         """
         # PR-46209: Use logger.error instead of logger.info when logging errors.
         self.logger.error(self._format_log(msg, "log_error call"))

sapiopycommons/webhook/webservice_handlers.py

@@ -1,42 +1,119 @@
 import sys
 import traceback
-from abc import abstractmethod
+from abc import abstractmethod, ABC
+from base64 import b64decode
+from logging import Logger
 from typing import Any
 
-from flask import request
+from flask import request, Response, Request
+from sapiopylib.rest.DataRecordManagerService import DataRecordManager
 from sapiopylib.rest.User import SapioUser
 from sapiopylib.rest.WebhookService import AbstractWebhookHandler
-from sapiopylib.rest.pojo.webhook.WebhookResult import SapioWebhookResult
+from sapiopylib.rest.utils.DataTypeCacheManager import DataTypeCacheManager
+from sapiopylib.rest.utils.recordmodel.RecordModelManager import RecordModelManager, RecordModelInstanceManager, \
+    RecordModelRelationshipManager
+from sapiopylib.rest.utils.recordmodel.ancestry import RecordModelAncestorManager
+from werkzeug.datastructures import Headers
+from werkzeug.datastructures.structures import MultiDict
 
+from sapiopycommons.general.exceptions import SapioException
+from sapiopycommons.recordmodel.record_handler import RecordHandler
 
-class AbstractWebserviceHandler(AbstractWebhookHandler):
+
+class SapioWebserviceException(Exception):
+    """
+    An exception to be thrown by webservice classes when responding to a request with an error.
     """
-    A base class for constructing "webservice" endpoints on your webhook server. These are endpoints that can be
-    communicated with by external sources without needing to format the payload JSON in the webhook context format that
-    webhook handlers expect.
+    msg: str
+    code: int
+
+    def __init__(self, msg: str, code: int = 500):
+        """
+        :param msg: The message to return in the webservice response.
+        :param code: The status code to return in the webservice response.
+        """
+        self.msg = msg
+        self.code = code
 
-    The entire payload JSON is sent to the run method of this class. It is up to the run method to determine how
-    this JSON should be parsed. In order to communicate with a Sapio system, a SapioUser object must be able to be
-    defined using the payload. Functions have been provided for constructing users with various authentication methods.
 
-    Since this extends AbstractWebhookHandler, you can still register endpoints from this class in the same way you
-    would normal webhook endpoints.
+class SapioWebserviceResult:
+    """
+    A result to be returned by AbstractWebserviceHandler endpoints, for sending information back to the caller.
     """
-    def post(self) -> dict[str, Any]:
+    message: str
+    is_error: bool
+    status_code: int
+    payload: dict[str, Any]
+
+    def __init__(self, message: str = "Success", status_code: int = 200, is_error: bool = False,
+                 payload: dict[str, Any] | None = None):
         """
-        Internal method to be executed to translate incoming requests.
+        :param message: A message to return to the sender describing what happened.
+        :param status_code: An HTTP status code to return to the sender.
+        :param is_error: Whether the webservice had an error during processing.
+        :param payload: A payload of additional information to return to the sender.
         """
-        # noinspection PyBroadException
+        self.message = message
+        self.status_code = status_code
+        self.is_error = is_error
+        self.payload = payload
+        if payload is None:
+            self.payload = {}
+
+    def to_json(self) -> dict[str, Any]:
+        return {"message": self.message,
+                "statusCode": self.status_code,
+                "isError": self.is_error,
+                "payload": self.payload}
+
+    def to_result(self) -> tuple[dict[str, Any], int]:
+        return self.to_json(), self.status_code
+
+
+WebserviceResponse = SapioWebserviceResult | Response | tuple[dict[str, Any] | int]
+
+
+class BaseAuthenticatorClass(AbstractWebhookHandler, ABC):
+    """
+    The base class for classes that may need to authenticate a SapioUser object for interacting with a Sapio server
+    through the webservice API.
+    """
+    def authenticate_user(self, headers: dict[str, str]) -> SapioUser:
+        """
+        Authenticate a user for making requests to a Sapio server using the provided headers. If no user can be
+        authenticated, then an exception will be thrown.
+
+        :param headers: The headers of the webservice request.
+        :return: A SapioUser object used to make requests to a Sapio server as authorized by the headers.
+        """
+        # Get the system URL from the headers.
+        if "System-URL" not in headers:
+            raise SapioWebserviceException("No \"System-URL\" provided in headers.", 400)
+        url: str = headers.get("System-URL")
+        if not url.endswith("/webservice/api"):
+            raise SapioWebserviceException(f"\"System-URL\" must be a webservice API URL for the target system: {url}", 400)
+
+        # Get the login credentials from the headers.
+        auth: str = headers.get("Authorization")
+        if auth and auth.startswith("Basic "):
+            credentials: list[str] = b64decode(auth.split("Basic ")[1]).decode().split(":")
+            user = self.basic_auth(url, credentials[0], credentials[1])
+        elif auth and auth.startswith("Bearer "):
+            user = self.bearer_token_auth(url, auth.split("Bearer ")[1])
+        elif "X-API-TOKEN" in headers:
+            user = self.api_token_auth(url, headers.get("X-API-TOKEN"))
+        else:
+            raise SapioWebserviceException(f"Unrecognized Authorization method.", 400)
+        # Make a simple webservice call to confirm that the credentials are valid.
         try:
-            return self.run(request.json).to_json()
+            # noinspection PyStatementEffect
+            user.session_additional_data
         except Exception:
-            print('Error occurred while running webservice custom logic. See traceback.', file=sys.stderr)
-            traceback.print_exc()
-            return SapioWebhookResult(False, display_text="Error occurred during webservice execution.").to_json()
-
-    @abstractmethod
-    def run(self, payload: dict[str, Any]) -> SapioWebhookResult:
-        pass
+            if "Unauthorized (javax.ws.rs.NotAuthorizedException: Incorrect username or password.)" in traceback.format_exc():
+                raise SapioWebserviceException("Unauthorized. Incorrect username or password.", 401)
+            else:
+                raise SapioWebserviceException("System-URL is invalid or user cannot be authenticated.", 401)
+        return user
 
     def basic_auth(self, url: str, username: str, password: str) -> SapioUser:
         """
@@ -65,3 +142,245 @@ class AbstractWebserviceHandler(AbstractWebhookHandler):
         :return: A SapioUser that will authenticate requests using a bearer token.
         """
         return SapioUser(url, self.verify_sapio_cert, self.client_timeout_seconds, bearer_token=bearer_token)
+
+
+class AbstractWebservicePostHandler(BaseAuthenticatorClass):
+    """
+    A base class for constructing POST webservice endpoints on your webhook server. These are endpoints that can be
+    communicated with by external sources without needing to format the request in the webhook context format that
+    normal webhook handlers expect.
+
+    Since this extends AbstractWebhookHandler, you can still register endpoints from this class in the same way you
+    would normal webhook endpoints.
+    """
+    request: Request
+
+    def post(self) -> Response | tuple[dict[str, Any], int]:
+        """
+        Internal method to be executed to translate incoming POST requests.
+        """
+        # noinspection PyBroadException
+        try:
+            self.request = request
+            ret_val: WebserviceResponse = self.run(request.json, request.headers, request.args)
+            if isinstance(ret_val, SapioWebserviceResult):
+                return ret_val.to_result()
+            return ret_val
+        except Exception:
+            print('Error occurred while running webservice custom logic. See traceback.', file=sys.stderr)
+            traceback.print_exc()
+            return SapioWebserviceResult("Unexpected error occurred.", 500, True).to_json(), 500
+
+    # noinspection PyMethodOverriding
+    @abstractmethod
+    def run(self, payload: Any, headers: Headers, params: MultiDict[str, str]) -> WebserviceResponse:
+        """
+        The execution details for this endpoint.
+
+        :param payload: The JSON payload from the request. Usually a dictionary of strings to Any.
+        :param headers: The headers from the request. Can be used like a dictionary.
+        :param params: The URL parameters from the request.
+        :return: A response object to send back to the requester.
+        """
+        pass
+
+
+class AbstractWebserviceGetHandler(BaseAuthenticatorClass):
+    """
+    A base class for constructing GET webservice endpoints on your webhook server. These are endpoints that can be
+    communicated with by external sources without needing to format the request in the webhook context format that
+    normal webhook handlers expect.
+
+    Since this extends AbstractWebhookHandler, you can still register endpoints from this class in the same way you
+    would normal webhook endpoints.
+    """
+    request: Request
+
+    def get(self) -> Response | tuple[dict[str, Any], int]:
+        """
+        Internal method to be executed to translate incoming GET requests.
+        """
+        # noinspection PyBroadException
+        try:
+            self.request = request
+            ret_val: WebserviceResponse = self.run(request.headers, request.args)
+            if isinstance(ret_val, SapioWebserviceResult):
+                return ret_val.to_result()
+            return ret_val
+        except Exception:
+            print('Error occurred while running webservice custom logic. See traceback.', file=sys.stderr)
+            traceback.print_exc()
+            return SapioWebserviceResult("Unexpected error occurred.", 500, True).to_json(), 500
+
+    # noinspection PyMethodOverriding
+    @abstractmethod
+    def run(self, headers: Headers, params: MultiDict[str, str]) -> WebserviceResponse:
+        """
+        The execution details for this endpoint.
+
+        :param headers: The headers from the request. Can be used like a dictionary.
+        :param params: The URL parameters from the request.
+        :return: A response object to send back to the requester.
+        """
+        pass
+
+
+class CommonsWebserviceBaseHandler(BaseAuthenticatorClass, ABC):
+    """
+    A base class for all commons webservice handlers.
+    """
+    logger: Logger
+
+    user: SapioUser | None
+
+    dr_man: DataRecordManager
+    rec_man: RecordModelManager
+    inst_man: RecordModelInstanceManager
+    rel_man: RecordModelRelationshipManager
+    an_man: RecordModelAncestorManager
+
+    dt_cache: DataTypeCacheManager
+    rec_handler: RecordHandler
+
+    def initialize(self, headers: Headers) -> None:
+        """
+        A function that can be optionally overridden by your classes to initialize additional instance variables,
+        or set up whatever else you wish to set up before the execute function is ran. Default behavior initializes a
+        SapioUser and various manager classes to make requests from.
+        """
+        self.user = None
+        self.user = self.authenticate_user(headers)
+
+        self.logger = self.user.logger
+
+        self.dr_man = DataRecordManager(self.user)
+        self.rec_man = RecordModelManager(self.user)
+        self.inst_man = self.rec_man.instance_manager
+        self.rel_man = self.rec_man.relationship_manager
+        self.an_man = RecordModelAncestorManager(self.rec_man)
+
+        self.dt_cache = DataTypeCacheManager(self.user)
+        self.rec_handler = RecordHandler(self.user)
+
+    def handle_webservice_exception(self, e: SapioWebserviceException) -> WebserviceResponse:
+        """
+        Handle a generic exception which isn't one of the handled Sapio exceptions.
+
+        Default behavior returns a webservice result with the message and error code of the webservice exception.
+        Additionally, the stack trace of the exception that was thrown is logged to the webhook server.
+
+        :param e: The exception that was raised.
+        :return: A webservice result to return to the requester.
+        """
+        result: WebserviceResponse | None = self.handle_any_exception(e)
+        if result is not None:
+            return result
+        msg: str = traceback.format_exc()
+        self.log_error(msg)
+        return SapioWebserviceResult(e.msg, e.code, True)
+
+    def handle_unexpected_exception(self, e: Exception) -> WebserviceResponse:
+        """
+        Handle a generic exception which isn't one of the handled Sapio exceptions.
+
+        Default behavior returns a 500 code result with a generic error message informing the user to contact Sapio
+        support. Additionally, the stack trace of the exception that was thrown is logged to the webhook server.
+
+        :param e: The exception that was raised.
+        :return: A webservice result to return to the requester.
+        """
+        result: SapioWebserviceResult | None = self.handle_any_exception(e)
+        if result is not None:
+            return result
+        msg: str = traceback.format_exc()
+        self.log_error(msg)
+        return SapioWebserviceResult("Unexpected error occurred during webservice execution. "
+                                     "Please contact Sapio support.", 500, True)
+
+    # noinspection PyMethodMayBeStatic,PyUnusedLocal
+    def handle_any_exception(self, e: Exception) -> WebserviceResponse | None:
+        """
+        An exception handler which runs regardless of the type of exception that was raised. Can be used to "rollback"
+        the client if an error occurs. Default behavior does nothing and returns None.
+
+        :param e: The exception that was raised.
+        :return: An optional response to the caller. May return a custom message to the client that wouldn't have been
+            sent by one of the normal exception handlers, or may return None if no result needs returned. If a result is
+            returned, then the default behavior of other exception handlers is skipped.
+        """
+        return None
+
+    def log_info(self, msg: str) -> None:
+        """
+        Write an info message to the webhook server log. Log destination is stdout.
+        """
+        self.logger.info(msg)
+
+    def log_error(self, msg: str) -> None:
+        """
+        Write an error message to the webhook server log. Log destination is stderr.
+        """
+        self.logger.error(msg)
+
+
+class CommonsWebservicePostHandler(AbstractWebservicePostHandler, CommonsWebserviceBaseHandler):
+    """
+    A subclass of AbstractWebservicePostHandler that provides additional quality of life features, including
+    authentication of a SapioUser from the request headers, initialization of various commonly used managers, and more.
+    """
+    def run(self, payload: Any, headers: Headers, params: MultiDict[str, str]) -> WebserviceResponse:
+        try:
+            self.initialize(headers)
+            result = self.execute(self.user, payload, headers, params)
+            if result is None:
+                raise SapioException("Your execute function returned a None result! Don't forget your return statement!")
+            return result
+        except SapioWebserviceException as e:
+            return self.handle_webservice_exception(e)
+        except Exception as e:
+            return self.handle_unexpected_exception(e)
+
+    @abstractmethod
+    def execute(self, user: SapioUser, payload: Any, headers: Headers, params: MultiDict[str, str]) \
+            -> SapioWebserviceResult:
+        """
+        The execution details for this endpoint.
+
+        :param user: The SapioUser object authenticated from the request headers.
+        :param payload: The JSON payload from the request. Usually a dictionary of strings to Any.
+        :param headers: The headers from the request. Can be used like a dictionary.
+        :param params: The URL parameters from the request.
+        :return: A response object to send back to the requester.
+        """
+        pass
+
+
+class CommonsWebserviceGetHandler(AbstractWebserviceGetHandler, CommonsWebserviceBaseHandler):
+    """
+    A subclass of AbstractWebserviceGetHandler that provides additional quality of life features, including
+    authentication of a SapioUser from the request headers, initialization of various commonly used managers, and more.
+    """
+    def run(self, headers: Headers, params: MultiDict[str, str]) -> WebserviceResponse:
+        try:
+            self.initialize(headers)
+            result = self.execute(self.user, headers, params)
+            if result is None:
+                raise SapioException("Your execute function returned a None result! Don't forget your return statement!")
+            return result
+        except SapioWebserviceException as e:
+            return self.handle_webservice_exception(e)
+        except Exception as e:
+            return self.handle_unexpected_exception(e)
+
+    @abstractmethod
+    def execute(self, user: SapioUser, headers: Headers, params: MultiDict[str, str]) \
+            -> SapioWebserviceResult:
+        """
+        The execution details for this endpoint.
+
+        :param user: The SapioUser object authenticated from the request headers.
+        :param headers: The headers from the request. Can be used like a dictionary.
+        :param params: The URL parameters from the request.
+        :return: A response object to send back to the requester.
+        """
+        pass

{sapiopycommons-2024.11.21a370.dist-info → sapiopycommons-2024.11.22a371.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2024.11.21a370
+Version: 2024.11.22a371
 Summary: Official Sapio Python API Utilities Package
 Project-URL: Homepage, https://github.com/sapiosciences
 Author-email: Jonathan Steck <jsteck@sapiosciences.com>, Yechen Qiao <yqiao@sapiosciences.com>

{sapiopycommons-2024.11.21a370.dist-info → sapiopycommons-2024.11.22a371.dist-info}/RECORD

@@ -1,7 +1,7 @@
 sapiopycommons/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/callbacks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/callbacks/callback_util.py,sha256=nb6cXK8yFq96gtG0Z2NiK-qdNaRh88bavUH-ZoBjh18,67953
-sapiopycommons/callbacks/field_builder.py,sha256=8n0jcbMgtMUHjie4C1-IkpAuHz4zBxbZtWpr4y0kABU,36868
+sapiopycommons/callbacks/field_builder.py,sha256=p2XacN99MuKk3ite8GAqstUMpixqugul2CsC4gB83-o,38620
 sapiopycommons/chem/IndigoMolecules.py,sha256=3f-aig3AJkKJhRmhlQ0cI-5G8oeaQk_3foJTDZCvoko,2040
 sapiopycommons/chem/Molecules.py,sha256=SQKnqdZnhYj_6HGtEZmE_1DormonRR1-nBAQ__z4gms,11485
 sapiopycommons/chem/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -31,7 +31,7 @@ sapiopycommons/general/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 sapiopycommons/general/accession_service.py,sha256=HYgyOsH_UaoRnoury-c2yTW8SeG4OtjLemdpCzoV4R8,13484
 sapiopycommons/general/aliases.py,sha256=tdDBNWSGx6s39eHJ3n2kscc4xxW3ZYaUfDftct6FmJE,12910
 sapiopycommons/general/audit_log.py,sha256=KQI0AGgN9WLwKqnHE4Tm0xeBCfpVBf8rIQ2HFmnyFGI,8956
-sapiopycommons/general/custom_report_util.py,sha256=BGu9Ki0wn3m4Nk-LKM6inDSfe8ULUSG9d-HJJNOTtGc,15653
+sapiopycommons/general/custom_report_util.py,sha256=6ZIg_Jl02TYUygfc5xqBoI1srPsSxLyxaJ9jwTolGcM,16671
 sapiopycommons/general/exceptions.py,sha256=GY7fe0qOgoy4kQVn_Pn3tdzHsJZyNIpa6VCChg6tzuM,1813
 sapiopycommons/general/popup_util.py,sha256=L-4qpTemSZdlD6_6oEsDYIzLOCiZgDK6wC6DqUwzOYA,31925
 sapiopycommons/general/sapio_links.py,sha256=o9Z-8y2rz6AI0Cy6tq58ElPge9RBnisGc9NyccbaJxs,2610
@@ -43,17 +43,17 @@ sapiopycommons/processtracking/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5
 sapiopycommons/processtracking/custom_workflow_handler.py,sha256=0Si5RQ1YFmqmcZWV8jNDKTffix2iZnQJ6b97fn31pbc,23859
 sapiopycommons/processtracking/endpoints.py,sha256=w5bziI2xC7450M95rCF8JpRwkoni1kEDibyAux9B12Q,10848
 sapiopycommons/recordmodel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/recordmodel/record_handler.py,sha256=Uxjrq6f_cWFbqi7KRLySdOvmQGtbIBrCNyStRewqzx8,64751
+sapiopycommons/recordmodel/record_handler.py,sha256=5kCO5zsSg0kp3uYpgw1vf0WLHw30pMNC_6Bn3G7iQkI,64796
 sapiopycommons/rules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/rules/eln_rule_handler.py,sha256=JYzDA_14D2nLnlqwbpIxVOrfKWzbOS27AYf4TQfGr4Q,10469
 sapiopycommons/rules/on_save_rule_handler.py,sha256=Rkqvph20RbNq6m-RF4fbvCP-YfD2CZYBM2iTr3nl0eY,10236
 sapiopycommons/sftpconnect/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sapiopycommons/sftpconnect/sftp_builder.py,sha256=eKYMiyBc10DNTfbeidQUcfZgFTwhu5ZU-nNJMCK_eos,3014
+sapiopycommons/sftpconnect/sftp_builder.py,sha256=lFK3FeXk-sFLefW0hqY8WGUQDeYiGaT6yDACzT_zFgQ,3015
 sapiopycommons/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sapiopycommons/webhook/webhook_context.py,sha256=D793uLsb1691SalaPnBUk3rOSxn_hYLhdvkaIxjNXss,1909
-sapiopycommons/webhook/webhook_handlers.py,sha256=JTquLBln49L1pJ9txJ4oc4Hpzy9kYtMKs0m4SLaFx78,18363
-sapiopycommons/webhook/webservice_handlers.py,sha256=1J56zFI0pWl5MHoNTznvcZumITXgAHJMluj8-2BqYEw,3315
-sapiopycommons-2024.11.21a370.dist-info/METADATA,sha256=tzVeWwhjIQz9oWbFWvlcL1dYsD_Yl_1-DlHkhS9Wa4w,3144
-sapiopycommons-2024.11.21a370.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-sapiopycommons-2024.11.21a370.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
-sapiopycommons-2024.11.21a370.dist-info/RECORD,,
+sapiopycommons/webhook/webhook_handlers.py,sha256=MdsVK4bHffkMNmNWl0_qvu-5Lz8-qGu4Ryi7lZO1BZs,18586
+sapiopycommons/webhook/webservice_handlers.py,sha256=AFM2Va9Fpb2BvlFycIUUOdghtGiEv1Ab5jf44yjHSgU,17218
+sapiopycommons-2024.11.22a371.dist-info/METADATA,sha256=IZ6j1XeF-tLgm-0ds4XSLeNoPzi-_F1wTLEOabg6NmM,3144
+sapiopycommons-2024.11.22a371.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+sapiopycommons-2024.11.22a371.dist-info/licenses/LICENSE,sha256=HyVuytGSiAUQ6ErWBHTqt1iSGHhLmlC8fO7jTCuR8dU,16725
+sapiopycommons-2024.11.22a371.dist-info/RECORD,,