qmenta-client 1.1.dev1289__py3-none-any.whl → 1.1.dev1295__py3-none-any.whl

qmenta/client/Project.py

@@ -22,7 +22,8 @@ logger_name = "qmenta.client"
 def show_progress(done, total, finish=False):
     bytes_in_mb = 1024 * 1024
     progress_message = "\r[{:.2f} %] Uploaded {:.2f} of {:.2f} Mb".format(
-        done / float(total) * 100, done / bytes_in_mb, total / bytes_in_mb)
+        done / float(total) * 100, done / bytes_in_mb, total / bytes_in_mb
+    )
     sys.stdout.write(progress_message)
     sys.stdout.flush()
     if not finish:
@@ -71,6 +72,7 @@ class QCStatus(Enum):
     Enum with the following options:
     FAIL, PASS
     """
+
     PASS = "pass"
     FAIL = "fail"
 
@@ -94,15 +96,11 @@ class Project:
         # project id (int)
         if isinstance(project_id, str):
             project_name = project_id
-            project_id = next(iter(filter(
-                lambda proj: proj["name"] == project_id, account.projects)
-            ))["id"]
+            project_id = next(iter(filter(lambda proj: proj["name"] == project_id, account.projects)))["id"]
         else:
             if isinstance(project_id, float):
                 project_id = int(project_id)
-            project_name = next(iter(filter(
-                lambda proj: proj["id"] == project_id, account.projects)
-            ))["name"]
+            project_name = next(iter(filter(lambda proj: proj["id"] == project_id, account.projects)))["name"]
 
         self._account = account
         self._project_id = project_id
@@ -133,11 +131,11 @@ class Project:
         """
         logger = logging.getLogger(logger_name)
         try:
-            platform.parse_response(platform.post(
-                self._account.auth,
-                "projectset_manager/activate_project",
-                data={"project_id": int(project_id)}
-            ))
+            platform.parse_response(
+                platform.post(
+                    self._account.auth, "projectset_manager/activate_project", data={"project_id": int(project_id)}
+                )
+            )
         except errors.PlatformError:
             logger.error("Unable to activate the project.")
             return False
@@ -263,27 +261,29 @@ class Project:
 
         """
 
-        assert len(items) == 2, f"The number of elements in items " \
-                                f"'{len(items)}' should be equal to two."
-        assert all([isinstance(item, int) for item in items]), \
-            f"All items elements '{items}' should be integers."
+        assert len(items) == 2, f"The number of elements in items " f"'{len(items)}' should be equal to two."
+        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
 
-        assert all([key[:5] == "pars_" for key in search_criteria.keys()]), \
-            f"All keys of the search_criteria dictionary " \
-            f"'{search_criteria.keys()}' must start with 'pars_'."
+        assert all([key[:5] == "pars_" for key in search_criteria.keys()]), (
+            f"All keys of the search_criteria dictionary " f"'{search_criteria.keys()}' must start with 'pars_'."
+        )
 
         operator_list = ["eq", "ne", "gt", "gte", "lt", "lte"]
         for key, value in search_criteria.items():
             if value.split(";")[0] in ["integer", "decimal"]:
-                assert value.split(";")[1].split("|")[0] in operator_list, \
-                    f"Search criteria of type '{value.split(';')[0]}' must " \
+                assert value.split(";")[1].split("|")[0] in operator_list, (
+                    f"Search criteria of type '{value.split(';')[0]}' must "
                     f"include an operator ({', '.join(operator_list)})."
+                )
 
-        content = platform.parse_response(platform.post(
-            self._account.auth, "patient_manager/get_patient_list",
-            data=search_criteria,
-            headers={"X-Range": f"items={items[0]}-{items[1]}"}
-        ))
+        content = platform.parse_response(
+            platform.post(
+                self._account.auth,
+                "patient_manager/get_patient_list",
+                data=search_criteria,
+                headers={"X-Range": f"items={items[0]}-{items[1]}"},
+            )
+        )
         return content
 
     @property
@@ -339,16 +339,13 @@ class Project:
         """
         logger = logging.getLogger(logger_name)
         try:
-            data = platform.parse_response(platform.post(
-                self._account.auth, "patient_manager/module_config"
-            ))
+            data = platform.parse_response(platform.post(self._account.auth, "patient_manager/module_config"))
         except errors.PlatformError:
             logger.error("Could not retrieve metadata parameters.")
             return None
         return data["fields"]
 
