sapiopycommons 2024.8.20a306__tar.gz → 2024.8.26a309__tar.gz

{sapiopycommons-2024.8.20a306 → sapiopycommons-2024.8.26a309}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sapiopycommons
-Version: 2024.8.20a306
+Version: 2024.8.26a309
 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.8.20a306 → sapiopycommons-2024.8.26a309}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sapiopycommons"
-version='2024.08.20a306'
+version='2024.08.26a309'
 authors = [
     { name="Jonathan Steck", email="jsteck@sapiosciences.com" },
     { name="Yechen Qiao", email="yqiao@sapiosciences.com" },

{sapiopycommons-2024.8.20a306 → sapiopycommons-2024.8.26a309}/src/sapiopycommons/callbacks/callback_util.py

@@ -900,7 +900,7 @@ class CallbackUtil:
         return response
 
     def request_file(self, title: str, exts: list[str] | None = None,
-                     show_image_editor: bool = False, show_camera_button: bool = False) -> (str, bytes):
+                     show_image_editor: bool = False, show_camera_button: bool = False) -> tuple[str, bytes]:
         """
         Request a single file from the user.
 
@@ -933,7 +933,7 @@ class CallbackUtil:
         return file_path, sink.data
 
     def request_files(self, title: str, exts: list[str] | None = None,
-                      show_image_editor: bool = False, show_camera_button: bool = False):
+                      show_image_editor: bool = False, show_camera_button: bool = False) -> dict[str, bytes]:
         """
         Request multiple files from the user.
 
@@ -964,7 +964,7 @@ class CallbackUtil:
         return ret_dict
 
     @staticmethod
-    def __verify_file(file_path: str, file_bytes: bytes, allowed_extensions: list[str]):
+    def __verify_file(file_path: str, file_bytes: bytes, allowed_extensions: list[str]) -> None:
         """
         Verify that the provided file was read (i.e. the file path and file bytes aren't None or empty) and that it
         has the correct file extension. Raises a user error exception if something about the file is incorrect.

{sapiopycommons-2024.8.20a306 → sapiopycommons-2024.8.26a309}/src/sapiopycommons/eln/experiment_handler.py

@@ -330,11 +330,7 @@ class ExperimentHandler:
         :return: The data record for this experiment. None if it has no record.
         """
         if not hasattr(self, "_ExperimentHandler__exp_record"):
-            drm = DataMgmtServer.get_data_record_manager(self.user)
-            dt = self.__eln_exp.experiment_data_type_name
-            results = drm.query_data_records_by_id(dt, [self.__eln_exp.experiment_record_id]).result_list
-            # PR-46504: Set the exp_record to None if there are no results.
-            self.__exp_record = results[0] if results else None
+            self.__exp_record = self.__protocol.get_record()
         if self.__exp_record is None and exception_on_none:
             raise SapioException(f"Experiment record not found for experiment with ID {self.__exp_id}.")
         return self.__exp_record

{sapiopycommons-2024.8.20a306 → sapiopycommons-2024.8.26a309}/src/sapiopycommons/files/file_bridge_handler.py

@@ -328,7 +328,7 @@ class Directory(FileBridgeObject):
         return {x: y for x, y in self.contents.items() if not y.is_file()}
 
 
-def split_path(file_path: str) -> (str, str):
+def split_path(file_path: str) -> tuple[str, str]:
     """
     :param file_path: A file path where directories are separated the "/" characters.
     :return: A tuple of two strings that splits the path on its last slash. The first string is the name of the

{sapiopycommons-2024.8.20a306 → sapiopycommons-2024.8.26a309}/src/sapiopycommons/recordmodel/record_handler.py

@@ -92,7 +92,7 @@ class RecordHandler:
         return self.inst_man.add_existing_records_of_type(list(records), wrapper_type)
 
     def query_models(self, wrapper_type: type[WrappedType], field: FieldIdentifier, value_list: Iterable[FieldValue],
-                     page_limit: int | None = None) -> list[WrappedType]:
+                     page_limit: int | None = None, page_size: int | None = None) -> list[WrappedType]:
         """
         Shorthand for using the data record manager to query for a list of data records by field value
         and then converting the results into a list of record models.
