sapiopycommons 2024.11.19a369__tar.gz → 2024.11.22a371__tar.gz

{sapiopycommons-2024.11.19a369 → sapiopycommons-2024.11.22a371}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2024.11.19a369
+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.19a369 → sapiopycommons-2024.11.22a371}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sapiopycommons"
-version='2024.11.19a369'
+version='2024.11.22a371'
 authors = [
     { name="Jonathan Steck", email="jsteck@sapiosciences.com" },
     { name="Yechen Qiao", email="yqiao@sapiosciences.com" },

{sapiopycommons-2024.11.19a369 → sapiopycommons-2024.11.22a371}/src/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-2024.11.19a369 → sapiopycommons-2024.11.22a371}/src/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-2024.11.19a369 → sapiopycommons-2024.11.22a371}/src/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-2024.11.19a369 → sapiopycommons-2024.11.22a371}/src/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