-    def add_metadata_parameter(self, title, param_id=None,
-                               param_type="string", visible=False):
+    def add_metadata_parameter(self, title, param_id=None, param_type="string", visible=False):
         """
         Add a metadata parameter to the project.
 
@@ -374,18 +371,13 @@ class Project:
 
         param_properties = [title, param_id, param_type, str(int(visible))]
 
-        post_data = {"add": "|".join(param_properties),
-                     "edit": "",
-                     "delete": ""
-                     }
+        post_data = {"add": "|".join(param_properties), "edit": "", "delete": ""}
 
         logger = logging.getLogger(logger_name)
         try:
-            answer = platform.parse_response(platform.post(
-                self._account.auth,
-                "patient_manager/save_metadata_changes",
-                data=post_data
-            ))
+            answer = platform.parse_response(
+                platform.post(self._account.auth, "patient_manager/save_metadata_changes", data=post_data)
+            )
         except errors.PlatformError:
             answer = {}
 
@@ -402,20 +394,17 @@ class Project:
         elif isinstance(analysis_name_or_id, str):
             search_tag = "p_n"
         else:
-            raise Exception("The analysis identifier must be its name or an "
-                            "integer")
+            raise Exception("The analysis identifier must be its name or an " "integer")
 
         search_condition = {
             search_tag: analysis_name_or_id,
         }
-        response = platform.parse_response(platform.post(
-            self._account.auth, "analysis_manager/get_analysis_list",
-            data=search_condition
-        ))
+        response = platform.parse_response(
+            platform.post(self._account.auth, "analysis_manager/get_analysis_list", data=search_condition)
+        )
 
         if len(response) > 1:
-            raise Exception(f"multiple analyses with name "
-                            f"{analysis_name_or_id} found")
+            raise Exception(f"multiple analyses with name " f"{analysis_name_or_id} found")
         elif len(response) == 1:
             return response[0]
         else:
@@ -455,10 +444,8 @@ class Project:
         dict
             List of analysis, each a dictionary
         """
-        assert len(items) == 2, f"The number of elements in items " \
-            f"'{len(items)}' should be equal to two."
-        assert all([isinstance(item, int) for item in items]), \
-            f"All items elements '{items}' should be integers."
+        assert len(items) == 2, f"The number of elements in items " f"'{len(items)}' should be equal to two."
+        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
         search_keys = {
             "p_n": str,
             "type": str,
@@ -474,26 +461,18 @@ class Project:
         }
         for key in search_condition.keys():
             if key not in search_keys.keys():
-                raise Exception(
-                    (
-                        f"This key '{key}' is not accepted by this"
-                        "search condition"
-                    )
-                )
+                raise Exception((f"This key '{key}' is not accepted by this" "search condition"))
             if not isinstance(search_condition[key], search_keys[key]):
-                raise Exception(
-                    (
-                        f"The key {key} in the search condition"
-                        f"is not type {search_keys[key]}"
-                    )
-                )
+                raise Exception((f"The key {key} in the search condition" f"is not type {search_keys[key]}"))
         req_headers = {"X-Range": f"items={items[0]}-{items[1] - 1}"}
-        return platform.parse_response(platform.post(
-            auth=self._account.auth,
-            endpoint="analysis_manager/get_analysis_list",
-            headers=req_headers,
-            data=search_condition
-        ))
+        return platform.parse_response(
+            platform.post(
+                auth=self._account.auth,
+                endpoint="analysis_manager/get_analysis_list",
+                headers=req_headers,
+                data=search_condition,
+            )
+        )
 
     def get_subject_container_id(self, subject_name, ssid):
         """
@@ -513,17 +492,11 @@ class Project:
             the subject is not found.
         """
 
-        search_criteria = {
-            "s_n": subject_name,
-            "ssid": ssid
-        }
-        response = self.list_input_containers(
-            search_criteria=search_criteria
-        )
+        search_criteria = {"s_n": subject_name, "ssid": ssid}
+        response = self.list_input_containers(search_criteria=search_criteria)
 
         for subject in response:
-            if subject["patient_secret_name"] == subject_name and \
-                    subject["ssid"] == ssid:
+            if subject["patient_secret_name"] == subject_name and subject["ssid"] == ssid:
                 return subject["container_id"]
         return False
 
@@ -561,16 +534,17 @@ class Project:
             {"container_name", "container_id", "patient_secret_name", "ssid"}
         """
 
-        assert len(items) == 2, f"The number of elements in items " \
-                                f"'{len(items)}' should be equal to two."
-        assert all([isinstance(item, int) for item in items]), \
-            f"All items elements '{items}' should be integers."
+        assert len(items) == 2, f"The number of elements in items " f"'{len(items)}' should be equal to two."
+        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
 
-        response = platform.parse_response(platform.post(
-            self._account.auth, "file_manager/get_container_list",
-            data=search_criteria,
-            headers={"X-Range": f"items={items[0]}-{items[1]}"}
-        ))
+        response = platform.parse_response(
+            platform.post(
+                self._account.auth,
+                "file_manager/get_container_list",
+                data=search_criteria,
+                headers={"X-Range": f"items={items[0]}-{items[1]}"},
+            )
+        )
         containers = [
             {
                 "patient_secret_name": container_item["patient_secret_name"],
@@ -598,8 +572,7 @@ class Project:
             {"name": "container-name", "id": "container_id"}
         """
         analysis = self.list_analysis(limit)
-        return [{"name": a["name"],
-                 "id": a["out_container_id"]} for a in analysis]
+        return [{"name": a["name"], "id": a["out_container_id"]} for a in analysis]
 
     def list_container_files(self, container_id):
         """
@@ -616,10 +589,11 @@ class Project:
             List of file names (strings)
         """
         try:
-            content = platform.parse_response(platform.post(
-                self._account.auth, "file_manager/get_container_files",
-                data={"container_id": container_id}
-            ))
+            content = platform.parse_response(
+                platform.post(
+                    self._account.auth, "file_manager/get_container_files", data={"container_id": container_id}
+                )
+            )
         except errors.PlatformError as e:
             logging.getLogger(logger_name).error(e)
             return False