@@ -100,14 +100,20 @@ class RecordHandler:
         :param wrapper_type: The record model wrapper to use.
         :param field: The field to query on.
         :param value_list: The values of the field to query on.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
+            only functions if you set a page size or the platform enforces a page size.
+        :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
         :return: The record models for the queried records.
         """
-        return self.query_models_with_criteria(wrapper_type, field, value_list, None, page_limit)[0]
+        criteria: DataRecordPojoPageCriteria | None = None
+        if page_size is not None:
+            criteria = DataRecordPojoPageCriteria(page_size=page_size)
+        return self.query_models_with_criteria(wrapper_type, field, value_list, criteria, page_limit)[0]
 
     def query_and_map_models(self, wrapper_type: type[WrappedType], field: FieldIdentifier,
                              value_list: Iterable[FieldValue], page_limit: int | None = None,
-                             *, mapping_field: FieldIdentifier | None = None) -> dict[FieldValue, list[WrappedType]]:
+                             page_size: int | None = None, *, mapping_field: FieldIdentifier | None = None) \
+            -> dict[FieldValue, list[WrappedType]]:
         """
         Shorthand for using query_models to search for records given values on a specific field and then using
         map_by_field to turn the returned list into a dictionary mapping field values to records.
@@ -115,17 +121,20 @@ class RecordHandler:
         :param wrapper_type: The record model wrapper to use.
         :param field: The field to query and map on.
         :param value_list: The values of the field to query on.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
+            only functions if you set a page size or the platform enforces a page size.
+        :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
         :param mapping_field: If provided, use this field to map against instead of the field that was queried on.
         :return: The record models for the queried records mapped by field values to the records with that value.
         """
         if mapping_field is None:
             mapping_field = field
-        return self.map_by_field(self.query_models(wrapper_type, field, value_list, page_limit), mapping_field)
+        return self.map_by_field(self.query_models(wrapper_type, field, value_list, page_limit, page_size),
+                                 mapping_field)
 
     def query_and_unique_map_models(self, wrapper_type: type[WrappedType], field: FieldIdentifier,
                                     value_list: Iterable[FieldValue], page_limit: int | None = None,
-                                    *, mapping_field: FieldIdentifier | None = None) \
+                                    page_size: int | None = None, *, mapping_field: FieldIdentifier | None = None) \
             -> dict[FieldValue, WrappedType]:
         """
         Shorthand for using query_models to search for records given values on a specific field and then using
@@ -135,13 +144,16 @@ class RecordHandler:
         :param wrapper_type: The record model wrapper to use.
         :param field: The field to query and map on.
         :param value_list: The values of the field to query on.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
+            only functions if you set a page size or the platform enforces a page size.
+        :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
         :param mapping_field: If provided, use this field to map against instead of the field that was queried on.
         :return: The record models for the queried records mapped by field values to the record with that value.
         """
         if mapping_field is None:
             mapping_field = field
-        return self.map_by_unique_field(self.query_models(wrapper_type, field, value_list, page_limit), mapping_field)
+        return self.map_by_unique_field(self.query_models(wrapper_type, field, value_list, page_limit, page_size),
+                                        mapping_field)
 
     def query_models_with_criteria(self, wrapper_type: type[WrappedType], field: FieldIdentifier,
                                    value_list: Iterable[FieldValue],
@@ -157,7 +169,8 @@ class RecordHandler:
         :param value_list: The values of the field to query on.
         :param paging_criteria: The paging criteria to start the query with.
         :param page_limit: The maximum number of pages to query from the starting criteria. If None, exhausts all
-            possible pages.
+            possible pages. This parameter only functions if you set a page size in the paging criteria or the platform
+            enforces a page size.
         :return: The record models for the queried records and the final paging criteria.
         """
         dt: str = wrapper_type.get_wrapper_data_type_name()
@@ -167,17 +180,22 @@ class RecordHandler:
         return self.wrap_models(pager.get_all_at_once(), wrapper_type), pager.next_page_criteria
 
     def query_models_by_id(self, wrapper_type: type[WrappedType], ids: Iterable[int],
-                           page_limit: int | None = None) -> list[WrappedType]:
+                           page_limit: int | None = None, page_size: int | None = None) -> list[WrappedType]:
         """
         Shorthand for using the data record manager to query for a list of data records by record ID
         and then converting the results into a list of record models.
 
         :param wrapper_type: The record model wrapper to use.
         :param ids: The list of record IDs to query.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
+            only functions if you set a page size or the platform enforces a page size.
+        :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
         :return: The record models for the queried records.
         """