@@ -646,10 +620,11 @@ class Project:
         """
 
         try:
-            data = platform.parse_response(platform.post(
-                self._account.auth, "file_manager/get_container_files",
-                data={"container_id": container_id}
-            ))
+            data = platform.parse_response(
+                platform.post(
+                    self._account.auth, "file_manager/get_container_files", data={"container_id": container_id}
+                )
+            )
         except errors.PlatformError as e:
             logging.getLogger(logger_name).error(e)
             return False
@@ -698,18 +673,15 @@ class Project:
         """
 
         tags_str = "" if tags is None else ";".join(tags)
-        platform.parse_response(platform.post(
-            self._account.auth, "file_manager/edit_file",
-            data={
-                "container_id": container_id,
-                "filename": filename,
-                "tags": tags_str,
-                "modality": modality
-            }
-        ))
+        platform.parse_response(
+            platform.post(
+                self._account.auth,
+                "file_manager/edit_file",
+                data={"container_id": container_id, "filename": filename, "tags": tags_str, "modality": modality},
+            )
+        )
 
-    def download_file(self, container_id, file_name, local_filename=False,
-                      overwrite=False):
+    def download_file(self, container_id, file_name, local_filename=False, overwrite=False):
         """
         Download a single file from a  specific container.
 
@@ -726,8 +698,7 @@ class Project:
         """
         logger = logging.getLogger(logger_name)
         if file_name not in self.list_container_files(container_id):
-            msg = (f"File \"{file_name}\" does not exist in container "
-                   f"{container_id}")
+            msg = f'File "{file_name}" does not exist in container ' f"{container_id}"
             logger.error(msg)
             return False
 
@@ -740,22 +711,18 @@ class Project:
 
         params = {"container_id": container_id, "files": file_name}
 
-        with platform.post(self._account.auth, "file_manager/download_file",
-                           data=params, stream=True) as response, \
-                open(local_filename, "wb") as f:
+        with platform.post(
+            self._account.auth, "file_manager/download_file", data=params, stream=True
+        ) as response, open(local_filename, "wb") as f:
 
-            for chunk in response.iter_content(chunk_size=2 ** 9 * 1024):
+            for chunk in response.iter_content(chunk_size=2**9 * 1024):
                 f.write(chunk)
             f.flush()
 
-        logger.info(
-            f"File {file_name} from container {container_id} saved to"
-            f" {local_filename}"
-        )
+        logger.info(f"File {file_name} from container {container_id} saved to" f" {local_filename}")
         return True
 
-    def download_files(self, container_id, filenames, zip_name="files.zip",
-                       overwrite=False):
+    def download_files(self, container_id, filenames, zip_name="files.zip", overwrite=False):
         """
         Download a set of files from a given container.
 
@@ -771,34 +738,30 @@ class Project:
             Name of the zip where the downloaded files are stored.
         """
         logger = logging.getLogger(logger_name)
-        files_not_in_container = list(
-            filter(lambda f: f not in self.list_container_files(container_id),
-                   filenames)
-        )
+        files_not_in_container = list(filter(lambda f: f not in self.list_container_files(container_id), filenames))
 
         if files_not_in_container:
-            msg = (f"The following files are missing in container "
-                   f"{container_id}: {', '.join(files_not_in_container)}")
+            msg = (
+                f"The following files are missing in container " f"{container_id}: {', '.join(files_not_in_container)}"
+            )
             logger.error(msg)
             return False
 
         if os.path.exists(zip_name) and not overwrite:
-            msg = f"File \"{zip_name}\" already exists"
+            msg = f'File "{zip_name}" already exists'
             logger.error(msg)
             return False
 
         params = {"container_id": container_id, "files": ";".join(filenames)}
-        with platform.post(self._account.auth,
-                           "file_manager/download_file",
-                           data=params, stream=True) as response, \
-                open(zip_name, "wb") as f:
+        with platform.post(
+            self._account.auth, "file_manager/download_file", data=params, stream=True
+        ) as response, open(zip_name, "wb") as f:
 
-            for chunk in response.iter_content(chunk_size=2 ** 9 * 1024):
+            for chunk in response.iter_content(chunk_size=2**9 * 1024):
                 f.write(chunk)
             f.flush()
 
-        logger.info("Files from container {} saved to {}".format(
-            container_id, zip_name))
+        logger.info("Files from container {} saved to {}".format(container_id, zip_name))
         return True
 
     def get_subject_id(self, subject_name, ssid):
@@ -821,8 +784,7 @@ class Project:
         """
 
         for user in self.get_subjects_metadata():
-            if user["patient_secret_name"] == str(subject_name) and \
-                    user["ssid"] == str(ssid):
+            if user["patient_secret_name"] == str(subject_name) and user["ssid"] == str(ssid):
                 return int(user["_id"])
         return False
 
@@ -842,27 +804,23 @@ class Project:
         """
         logger = logging.getLogger(logger_name)
         if self.check_subject_name(subject.name):
-            logger.error(f"Subject with name {subject.name} already exists in "
-                         f"project!")
+            logger.error(f"Subject with name {subject.name} already exists in " f"project!")
             return False
 
         try:
-            platform.parse_response(platform.post(
-                self._account.auth, "patient_manager/upsert_patient",
-                data={"secret_name": subject.name}
-            ))
+            platform.parse_response(
+                platform.post(self._account.auth, "patient_manager/upsert_patient", data={"secret_name": subject.name})
+            )
         except errors.PlatformError:
             logger.error(f"Subject {subject.name} could not be created.")
             return False
 
         subject.subject_id = self.get_subject_id(subject.name)
         subject.project = self
-        logger.info(
-            "Subject {0} was successfully created".format(subject.name))
+        logger.info("Subject {0} was successfully created".format(subject.name))
         return True
 
-    def change_subject_metadata(self, patient_id, subject_name, ssid, tags,
-                                age_at_scan, metadata):
+    def change_subject_metadata(self, patient_id, subject_name, ssid, tags, age_at_scan, metadata):
         """
         Change the Subject ID, Session ID, Tags, Age at Scan and Metadata of
         the session with Patient ID
@@ -897,42 +855,36 @@ class Project:
         try:
             patient_id = str(int(patient_id))
         except ValueError:
-            raise ValueError(f"'patient_id': '{patient_id}' not valid. "
-                             f"Must be convertible to int.")
+            raise ValueError(f"'patient_id': '{patient_id}' not valid. " f"Must be convertible to int.")
 
-        assert isinstance(tags, list) and \
-               all(isinstance(item, str) for item in tags), \
-               f"tags: '{tags}' should be a list of strings."
+        assert isinstance(tags, list) and all(
+            isinstance(item, str) for item in tags
+        ), f"tags: '{tags}' should be a list of strings."
         tags = [tag.lower() for tag in tags]
 
-        assert subject_name is not None and subject_name != "", \
-            "subject_name must be a non empty string."
-        assert ssid is not None and ssid != "", \
-            "ssid must be a non empty string."
+        assert subject_name is not None and subject_name != "", "subject_name must be a non empty string."
+        assert ssid is not None and ssid != "", "ssid must be a non empty string."
 
         try:
             age_at_scan = str(int(age_at_scan)) if age_at_scan else None
         except ValueError:
-            raise ValueError(f"age_at_scan: '{age_at_scan}' not valid. "
-                             f"Must be an integer.")
+            raise ValueError(f"age_at_scan: '{age_at_scan}' not valid. " f"Must be an integer.")
 
-        assert isinstance(metadata, dict), \
-            f"metadata: '{metadata}' should be a dictionary."
+        assert isinstance(metadata, dict), f"metadata: '{metadata}' should be a dictionary."
 
-        assert all("md_" == key[:3] for key in metadata.keys()) or \
-               all("md_" != key[:3] for key in metadata.keys()), \
-               f"metadata: '{metadata}' must be a dictionary whose keys " \
-               f"are either all starting with 'md_' or none."
+        assert all("md_" == key[:3] for key in metadata.keys()) or all("md_" != key[:3] for key in metadata.keys()), (
+            f"metadata: '{metadata}' must be a dictionary whose keys " f"are either all starting with 'md_' or none."
+        )
 
         metadata_keys = self.metadata_parameters.keys()
-        assert \
-            all([key[3:] in metadata_keys
-                 if "md_" == key[:3] else key in metadata_keys
-                 for key in metadata.keys()]), \
-            f"Some metadata keys provided ({', '.join(metadata.keys())}) " \
-            f"are not available in the project. They can be added via the " \
-            f"Metadata Manager via the QMENTA Platform graphical user " \
+        assert all(
+            [key[3:] in metadata_keys if "md_" == key[:3] else key in metadata_keys for key in metadata.keys()]
+        ), (
+            f"Some metadata keys provided ({', '.join(metadata.keys())}) "
+            f"are not available in the project. They can be added via the "
+            f"Metadata Manager via the QMENTA Platform graphical user "
             f"interface (GUI)."
+        )
 
         post_data = {
             "patient_id": patient_id,
@@ -946,11 +898,7 @@ class Project:
             post_data[f"last_vals.{id}"] = value
 
         try:
-            platform.parse_response(platform.post(
-                self._account.auth,
-                "patient_manager/upsert_patient",
-                data=post_data
-            ))
+            platform.parse_response(platform.post(self._account.auth, "patient_manager/upsert_patient", data=post_data))
         except errors.PlatformError:
             logger.error(f"Patient ID '{patient_id}' could not be modified.")
             return False
@@ -979,45 +927,32 @@ class Project:
         all_sessions = self.get_subjects_metadata()
 
         session_to_del = [
-            s for s in all_sessions if
-            s["patient_secret_name"] == subject_name and
-            s["ssid"] == session_id
+            s for s in all_sessions if s["patient_secret_name"] == subject_name and s["ssid"] == session_id
         ]
 
         if not session_to_del:
-            logger.error(
-                f"Session {subject_name}/{session_id} could not be found "
-                f"in this project."
-            )
+            logger.error(f"Session {subject_name}/{session_id} could not be found " f"in this project.")
             return False
         elif len(session_to_del) > 1:
-            raise RuntimeError(
-                "Multiple sessions with same Subject ID and Session ID."
-                " Contact support."
-            )
+            raise RuntimeError("Multiple sessions with same Subject ID and Session ID." " Contact support.")
         else:
-            logger.info("{}/{} found (id {})".format(
-                subject_name, session_id, session_to_del[0]["_id"]
-            ))
+            logger.info("{}/{} found (id {})".format(subject_name, session_id, session_to_del[0]["_id"]))
 
         session = session_to_del[0]
 
         try:
-            platform.parse_response(platform.post(
-                self._account.auth, "patient_manager/delete_patient",
-                data={
-                    "patient_id": str(int(session["_id"])), "delete_files": 1
-                }
-            ))
+            platform.parse_response(
+                platform.post(
+                    self._account.auth,
+                    "patient_manager/delete_patient",
+                    data={"patient_id": str(int(session["_id"])), "delete_files": 1},
+                )
+            )
         except errors.PlatformError:
-            logger.error(f"Session \"{subject_name}/{session['ssid']}\" could"
-                         f" not be deleted.")
+            logger.error(f"Session \"{subject_name}/{session['ssid']}\" could" f" not be deleted.")
             return False
 
-        logger.info(
-            f"Session \"{subject_name}/{session['ssid']}\" successfully "
-            f"deleted."
-        )
+        logger.info(f"Session \"{subject_name}/{session['ssid']}\" successfully " f"deleted.")
         return True
 
     def delete_session_by_patientid(self, patient_id):
@@ -1038,12 +973,13 @@ class Project:
         logger = logging.getLogger(logger_name)
 
         try:
-            platform.parse_response(platform.post(
-                self._account.auth, "patient_manager/delete_patient",
-                data={
-                    "patient_id": str(int(patient_id)), "delete_files": 1
-                }
-            ))
+            platform.parse_response(
+                platform.post(
+                    self._account.auth,
+                    "patient_manager/delete_patient",
+                    data={"patient_id": str(int(patient_id)), "delete_files": 1},
+                )
+            )
         except errors.PlatformError:
             logger.error(f"Patient ID {patient_id} could not be deleted.")
             return False
@@ -1071,16 +1007,10 @@ class Project:
         # Always fetch the session IDs from the platform before deleting them
         all_sessions = self.get_subjects_metadata()
 
-        sessions_to_del = [
-            s for s in all_sessions if s["patient_secret_name"] == subject_name
-        ]
+        sessions_to_del = [s for s in all_sessions if s["patient_secret_name"] == subject_name]
 
         if not sessions_to_del:
-            logger.error(
-                "Subject {} cannot be found in this project.".format(
-                    subject_name
-                )
-            )
+            logger.error("Subject {} cannot be found in this project.".format(subject_name))
             return False
 
         for ssid in [s["ssid"] for s in sessions_to_del]:
@@ -1088,15 +1018,25 @@ class Project:
                 return False
         return True
 
-    def _upload_chunk(self, data, range_str, length, session_id,
-                      disposition,
-                      last_chunk,
-                      name="", date_of_scan="", description="",
-                      subject_name="", ssid="", filename="DATA.zip",
-                      input_data_type="mri_brain_data:1.0",
-                      result=False, add_to_container_id=0,
-                      split_data=False
-                      ):
+    def _upload_chunk(
+        self,
+        data,
+        range_str,
+        length,
+        session_id,
+        disposition,
+        last_chunk,
+        name="",
+        date_of_scan="",
+        description="",
+        subject_name="",
+        ssid="",
+        filename="DATA.zip",
+        input_data_type="mri_brain_data:1.0",
+        result=False,
+        add_to_container_id=0,
+        split_data=False,
+    ):
         """
         Upload a chunk of a file to the platform.
 