-        return self.query_models_by_id_with_criteria(wrapper_type, ids, None, page_limit)[0]
+        criteria: DataRecordPojoPageCriteria | None = None
+        if page_size is not None:
+            criteria = DataRecordPojoPageCriteria(page_size=page_size)
+        return self.query_models_by_id_with_criteria(wrapper_type, ids, criteria, page_limit)[0]
 
     def query_models_by_id_with_criteria(self, wrapper_type: type[WrappedType], ids: Iterable[int],
                                          paging_criteria: DataRecordPojoPageCriteria | None = None,
@@ -191,7 +209,8 @@ class RecordHandler:
         :param ids: The list of record IDs to query.
         :param paging_criteria: The paging criteria to start the query with.
         :param page_limit: The maximum number of pages to query from the starting criteria. If None, exhausts all
-            possible pages.
+            possible pages. This parameter only functions if you set a page size in the paging criteria or the platform
+            enforces a page size.
         :return: The record models for the queried records and the final paging criteria.
         """
         dt: str = wrapper_type.get_wrapper_data_type_name()
@@ -200,28 +219,37 @@ class RecordHandler:
         return self.wrap_models(pager.get_all_at_once(), wrapper_type), pager.next_page_criteria
 
     def query_models_by_id_and_map(self, wrapper_type: type[WrappedType], ids: Iterable[int],
-                                   page_limit: int | None = None) -> dict[int, WrappedType]:
+                                   page_limit: int | None = None, page_size: int | None = None) \
+            -> dict[int, WrappedType]:
         """
         Shorthand for using the data record manager to query for a list of data records by record ID
         and then converting the results into a dictionary of record ID to the record model for that ID.
 
         :param wrapper_type: The record model wrapper to use.
         :param ids: The list of record IDs to query.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
+            only functions if you set a page size or the platform enforces a page size.
+        :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
         :return: The record models for the queried records mapped in a dictionary by their record ID.
         """
-        return {x.record_id: x for x in self.query_models_by_id(wrapper_type, ids, page_limit)}
+        return {x.record_id: x for x in self.query_models_by_id(wrapper_type, ids, page_limit, page_size)}
 
-    def query_all_models(self, wrapper_type: type[WrappedType], page_limit: int | None = None) -> list[WrappedType]:
+    def query_all_models(self, wrapper_type: type[WrappedType], page_limit: int | None = None,
+                         page_size: int | None = None) -> list[WrappedType]:
         """
         Shorthand for using the data record manager to query for all data records of a given type
         and then converting the results into a list of record models.
 
         :param wrapper_type: The record model wrapper to use.
-        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages.
+        :param page_limit: The maximum number of pages to query. If None, exhausts all possible pages. This parameter
+            only functions if you set a page size or the platform enforces a page size.
+        :param page_size: The size of the pages to query. If None, the page size may be limited by the platform.
         :return: The record models for the queried records.
         """
-        return self.query_all_models_with_criteria(wrapper_type, None, page_limit)[0]
+        criteria: DataRecordPojoPageCriteria | None = None
+        if page_size is not None:
+            criteria = DataRecordPojoPageCriteria(page_size=page_size)
+        return self.query_all_models_with_criteria(wrapper_type, criteria, page_limit)[0]
 
     def query_all_models_with_criteria(self, wrapper_type: type[WrappedType],
                                        paging_criteria: DataRecordPojoPageCriteria | None = None,
@@ -234,7 +262,8 @@ class RecordHandler:
         :param wrapper_type: The record model wrapper to use.
         :param paging_criteria: The paging criteria to start the query with.
         :param page_limit: The maximum number of pages to query from the starting criteria. If None, exhausts all
-            possible pages.
+            possible pages. This parameter only functions if you set a page size in the paging criteria or the platform
+            enforces a page size.
         :return: The record models for the queried records and the final paging criteria.
         """
         dt: str = wrapper_type.get_wrapper_data_type_name()