@@ -1123,10 +1063,11 @@ class Project:
         """
 
         request_headers = {
-            "Content-Type": "application/zip", "Content-Range":
-                range_str, "Session-ID": str(session_id),
+            "Content-Type": "application/zip",
+            "Content-Range": range_str,
+            "Session-ID": str(session_id),
             "Content-Length": str(length),
-            "Content-Disposition": disposition
+            "Content-Disposition": disposition,
         }
 
         if last_chunk:
@@ -1154,20 +1095,25 @@ class Project:
 
         response_time = 900.0 if last_chunk else 120.0
         response = platform.post(
-            auth=self._account.auth,
-            endpoint="upload",
-            data=data,
-            headers=request_headers,
-            timeout=response_time
+            auth=self._account.auth, endpoint="upload", data=data, headers=request_headers, timeout=response_time
         )
 
         return response
 
-    def upload_file(self, file_path, subject_name, ssid="", date_of_scan="",
-                    description="", result=False, name="",
-                    input_data_type="qmenta_mri_brain_data:1.0",
-                    add_to_container_id=0, chunk_size=2 ** 9,
-                    split_data=False):
+    def upload_file(
+        self,
+        file_path,
+        subject_name,
+        ssid="",
+        date_of_scan="",
+        description="",
+        result=False,
+        name="",
+        input_data_type="qmenta_mri_brain_data:1.0",
+        add_to_container_id=0,
+        chunk_size=2**9,
+        split_data=False,
+    ):
         """
         Upload a ZIP file to the platform.
 
@@ -1231,8 +1177,7 @@ class Project:
             last_chunk = False
 
             if ssid and split_data:
-                logger.warning("split-data argument will be ignored because" +
-                               " ssid has been specified")
+                logger.warning("split-data argument will be ignored because" + " ssid has been specified")
                 split_data = False
 
             while True:
@@ -1249,16 +1194,27 @@ class Project:
                     end_position = total_bytes - 1
                     bytes_to_send = total_bytes - uploaded_bytes
 
-                bytes_range = "bytes " + str(start_position) + "-" + \
-                              str(end_position) + "/" + str(total_bytes)
+                bytes_range = "bytes " + str(start_position) + "-" + str(end_position) + "/" + str(total_bytes)
 
                 dispstr = f"attachment; filename={filename}"
                 response = self._upload_chunk(
-                    data, bytes_range, bytes_to_send, session_id, dispstr,
+                    data,
+                    bytes_range,
+                    bytes_to_send,
+                    session_id,
+                    dispstr,
                     last_chunk,
-                    name, date_of_scan, description, subject_name, ssid,
-                    filename, input_data_type, result, add_to_container_id,
-                    split_data)
+                    name,
+                    date_of_scan,
+                    description,
+                    subject_name,
+                    ssid,
+                    filename,
+                    input_data_type,
+                    result,
+                    add_to_container_id,
+                    split_data,
+                )
 
                 if response is None:
                     retries_count += 1
@@ -1278,17 +1234,14 @@ class Project:
                     retries_count += 1
                     time.sleep(retries_count * 5)
                     if retries_count > self.max_retries:
-                        error_message = (
-                            "Error Code: 416; "
-                            "Requested Range Not Satisfiable (NGINX)")
+                        error_message = "Error Code: 416; " "Requested Range Not Satisfiable (NGINX)"
                         logger.error(error_message)
                         break
                 else:
                     retries_count += 1
                     time.sleep(retries_count * 5)
                     if retries_count > max_retries:
-                        error_message = ("Number of retries has been reached. "
-                                         "Upload process stops here !")
+                        error_message = "Number of retries has been reached. " "Upload process stops here !"
                         logger.error(error_message)
                         break
 
@@ -1342,9 +1295,7 @@ class Project:
         """
 
         if check_upload_file(file_path):
-            return self.upload_file(
-                file_path, subject_name,
-                input_data_type="parkinson_gametection")
+            return self.upload_file(file_path, subject_name, input_data_type="parkinson_gametection")
         return False
 
     def upload_result(self, file_path, subject_name):
@@ -1388,13 +1339,9 @@ class Project:
             p_id = int(project_id)
         elif type(project_id) == str:
             projects = self._account.projects
-            projects_match = [proj for proj in projects
-                              if proj["name"] == project_id]
+            projects_match = [proj for proj in projects if proj["name"] == project_id]
             if not projects_match:
-                raise Exception(
-                    f"Project {project_id}" +
-                    " does not exist or is not available for this user."
-                )
+                raise Exception(f"Project {project_id}" + " does not exist or is not available for this user.")
             p_id = int(projects_match[0]["id"])
         else:
             raise TypeError("project_id")
@@ -1404,30 +1351,26 @@ class Project:
         }
 
         try:
-            platform.parse_response(platform.post(
-                self._account.auth,
-                "file_manager/copy_container_to_another_project",
-                data=data
-            ))
-        except errors.PlatformError as e:
-            logging.getLogger(logger_name).error(
-                "Couldn not copy container: {}".format(e)
+            platform.parse_response(
+                platform.post(self._account.auth, "file_manager/copy_container_to_another_project", data=data)
             )
+        except errors.PlatformError as e:
+            logging.getLogger(logger_name).error("Couldn not copy container: {}".format(e))
             return False
 
         return True
 
     def start_analysis(
-            self,
-            script_name,
-            version,
-            in_container_id=None,
-            analysis_name=None,
-            analysis_description=None,
-            ignore_warnings=False,
-            settings=None,
-            tags=None,
-            preferred_destination=None
+        self,
+        script_name,
+        version,
+        in_container_id=None,
+        analysis_name=None,
+        analysis_description=None,
+        ignore_warnings=False,
+        settings=None,
+        tags=None,
+        preferred_destination=None,
     ):
         """
         Starts an analysis on a subject.
@@ -1466,13 +1409,9 @@ class Project:
         logger = logging.getLogger(logger_name)
 
         if in_container_id is None and settings is None:
-            raise ValueError(
-                "Pass a value for either in_container_id or settings.")
+            raise ValueError("Pass a value for either in_container_id or settings.")
 
-        post_data = {
-            "script_name": script_name,
-            "version": version
-        }
+        post_data = {"script_name": script_name, "version": version}
 
         settings = settings or {}
 
@@ -1502,9 +1441,7 @@ class Project:
             post_data["preferred_destination"] = preferred_destination
 
         logger.debug(f"post_data = {post_data}")
-        return self.__handle_start_analysis(
-            post_data, ignore_warnings=ignore_warnings
-        )
+        return self.__handle_start_analysis(post_data, ignore_warnings=ignore_warnings)
 
     def delete_analysis(self, analysis_id):
         """
@@ -1516,19 +1453,20 @@ class Project:
         logger = logging.getLogger(logger_name)
 
         try:
-            platform.parse_response(platform.post(
-                auth=self._account.auth,
-                endpoint="analysis_manager/delete_analysis",
-                data={"project_id": analysis_id}
-            ))
+            platform.parse_response(
+                platform.post(
+                    auth=self._account.auth,
+                    endpoint="analysis_manager/delete_analysis",
+                    data={"project_id": analysis_id},
+                )
+            )
         except errors.PlatformError as error:
             logger.error("Could not delete analysis: {}".format(error))
             return False
 
         return True
 
-    def __handle_start_analysis(self, post_data, ignore_warnings=False,
-                                n_calls=0):
+    def __handle_start_analysis(self, post_data, ignore_warnings=False, n_calls=0):
         """
         Handle the possible responses from the server after start_analysis.
         Sometimes we have to send a request again, and then check again the
@@ -1543,16 +1481,16 @@ class Project:
 
         logger = logging.getLogger(logger_name)
         if n_calls > call_limit:
-            logger.error(f"__handle_start_analysis_response called itself more\
-                          than {n_calls} times: aborting.")
+            logger.error(
+                f"__handle_start_analysis_response called itself more\
+                          than {n_calls} times: aborting."
+            )
             return None
 
         try:
-            response = platform.parse_response(platform.post(
-                self._account.auth,
-                "analysis_manager/analysis_registration",
-                data=post_data
-            ))
+            response = platform.parse_response(
+                platform.post(self._account.auth, "analysis_manager/analysis_registration", data=post_data)
+            )
             logger.info(response["message"])
             return int(response["analysis_id"])
         except platform.ChooseDataError as choose_data:
@@ -1574,8 +1512,7 @@ class Project:
                 chosen_files = {}
                 for settings_key in choose_data.data_to_choose:
                     chosen_files[settings_key] = {}
-                    filters = choose_data.data_to_choose[
-                        settings_key]["filters"]
+                    filters = choose_data.data_to_choose[settings_key]["filters"]
                     for filter_key in filters:
                         filter_data = filters[filter_key]
 
@@ -1587,35 +1524,24 @@ class Project:
                         if filter_data["range"][0] != 0:
                             number_of_files_to_select = filter_data["range"][0]
                         elif filter_data["range"][1] != 0:
-                            number_of_files_to_select = min(
-                                filter_data["range"][1],
-                                len(filter_data["files"])
-                            )
+                            number_of_files_to_select = min(filter_data["range"][1], len(filter_data["files"]))
                         else:
-                            number_of_files_to_select = len(
-                                filter_data["files"]
-                            )
+                            number_of_files_to_select = len(filter_data["files"])
 
-                        files_selection = [ff["_id"] for ff in
-                                           filter_data["files"]
-                                           [:number_of_files_to_select]]
-                        chosen_files[settings_key][filter_key] = \
-                            files_selection
+                        files_selection = [ff["_id"] for ff in filter_data["files"][:number_of_files_to_select]]
+                        chosen_files[settings_key][filter_key] = files_selection
 
                 new_post["user_preference"] = json.dumps(chosen_files)
             else:
                 if has_warning and not ignore_warnings:
-                    logger.info("cancelling analysis due to warnings, " +
-                                "set \"ignore_warnings\" to True to override")
+                    logger.info("cancelling analysis due to warnings, " + 'set "ignore_warnings" to True to override')
                     new_post["cancel"] = "1"
                 else:
                     logger.info("suppressing warnings")
                     new_post["user_preference"] = "{}"
                     new_post["_mint_only_warning"] = "1"
 
-            return self.__handle_start_analysis(
-                new_post, ignore_warnings=ignore_warnings, n_calls=n_calls
-            )
+            return self.__handle_start_analysis(new_post, ignore_warnings=ignore_warnings, n_calls=n_calls)
         except platform.ActionFailedError as e:
             logger.error(f"Unable to start the analysis: {e}")
             return None
@@ -1646,19 +1572,15 @@ class Project:
         logger = logging.getLogger(__name__)
         logger.info(f"Setting QC status to {status}: {comments}")
 
-        platform.parse_response(platform.post(
-            auth=self._account.auth,
-            endpoint="projectset_manager/set_qa_status",
-            data={
-                "item_ids": analysis_id,
-                "status": status.value,
-                "comments": comments,
-                "entity": "analysis"
-            }
-        ))
+        platform.parse_response(
+            platform.post(
+                auth=self._account.auth,
+                endpoint="projectset_manager/set_qa_status",
+                data={"item_ids": analysis_id, "status": status.value, "comments": comments, "entity": "analysis"},
+            )
+        )
 
-    def get_qc_status(
-            self, patient_secret_name=None, ssid=None, analysis_id=None):
+    def get_qc_status(self, patient_secret_name=None, ssid=None, analysis_id=None):
         """
         Gets the session QC status of a session. If the analysis_id is
         specified, it returns the QC of the
@@ -1668,17 +1590,15 @@ class Project:
         if patient_secret_name and ssid:
             session = self.get_subjects_metadata(
                 search_criteria={
-                    "pars_patient_secret_name": f"string;"
-                                                f"{patient_secret_name}",
-                    "pars_ssid": f"integer;eq|{ssid}"
+                    "pars_patient_secret_name": f"string;" f"{patient_secret_name}",
+                    "pars_ssid": f"integer;eq|{ssid}",
                 }
             )
             to_return = session["qa_status"], session["qa_comments"]
         elif analysis_id:
             try:
                 to_return = [
-                    analysis["qa_data"] for analysis in self.list_analysis()
-                    if analysis["_id"] == analysis_id
+                    analysis["qa_data"] for analysis in self.list_analysis() if analysis["_id"] == analysis_id
                 ][0]
                 to_return = to_return["qa_status"], to_return["qa_comments"]
             except IndexError:
@@ -1689,22 +1609,21 @@ class Project:
                 print(f"An error occurred: {e}")
                 to_return = None
         else:
-            raise Exception(f"Must specify {patient_secret_name} and "
-                            f"{ssid} or {analysis_id}.")
+            raise Exception(f"Must specify {patient_secret_name} and {ssid} or {analysis_id}.")
         return to_return
 
     def start_multiple_analyses(
-            self,
-            script_name,
-            version,
-            n_times,
-            in_container_id=None,
-            analysis_name=None,
-            analysis_description=None,
-            ignore_warnings=False,
-            settings=None,
-            tags=None,
-            preferred_destination=None
+        self,
+        script_name,
+        version,
+        n_times,
+        in_container_id=None,
+        analysis_name=None,
+        analysis_description=None,
+        ignore_warnings=False,
+        settings=None,
+        tags=None,
+        preferred_destination=None,
     ):
         """
         Starts multiple times the same analysis on a subject with the same
@@ -1745,9 +1664,7 @@ class Project:
         """
         logger = logging.getLogger(logger_name)
         for n in range(n_times):
-            logger.info(
-                f"Running tool {script_name}:{version} {n + 1}/{n_times}"
-            )
+            logger.info(f"Running tool {script_name}:{version} {n + 1}/{n_times}")
             yield self.start_analysis(
                 script_name,
                 version,
@@ -1757,5 +1674,40 @@ class Project:
                 ignore_warnings=ignore_warnings,
                 settings=settings,
                 tags=tags,
-                preferred_destination=preferred_destination
+                preferred_destination=preferred_destination,
             )
+
+    def set_project_qa_rules(self, rules_file_path, guidance_text=""):
+        """
+        Logs in to the Qmenta platform, retrieves the project ID based on the project name,
+        and updates the project's QA rules using the provided rules file.
+
+        Args:
+            rules_file_path (str): The file path to the JSON file containing the QA rules.
+            guidance_text (str): Description of the rules. Only visible for Platform admins.
+
+        Returns:
+            bool: True if the rules were set successfully, False otherwise.
+        """
+        # Read the rules from the JSON file
+        try:
+            with open(rules_file_path, "r") as fr:
+                rules = json.load(fr)
+        except FileNotFoundError:
+            print(f"ERROR: Rules file '{rules_file_path}' not found.")
+            return False
+
+        # Update the project's QA rules
+        res = platform.post(
+            auth=self._account.auth,
+            endpoint="projectset_manager/set_session_qa_requirements",
+            data={"project_id": self._project_id, "rules": json.dumps(rules), "guidance_text": guidance_text},
+        )
+
+        if res.json().get("success") == 1:
+            print("Rules set up successfully!")
+            return True
+        else:
+            print("ERROR setting the rules")
+            print(res.json())
+            return False

{qmenta_client-1.1.dev1289.dist-info → qmenta_client-1.1.dev1295.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qmenta-client
-Version: 1.1.dev1289
+Version: 1.1.dev1295
 Summary: Python client lib to interact with the QMENTA platform.
 Author: QMENTA
 Author-email: dev@qmenta.com

{qmenta_client-1.1.dev1289.dist-info → qmenta_client-1.1.dev1295.dist-info}/RECORD

@@ -1,10 +1,10 @@
 qmenta/__init__.py,sha256=jv2YF__bseklT3OWEzlqJ5qE24c4aWd5F4r0TTjOrWQ,65
 qmenta/client/Account.py,sha256=MEljEy9cmg2uP2FG1d3TZAgfj66EE2_3PQAZ9rvpCXY,9647
 qmenta/client/File.py,sha256=ZgvSqejIosUt4uoX7opUnPnp5XGEaJNMRwFC0mQVB8k,5344
-qmenta/client/Project.py,sha256=Y0G5vSVODThAL8kGwmtkcZrE49vB2LVlNf2eRrqr8dg,59767
+qmenta/client/Project.py,sha256=XXwsd2QKk_p61Mg2ahXxS9MHl1KENDPeNTsooQoXNkE,58955
 qmenta/client/Subject.py,sha256=lhxxVdQ6d-GNoQC8mrJwa4L1f44nJc4PcJtDspmKN7I,8756
 qmenta/client/__init__.py,sha256=AjTojBhZeW5nl0i605KS8S1Gl5tPNc1hdzD47BGNfoI,147
 qmenta/client/utils.py,sha256=5DK2T_HQprrCwLS0Ycm2CjseaYmAUKaJkJvYoW-Rqzc,2479
-qmenta_client-1.1.dev1289.dist-info/METADATA,sha256=khcRoMKuV0hhGvxc-9tjMy9RRIXugkzyE5sKZ_PuF4M,672
-qmenta_client-1.1.dev1289.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-qmenta_client-1.1.dev1289.dist-info/RECORD,,
+qmenta_client-1.1.dev1295.dist-info/METADATA,sha256=G87kykIBmTLL0ebfHvfT0J-0as4u-HCWPzpdDnTiuds,672
+qmenta_client-1.1.dev1295.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+qmenta_client-1.1.dev1295.dist-info/RECORD,,