qmenta-client 1.1.dev1446__py3-none-any.whl → 1.1.dev1468__py3-none-any.whl

qmenta/__init__.py

@@ -1 +1 @@
-__path__ = __import__('pkgutil').extend_path(__path__, __name__)
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

qmenta/client/Account.py

@@ -9,7 +9,7 @@ from qmenta.core import errors
 from .Project import Project
 from .utils import load_json
 
-logger_name = 'qmenta.client'
+logger_name = "qmenta.client"
 
 
 class Account:
@@ -35,9 +35,7 @@ class Account:
         The Auth object used for communication with the platform
     """
 
-    def __init__(self, username, password,
-                 base_url="https://platform.qmenta.com",
-                 verify_certificates=True):
+    def __init__(self, username, password, base_url="https://platform.qmenta.com", verify_certificates=True):
 
         self._cookie = None
         self.username = username
@@ -64,17 +62,14 @@ class Account:
         """
         logger = logging.getLogger(logger_name)
         try:
-            auth = platform.Auth.login(
-                self.username, self.password, base_url=self.baseurl,
-                ask_for_2fa_input=True
-            )
+            auth = platform.Auth.login(self.username, self.password, base_url=self.baseurl, ask_for_2fa_input=True)
         except errors.PlatformError as e:
-            logger.error('Failed to log in: {}'.format(e))
+            logger.error("Failed to log in: {}".format(e))
             self.auth = None
             raise
 
         self.auth = auth
-        logger.info('Logged in as {}'.format(self.username))
+        logger.info("Logged in as {}".format(self.username))
 
     def logout(self):
         """
@@ -88,12 +83,12 @@ class Account:
 
         logger = logging.getLogger(logger_name)
         try:
-            platform.parse_response(platform.post(self.auth, 'logout'))
+            platform.parse_response(platform.post(self.auth, "logout"))
         except errors.PlatformError as e:
-            logger.error('Logout was unsuccessful: {}'.format(e))
+            logger.error("Logout was unsuccessful: {}".format(e))
             raise
 
-        logger.info('Logged out successfully')
+        logger.info("Logged out successfully")
 
     def get_project(self, project_id):
         """
@@ -114,14 +109,9 @@ class Account:
             return Project(self, int(project_id))
         elif type(project_id) is str:
             projects = self.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 "
-                    f"not available for this user."
-                )
+                raise Exception(f"Project {project_id} does not exist or is not available for this user.")
             return Project(self, int(projects_match[0]["id"]))
 
     @property
@@ -137,11 +127,9 @@ class Account:
         logger = logging.getLogger(logger_name)
 
         try:
-            data = platform.parse_response(platform.post(
-                self.auth, 'projectset_manager/get_projectset_list'
-            ))
+            data = platform.parse_response(platform.post(self.auth, "projectset_manager/get_projectset_list"))
         except errors.PlatformError as e:
-            logger.error('Failed to get project list: {}'.format(e))
+            logger.error("Failed to get project list: {}".format(e))
             raise
 
         titles = []
@@ -149,8 +137,7 @@ class Account:
             titles.append({"name": project["name"], "id": project["_id"]})
         return titles
 
-    def add_project(self, project_abbreviation, project_name,
-                    description="", users=None, from_date="", to_date=""):
+    def add_project(self, project_abbreviation, project_name, description="", users=None, from_date="", to_date=""):
         """
         Add a new project to the user account.
 
@@ -183,17 +170,20 @@ class Account:
                 return False
 
         try:
-            platform.parse_response(platform.post(
-                self.auth, 'projectset_manager/upsert_project',
-                data={
-                    "name": project_name,
-                    "description": description,
-                    "from_date": from_date,
-                    "to_date": to_date,
-                    "abbr": project_abbreviation,
-                    "users": "|".join(users)
-                }
-            ))
+            platform.parse_response(
+                platform.post(
+                    self.auth,
+                    "projectset_manager/upsert_project",
+                    data={
+                        "name": project_name,
+                        "description": description,
+                        "from_date": from_date,
+                        "to_date": to_date,
+                        "abbr": project_abbreviation,
+                        "users": "|".join(users),
+                    },
+                )
+            )
         except errors.PlatformError as e:
             logger.error(e)
             return False
@@ -205,9 +195,15 @@ class Account:
         logger.error("Project could note be created.")
         return False
 
-    def _send_request(self, path, req_parameters=None, req_headers=None,
-                      stream=False, return_raw_response=False,
-                      response_timeout=900.0):
+    def _send_request(
+        self,
+        path,
+        req_parameters=None,
+        req_headers=None,
+        stream=False,
+        return_raw_response=False,
+        response_timeout=900.0,
+    ):
         """
         TODO: not used and contains warnings, maybe we should delete it.
 
@@ -234,34 +230,33 @@ class Account:
         """
 
         req_headers = req_headers or {}
-        req_url = '/'.join((self.baseurl, path))
+        req_url = "/".join((self.baseurl, path))
         if self._cookie is not None:
             req_headers["Cookie"] = self._cookie
         req_headers["Mint-Api-Call"] = "1"
 
         logger = logging.getLogger(logger_name)
         try:
-            if path == 'upload':
+            if path == "upload":
                 response = self.pool.request(
-                    'POST',
+                    "POST",
                     req_url,
                     body=req_parameters,
                     headers=req_headers,
                     timeout=response_timeout,
-                    preload_content=not stream
+                    preload_content=not stream,
                 )
             else:
                 response = self.pool.request(
-                    'POST',
+                    "POST",
                     req_url,
                     req_parameters or {},
                     headers=req_headers,
                     timeout=response_timeout,
-                    preload_content=not stream
+                    preload_content=not stream,
                 )
             if response.status >= 400:
-                raise HTTPError(
-                    'STATUS {}: {}'.format(response.status, response.reason))
+                raise HTTPError("STATUS {}: {}".format(response.status, response.reason))
         except Exception as e:
             error = "Could not send request. ERROR: {0}".format(e)
             logger.error(error)
@@ -283,8 +278,7 @@ class Account:
         try:
             parsed_content = load_json(response.data)
         except Exception:
-            error = "Could not parse the response as JSON data: {}".format(
-                response.data)
+            error = "Could not parse the response as JSON data: {}".format(response.data)
             logger.error(error)
             raise
 
@@ -293,8 +287,8 @@ class Account:
             error = parsed_content["error"] or "Unknown error"
             logger.error(error)
             raise Exception(error)
-        elif 'success' in parsed_content and parsed_content['success'] == 3:
-            error = parsed_content['message']
+        elif "success" in parsed_content and parsed_content["success"] == 3:
+            error = parsed_content["message"]
             logger.error(error)
             raise Exception(error)
         return parsed_content

qmenta/client/File.py

@@ -32,14 +32,12 @@ class File:
     `ff_container = File(project, "MRB", "1", "gre_field_mapping_3.zip")`
     """
 
-    def __init__(self, project: qmenta.client.Project, subject_name: str,
-                 ssid: str, file_name: str):
+    def __init__(self, project: qmenta.client.Project, subject_name: str, ssid: str, file_name: str):
         self.file_name = file_name
         self.project = project
         self._container_id = None
         for cont in self.project.list_input_containers():
-            if cont["patient_secret_name"] == subject_name and cont[
-                    "ssid"] == ssid:
+            if cont["patient_secret_name"] == subject_name and cont["ssid"] == ssid:
                 self._container_id = cont["container_id"]
                 break
         if self.file_name.endswith(".zip"):
@@ -52,8 +50,7 @@ class File:
     def __str__(self):
         return self.file_name
 
-    def pull_scan_sequence_info(self, specify_dicom_tags=None,
-                                output_format: str = "csv"):
+    def pull_scan_sequence_info(self, specify_dicom_tags=None, output_format: str = "csv"):
         """
         Pulling scan sequence information (e.g. series number, series type,
         series description, number of files, file formats available)
@@ -77,13 +74,11 @@ class File:
         if specify_dicom_tags is None:
             specify_dicom_tags = list()
         valid_output_formats = ["csv", "tsv", "json", "dict"]
-        assert output_format in valid_output_formats, \
-            f"Output format not valid. Choose one of {valid_output_formats}"
+        assert output_format in valid_output_formats, f"Output format not valid. Choose one of {valid_output_formats}"
 
         with TemporaryDirectory() as temp_dir:
             local_file_name = mkstemp(dir=temp_dir) + ".zip"
-            self.project.download_file(self._container_id, self.file_name,
-                                       local_file_name, overwrite=False)
+            self.project.download_file(self._container_id, self.file_name, local_file_name, overwrite=False)
             if self._file_type == "DICOM":
                 unzip_dicoms(local_file_name, temp_dir, exclude_members=None)
                 dicoms = glob.glob(os.path.join(temp_dir, "*"))
@@ -97,20 +92,11 @@ class File:
                             # only needed for one file, all have the same data.
                             for attribute in specify_dicom_tags:
                                 # error handling of attributes send by the user
-                                assert len(
-                                    attribute) == 2, (
-                                    "Invalid length of DICOM Attribute"
-                                )
-                                assert isinstance(attribute[0],
-                                                  int), (
-                                    "Invalid type of DICOM Attribute"
-                                )
-                                output_data["dicom tag"].append(
-                                    open_file[attribute].tag)
-                                output_data["attribute"].append(
-                                    open_file[attribute].name)
-                                output_data["value"].append(
-                                    open_file[attribute].value)
+                                assert len(attribute) == 2, "Invalid length of DICOM Attribute"
+                                assert isinstance(attribute[0], int), "Invalid type of DICOM Attribute"
+                                output_data["dicom tag"].append(open_file[attribute].tag)
+                                output_data["attribute"].append(open_file[attribute].name)
+                                output_data["value"].append(open_file[attribute].value)
                     except Exception as e:
                         print(str(e))
                         pass
@@ -120,14 +106,10 @@ class File:
         output_data["value"].append(number_files)
 
         if output_format == "csv":
-            pd.DataFrame(output_data).to_csv(
-                f"scan_sequence_info.{output_format}", index=False)
+            pd.DataFrame(output_data).to_csv(f"scan_sequence_info.{output_format}", index=False)
 
         elif output_format == "tsv":
-            pd.DataFrame(output_data).to_csv(
-                f"scan_sequence_info.{output_format}", sep="\t",
-                index=False
-            )
+            pd.DataFrame(output_data).to_csv(f"scan_sequence_info.{output_format}", sep="\t", index=False)
 
         elif output_format == "json":
             with open(f"scan_sequence_info.{output_format}", "w") as fp:

qmenta/client/Project.py

@@ -43,8 +43,7 @@ def convert_qc_value_to_qcstatus(value):
     elif value == "":
         return QCStatus.UNDERTERMINED
     else:
-        logger.error(f"The input value '{value}' cannot be converted "
-                     f"to class QCStatus.")
+        logger.error(f"The input value '{value}' cannot be converted to class QCStatus.")
         return False
 
 
@@ -76,6 +75,7 @@ class Project:
     """
 
     """ Project Related Methods """
+
     def __init__(self, account: Account, project_id, max_upload_retries=5):
         # if project_id is a string (the name of the project), get the
         # project id (int)
@@ -134,6 +134,7 @@ class Project:
         return rep
 
     """ Upload / Download Data Related Methods """
+
     def _upload_chunk(
         self,
         data,
@@ -350,14 +351,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
 
@@ -451,14 +452,12 @@ class Project:
         """
         logger = logging.getLogger(logger_name)
         if not isinstance(file_name, str):
-            raise ValueError("The name of the file to download (file_name) "
-                             "should be of type string.")
+            raise ValueError("The name of the file to download (file_name) should be of type string.")
         if not isinstance(file_name, str):
-            raise ValueError("The name of the output file (local_filename) "
-                             "should be of type string.")
+            raise ValueError("The name of the output file (local_filename) should be of type string.")
 
         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 {container_id}'
             logger.error(msg)
             return False
 
@@ -479,7 +478,7 @@ class Project:
                 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 {local_filename}")
         return True
 
     def download_files(self, container_id, filenames, zip_name="files.zip", overwrite=False):
@@ -500,18 +499,14 @@ class Project:
         logger = logging.getLogger(logger_name)
 
         if not all([isinstance(file_name, str) for file_name in filenames]):
-            raise ValueError("The name of the files to download (filenames) "
-                             "should be of type string.")
+            raise ValueError("The name of the files to download (filenames) should be of type string.")
         if not isinstance(zip_name, str):
-            raise ValueError("The name of the output ZIP file (zip_name) "
-                             "should be of type string.")
+            raise ValueError("The name of the output ZIP file (zip_name) should be of type string.")
 
         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 {container_id}: {', '.join(files_not_in_container)}"
             logger.error(msg)
             return False
 
@@ -575,6 +570,7 @@ class Project:
         return True
 
     """ Subject/Session Related Methods """
+
     @property
     def subjects(self):
         """
@@ -810,12 +806,12 @@ class Project:
 
         """
 
-        assert len(items) == 2, f"The number of elements in items " f"'{len(items)}' should be equal to two."
+        assert len(items) == 2, f"The number of elements in items '{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 '{search_criteria.keys()}' must start with 'pars_'."
 
         for key, value in search_criteria.items():
             if value.split(";")[0] in ["integer", "decimal"]:
@@ -869,7 +865,7 @@ 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. Must be convertible to int.")
 
         assert isinstance(tags, list) and all(
             isinstance(item, str) for item in tags
@@ -882,13 +878,13 @@ class Project:
         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. Must be an integer.")
 
         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 are either all starting with 'md_' or none."
 
         metadata_keys = self.metadata_parameters.keys()
         assert all(
@@ -1047,27 +1043,26 @@ class Project:
         # them from the results.
         subjects = list()
         for subject in content:
-            files = platform.parse_response(platform.post(
-                self._account.auth, "file_manager/get_container_files",
-                data={"container_id": str(int(subject["container_id"]))}
-                ))
+            files = platform.parse_response(
+                platform.post(
+                    self._account.auth,
+                    "file_manager/get_container_files",
+                    data={"container_id": str(int(subject["container_id"]))},
+                )
+            )
 
             for file in files["meta"]:
-                if modality and \
-                   modality != (file.get("metadata") or {}).get("modality"):
+                if modality and modality != (file.get("metadata") or {}).get("modality"):
                     continue
                 if tags and not all([tag in file.get("tags") for tag in tags]):
                     continue
                 if dicoms:
                     result_values = list()
                     for key, dict_value in dicoms.items():
-                        f_value = ((file.get("metadata") or {})
-                                   .get("info") or {}).get(key)
+                        f_value = ((file.get("metadata") or {}).get("info") or {}).get(key)
                         d_operator = dict_value["operation"]
                         d_value = dict_value["value"]
-                        result_values.append(
-                            self.__operation(d_value, d_operator, f_value)
-                        )
+                        result_values.append(self.__operation(d_value, d_operator, f_value))
 
                     if not all(result_values):
                         continue
@@ -1150,10 +1145,10 @@ class Project:
         ]
 
         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 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"]))
 
@@ -1168,10 +1163,10 @@ class Project:
                 )
             )
         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 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 deleted.")
         return True
 
     def delete_session_by_patientid(self, patient_id):
@@ -1273,7 +1268,7 @@ 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 len(items) == 2, f"The number of elements in items '{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(
@@ -1316,7 +1311,8 @@ class Project:
         ----------
         search_condition : dict
             - p_n: str or None Analysis name
-            - type: str or None Type
+            - type: str or None Type (analysis_code:analysis_version).
+            - analysis_code: str or None Type
             - from_d: str or None dd.mm.yyyy Date from
             - to_d: str or None dd.mm.yyyy Date to
             - qa_status: str or None pass/fail/nd QC status
@@ -1372,13 +1368,7 @@ class Project:
             return False
         return content["files"]
 
-    def list_container_filter_files(
-        self,
-        container_id,
-        modality="",
-        metadata_info={},
-        tags=[]
-    ):
+    def list_container_filter_files(self, container_id, modality="", metadata_info={}, tags=[]):
         """
         List the name of the files available inside a given container.
         search condition example:
@@ -1414,23 +1404,12 @@ class Project:
             if modality == "":
                 modality_bool = True
             else:
-                modality_bool = modality == metadata_file["metadata"].get(
-                    "modality"
-                )
+                modality_bool = modality == metadata_file["metadata"].get("modality")
             for key in metadata_info.keys():
-                meta_key = (
-                    (
-                        metadata_file.get("metadata") or {}
-                    ).get("info") or {}).get(
-                        key
-                    )
+                meta_key = ((metadata_file.get("metadata") or {}).get("info") or {}).get(key)
                 if meta_key is None:
-                    logging.getLogger(logger_name).warning(
-                        f"{key} is not in file_info from file {file}"
-                    )
-                info_bool.append(
-                    metadata_info[key] == meta_key
-                    )
+                    logging.getLogger(logger_name).warning(f"{key} is not in file_info from file {file}")
+                info_bool.append(metadata_info[key] == meta_key)
             if all(tags_bool) and all(info_bool) and modality_bool:
                 selected_files.append(file)
         return selected_files
@@ -1486,13 +1465,12 @@ class Project:
                 analysis_name_or_id = int(analysis_name_or_id)
             else:
                 search_tag = "p_n"
-                excluded_characters = ["\\", "[", "]", "(", ")",
-                                       "{", "}", "+", "*"]
+                excluded_characters = ["\\", "[", "]", "(", ")", "{", "}", "+", "*"]
                 excluded_bool = [character in analysis_name_or_id for character in excluded_characters]
                 if any(excluded_bool):
                     raise Exception(f"p_n does not allow characters {excluded_characters}")
         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,
@@ -1502,7 +1480,7 @@ class Project:
         )
 
         if len(response) > 1:
-            raise Exception(f"multiple analyses with name " f"{analysis_name_or_id} found")
+            raise Exception(f"multiple analyses with name {analysis_name_or_id} found")
         elif len(response) == 1:
             return response[0]
         else:
@@ -1530,7 +1508,8 @@ class Project:
         ----------
         search_condition : dict
             - p_n: str or None Analysis name
-            - type: str or None Type
+            - type: str or None Type (analysis_code:analysis_version).
+            - analysis_code: str or None Type
             - from_d: str or None dd.mm.yyyy Date from
             - to_d: str or None dd.mm.yyyy Date to
             - qa_status: str or None pass/fail/nd QC status
@@ -1550,11 +1529,12 @@ 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 len(items) == 2, f"The number of elements in items '{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,
+            "analysis_code": str,
             "from_d": str,
             "to_d": str,
             "qa_status": str,
@@ -1567,12 +1547,11 @@ 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]) and search_condition[key] is not None:
-                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 is not type {search_keys[key]}"))
             if "p_n" == key:
-                excluded_characters = ["\\", "[", "]", "(", ")",
-                                       "{", "}", "+", "*"]
+                excluded_characters = ["\\", "[", "]", "(", ")", "{", "}", "+", "*"]
                 excluded_bool = [character in search_condition["p_n"] for character in excluded_characters]
                 if any(excluded_bool):
                     raise Exception(f"p_n does not allow characters {excluded_characters}")
@@ -1598,6 +1577,7 @@ class Project:
         settings=None,
         tags=None,
         preferred_destination=None,
+        ignore_file_selection=True,
     ):
         """
         Starts an analysis on a subject.
@@ -1627,6 +1607,10 @@ class Project:
             The tags of the analysis.
         preferred_destination : str
             The machine on which to run the analysis
+        ignore_file_selection : Bool
+            When the file filter of the analysis is satified by multiple files.
+            False if you want to select manually the file to input to the
+            analysis. True otherwise and the analysis will cancelled.
 
         Returns
         -------
@@ -1668,7 +1652,9 @@ 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, ignore_file_selection=ignore_file_selection
+        )
 
     def delete_analysis(self, analysis_id):
         """
@@ -1759,17 +1745,16 @@ class Project:
         try:
             analysis_id = str(int(analysis_id))
         except ValueError:
-            raise ValueError(f"'analysis_id' has to be an integer"
-                             f" not '{analysis_id}'.")
+            raise ValueError(f"'analysis_id' has to be an integer not '{analysis_id}'.")
 
         file_name = file_name if file_name else f"logs_{analysis_id}.txt"
         try:
             res = platform.post(
-                    auth=self._account.auth,
-                    endpoint="analysis_manager/download_execution_file",
-                    data={"project_id": analysis_id, "file": f"logs_{analysis_id}"},
-                    timeout=1000
-                )
+                auth=self._account.auth,
+                endpoint="analysis_manager/download_execution_file",
+                data={"project_id": analysis_id, "file": f"logs_{analysis_id}"},
+                timeout=1000,
+            )
         except Exception:
             logger.error(f"Could not export the analysis log of '{analysis_id}'")
             return False
@@ -1784,8 +1769,7 @@ class Project:
 
     """ QC Status Related Methods """
 
-    def set_qc_status_analysis(self, analysis_id,
-                               status=QCStatus.UNDERTERMINED, comments=""):
+    def set_qc_status_analysis(self, analysis_id, status=QCStatus.UNDERTERMINED, comments=""):
         """
         Changes the analysis QC status.
 
@@ -1814,25 +1798,27 @@ class Project:
         try:
             analysis_id = str(int(analysis_id))
         except ValueError:
-            raise ValueError(f"analysis_id: '{analysis_id}' not valid. " f"Must be convertible to int.")
+            raise ValueError(f"analysis_id: '{analysis_id}' not valid. Must be convertible to int.")
 
         try:
             platform.parse_response(
                 platform.post(
                     auth=self._account.auth,
                     endpoint="projectset_manager/set_qa_status",
-                    data={"item_ids": analysis_id, "status": status.value,
-                          "comments": str(comments), "entity": "analysis"},
+                    data={
+                        "item_ids": analysis_id,
+                        "status": status.value,
+                        "comments": str(comments),
+                        "entity": "analysis",
+                    },
                 )
             )
         except Exception:
-            logger.error(f"It was not possible to change the QC status of"
-                         f"Analysis ID: {analysis_id}")
+            logger.error(f"It was not possible to change the QC status of Analysis ID: {analysis_id}")
             return False
         return True
 
-    def set_qc_status_subject(self, patient_id,
-                              status=QCStatus.UNDERTERMINED, comments=""):
+    def set_qc_status_subject(self, patient_id, status=QCStatus.UNDERTERMINED, comments=""):
         """
         Changes the QC status of a Patient ID (equivalent to a
         Subject ID/Session ID).
@@ -1861,20 +1847,23 @@ 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. Must be convertible to int.")
 
         try:
             platform.parse_response(
                 platform.post(
                     auth=self._account.auth,
                     endpoint="projectset_manager/set_qa_status",
-                    data={"item_ids": patient_id, "status": status.value,
-                          "comments": str(comments), "entity": "patients"},
+                    data={
+                        "item_ids": patient_id,
+                        "status": status.value,
+                        "comments": str(comments),
+                        "entity": "patients",
+                    },
                 )
             )
         except Exception:
-            logger.error(f"It was not possible to change the QC status of"
-                         f"Patient ID: {patient_id}")
+            logger.error(f"It was not possible to change the QC status of Patient ID: {patient_id}")
             return False
         return True
 
@@ -1906,12 +1895,10 @@ class Project:
             return False, False
         except Exception:
             # Handle other potential exceptions
-            logging.error(f"It was not possible to extract the QC status"
-                          f"from Analysis ID: {analysis_id}")
+            logging.error(f"It was not possible to extract the QC status from Analysis ID: {analysis_id}")
             return False, False
 
-    def get_qc_status_subject(self, patient_id=None, subject_name=None,
-                              ssid=None):
+    def get_qc_status_subject(self, patient_id=None, subject_name=None, ssid=None):
         """
         Gets the session QC status via the patient ID or the Subject ID
         and the Session ID.
@@ -1939,13 +1926,11 @@ class Project:
             try:
                 patient_id = int(patient_id)
             except ValueError:
-                raise ValueError(f"patient_id '{patient_id}' should be an "
-                                 f"integer.")
+                raise ValueError(f"patient_id '{patient_id}' should be an integer.")
             sessions = self.get_subjects_metadata(search_criteria={})
             session = [session for session in sessions if int(session["_id"]) == patient_id]
             if len(session) < 1:
-                logging.error(f"No session was found with Patient ID: "
-                              f"'{patient_id}'.")
+                logging.error(f"No session was found with Patient ID: '{patient_id}'.")
                 return False, False
             return convert_qc_value_to_qcstatus(session[0]["qa_status"]), session[0]["qa_comments"]
         elif subject_name and ssid:
@@ -1956,15 +1941,14 @@ class Project:
                 }
             )
             if len(session) < 1:
-                logging.error(f"No session was found with Subject ID: "
-                              f"'{subject_name}' and Session ID: '{ssid}'.")
+                logging.error(f"No session was found with Subject ID: '{subject_name}' and Session ID: '{ssid}'.")
                 return False, False
             return convert_qc_value_to_qcstatus(session[0]["qa_status"]), session[0]["qa_comments"]
         else:
-            raise ValueError("Either 'patient_id' or 'subject_name' and 'ssid'"
-                             " must not be empty.")
+            raise ValueError("Either 'patient_id' or 'subject_name' and 'ssid' must not be empty.")
 
     """ Protocol Adherence Related Methods """
+
     def set_project_pa_rules(self, rules_file_path, guidance_text=""):
         """
         Updates the active project's protocol adherence rules using the
@@ -1989,20 +1973,20 @@ class Project:
             with open(rules_file_path, "r") as fr:
                 rules = json.load(fr)
         except FileNotFoundError:
-            logger.error(f"Pprotocol adherence rule file '{rules_file_path}' "
-                         f"not found.")
+            logger.error(f"Pprotocol adherence rule file '{rules_file_path}' not found.")
             return False
 
         # Update the project's QA rules
-        res = platform.parse_response(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},
-        ))
+        res = platform.parse_response(
+            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 not res.get("success") == 1:
-            logger.error("There was an error setting up the protocol "
-                         "adherence rules.")
+            logger.error("There was an error setting up the protocol adherence rules.")
             logger.error(platform.parse_response(res))
             return False
 
@@ -2028,15 +2012,16 @@ class Project:
         logger = logging.getLogger(logger_name)
 
         # Update the project's QA rules
-        res = platform.parse_response(platform.post(
-            auth=self._account.auth,
-            endpoint="projectset_manager/get_session_qa_requirements",
-            data={"project_id": self._project_id},
-        ))
+        res = platform.parse_response(
+            platform.post(
+                auth=self._account.auth,
+                endpoint="projectset_manager/get_session_qa_requirements",
+                data={"project_id": self._project_id},
+            )
+        )
 
         if "rules" not in res:
-            logger.error(f"There was an error extracting the protocol "
-                         f"adherence rules from {self._project_name}.")
+            logger.error(f"There was an error extracting the protocol adherence rules from {self._project_name}.")
             logger.error(platform.parse_response(res))
             return False
 
@@ -2048,14 +2033,14 @@ class Project:
             with open(rules_file_path, "w") as fr:
                 json.dump(res["rules"], fr, indent=4)
         except FileNotFoundError:
-            logger.error(f"Protocol adherence rules could not be exported"
-                         f"to file: '{rules_file_path}'.")
+            logger.error(f"Protocol adherence rules could not be exported to file: '{rules_file_path}'.")
             return False
 
         return res["guidance_text"]
 
     """ Helper Methods """
-    def __handle_start_analysis(self, post_data, ignore_warnings=False, n_calls=0):
+
+    def __handle_start_analysis(self, post_data, ignore_warnings=False, ignore_file_selection=True, 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
@@ -2081,8 +2066,21 @@ class Project:
                 platform.post(self._account.auth, "analysis_manager/analysis_registration", data=post_data)
             )
             logger.info(response["message"])
-            return int(response["analysis_id"])
+            return int(response["analysis_id"]) if "analysis_id" in response else None
+
         except platform.ChooseDataError as choose_data:
+            if ignore_file_selection:
+                logger.error(
+                    "Existence of multiple files satisfying the input data "
+                    "requirements and parameter ignore_file_selection==True."
+                )
+                logger.error(
+                    f"Unable to start the analysis: "
+                    f"{post_data['script_name']}:"
+                    f"{post_data['version']} with input "
+                    f"{post_data['as_input']}."
+                )
+                return None
             has_warning = False
 
             # logging any warning that we have
@@ -2097,44 +2095,104 @@ class Project:
             }
 
             if choose_data.data_to_choose:
-                # in case we have data to choose
-                chosen_files = {}
-                for settings_key in choose_data.data_to_choose:
-                    chosen_files[settings_key] = {}
-                    filters = choose_data.data_to_choose[settings_key]["filters"]
-                    for filter_key in filters:
-                        filter_data = filters[filter_key]
-
-                        # skip the filters that did not pass
-                        if not filter_data["passed"]:
-                            continue
-
-                        number_of_files_to_select = 1
-                        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"]))
-                        else:
-                            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
-
-                new_post["user_preference"] = json.dumps(chosen_files)
+                self.__handle_manual_choose_data(new_post, choose_data)
             else:
                 if has_warning and not ignore_warnings:
-                    logger.info("cancelling analysis due to warnings, " + 'set "ignore_warnings" to True to override')
+                    logger.error("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_file_selection, n_calls)
         except platform.ActionFailedError as e:
-            logger.error(f"Unable to start the analysis: {e}")
+            logger.error(f"Unable to start the analysis: {e}.")
             return None
 
+    def __handle_manual_choose_data(self, post_data, choose_data):
+        """
+        Handle the responses of the user when there is need to select a file
+        to start the analysis.
+
+        At the moment only supports a manual selection via the command-line
+        interface.
+
+        Parameters
+        ----------
+            post_data : dict
+                Current post_data dictionary. To be mofidied in-place.
+            choose_data : platform.ChooseDataError
+                Error raised when trying to start an analysis, but data has to be chosen.
+        """
+
+        logger = logging.getLogger(logger_name)
+        logger.warning("Multiple inputs available. You have to select the desired file/s to continue.")
+        # in case we have data to choose
+        chosen_files = {}
+        for settings_key in choose_data.data_to_choose:
+            logger.warning(f"Type next the file/s for the input with ID: '{settings_key}'.")
+            chosen_files[settings_key] = {}
+            filters = choose_data.data_to_choose[settings_key]["filters"]
+            for filter_key in filters:
+                filter_data = filters[filter_key]
+
+                # skip the filters that did not pass
+                if not filter_data["passed"]:
+                    continue
+                elif post_data.get("cancel"):
+                    continue
+
+                number_of_files_to_select = 1
+                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"]))
+                else:
+                    number_of_files_to_select = len(filter_data["files"])
+
+                # If the files need to be selected automatically based
+                # on their file information.
+                # Need to apply some filtering criteria at this stage.
+                # Based on the information provided by next methods.
+                # files_info = list_container_files_metadata() or
+                # list_container_filter_files()
+
+                if number_of_files_to_select != len(filter_data["files"]):
+                    logger.warning(
+                        f"  · File filter name: '{filter_key}'. Type "
+                        f"{number_of_files_to_select} file"
+                        f"{'s (i.e., file1.zip, file2.zip, file3.zip)' if number_of_files_to_select >1 else ''}."
+                    )
+                    save_file_ids, select_file_filter = {}, ""
+                    for file_ in filter_data["files"]:
+                        select_file_filter += f"       · File name: {file_['name']}\n"
+                        save_file_ids[file_["name"]] = file_["_id"]
+                    names = [el.strip() for el in input(select_file_filter).strip().split(",")]
+
+                    if len(names) != number_of_files_to_select:
+                        logger.error("The number of files selected does not correspond to the number of needed files.")
+                        logger.error(
+                            f"Selected: {len(names)} vs. "
+                            f"Number of files to select: "
+                            f"{number_of_files_to_select}."
+                        )
+                        logger.error("Cancelling analysis.")
+                        post_data["cancel"] = "1"
+
+                    elif any([name not in save_file_ids for name in names]):
+                        logger.error(f"Some selected file/s '{', '.join(names)}' do not exist. Cancelling analysis...")
+                        post_data["cancel"] = "1"
+                    else:
+                        chosen_files[settings_key][filter_key] = [save_file_ids[name] for name in names]
+
+                else:
+                    logger.warning("Setting all available files to be input to the analysis.")
+                    files_selection = [ff["_id"] for ff in filter_data["files"][:number_of_files_to_select]]
+                    chosen_files[settings_key][filter_key] = files_selection
+
+        post_data["user_preference"] = json.dumps(chosen_files)
+
     @staticmethod
     def __get_modalities(files):
         modalities = []
@@ -2284,9 +2342,9 @@ class Project:
             if key == "pars_modalities":
                 modalities = value.split(";")[1].split(",")
                 if len(modalities) != 1:
-                    raise ValueError(f"A file can only have one modality. "
-                                     f"Provided Modalities: "
-                                     f"{', '.join(modalities)}.")
+                    raise ValueError(
+                        f"A file can only have one modality. Provided Modalities: {', '.join(modalities)}."
+                    )
                 modality = modalities[0]
             elif key == "pars_tags":
                 tags = value.split(";")[1].split(",")
@@ -2294,27 +2352,16 @@ class Project:
                 d_tag = key.split("pars_[dicom]_")[1]
                 d_type = value.split(";")[0]
                 if d_type == "string":
-                    file_metadata[d_tag] = {
-                        "operation": "in",
-                        "value": value.replace(d_type + ";", "")
-                    }
+                    file_metadata[d_tag] = {"operation": "in", "value": value.replace(d_type + ";", "")}
                 elif d_type == "integer":
                     d_operator = value.split(";")[1].split("|")[0]
                     d_value = value.split(";")[1].split("|")[1]
-                    file_metadata[d_tag] = {
-                        "operation": d_operator,
-                        "value": int(d_value)}
+                    file_metadata[d_tag] = {"operation": d_operator, "value": int(d_value)}
                 elif d_type == "decimal":
                     d_operator = value.split(";")[1].split("|")[0]
                     d_value = value.split(";")[1].split("|")[1]
-                    file_metadata[d_tag] = {
-                        "operation": d_operator,
-                        "value": float(d_value)
-                    }
+                    file_metadata[d_tag] = {"operation": d_operator, "value": float(d_value)}
                 elif d_type == "list":
                     value.replace(d_type + ";", "")
-                    file_metadata[d_tag] = {
-                        "operation": "in-list",
-                        "value": value.replace(d_type + ";", "").split(";")
-                    }
+                    file_metadata[d_tag] = {"operation": "in-list", "value": value.replace(d_type + ";", "").split(";")}
         return modality, tags, file_metadata

qmenta/client/Subject.py

@@ -30,8 +30,7 @@ class Subject:
         self._all_data = None
 
     def __repr__(self):
-        rep = "<Subject {} ({})>".format(self.name,
-                                         self.project or "No project")
+        rep = "<Subject {} ({})>".format(self.name, self.project or "No project")
         return rep
 
     @property
@@ -110,14 +109,13 @@ class Subject:
 
     def get_all_data(self, cache=True):
         if not cache or not self._all_data:
-            self._all_data = platform.parse_response(platform.post(
-                auth=self.project._account.auth,
-                endpoint='patient_manager/get_patient_profile_data',
-                data={
-                    "patient_id": self.subject_id,
-                    "patient_secret_name": self.name
-                }
-            ))
+            self._all_data = platform.parse_response(
+                platform.post(
+                    auth=self.project._account.auth,
+                    endpoint="patient_manager/get_patient_profile_data",
+                    data={"patient_id": self.subject_id, "patient_secret_name": self.name},
+                )
+            )
         return self._all_data
 
     @property
@@ -242,8 +240,7 @@ class Subject:
             List of dictionaries with the data of each analysis performed.
         """
         all_analysis = self.project.list_analysis(limit=10000000)
-        return [a for a in all_analysis if
-                a["patient_secret_name"] == self._name]
+        return [a for a in all_analysis if a["patient_secret_name"] == self._name]
 
     def upload_mri(self, path):
         """

qmenta/client/__init__.py

@@ -3,8 +3,4 @@ from .Project import Project
 from .Subject import Subject
 
 
-__all__ = [
-    'Account',
-    'Project',
-    'Subject'
-]
+__all__ = ["Account", "Project", "Subject"]

qmenta/client/utils.py

@@ -67,14 +67,10 @@ def unzip_dicoms(zip_path, output_folder, exclude_members=None):
         if exclude_members is not None:
             # Filter members according to the passed exclusion rules
             for exclude_members_rule in exclude_members:
-                members = [
-                    x for x in members if not re.match(exclude_members_rule, x)
-                ]
+                members = [x for x in members if not re.match(exclude_members_rule, x)]
 
         # Extract all files and add them to the list of extracted files
         zfile.extractall(path=output_folder, members=members)
-        current_extracted_files = [
-            os.path.join(output_folder, fpath) for fpath in members
-        ]
+        current_extracted_files = [os.path.join(output_folder, fpath) for fpath in members]
         extracted_files.extend(current_extracted_files)
     os.unlink(zip_path)

{qmenta_client-1.1.dev1446.dist-info → qmenta_client-1.1.dev1468.dist-info}/METADATA

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

qmenta_client-1.1.dev1468.dist-info/RECORD

@@ -0,0 +1,10 @@
+qmenta/__init__.py,sha256=ED6jHcYiuYpr_0vjGz0zx2lrrmJT9sDJCzIljoDfmlM,65
+qmenta/client/Account.py,sha256=7BOWHtRbHdfpBYQqv9v2m2Fag13pExZSxFsjDA7UsW0,9500
+qmenta/client/File.py,sha256=iCrzrd7rIfjjW2AgMgUoK-ZF2wf-95wCcPKxKw6PGyg,4816
+qmenta/client/Project.py,sha256=eIEmFcfh5dYjuHqGgfJfjvJNUYM8EEPFDwRidjjGOK8,86415
+qmenta/client/Subject.py,sha256=b5sg9UFtn11bmPM-xFXP8aehOm_HGxnhgT7IPKbrZnE,8688
+qmenta/client/__init__.py,sha256=Mtqe4zf8n3wuwMXSALENQgp5atQY5VcsyXWs2hjBs28,133
+qmenta/client/utils.py,sha256=vWUAW0r9yDetdlwNo86sdzKn03FNGvwa7D9UtOA3TEc,2419
+qmenta_client-1.1.dev1468.dist-info/METADATA,sha256=iVD5lU8ZbFqP5B6I8SdaN784WqN6nkx2MI3IG3lICOU,672
+qmenta_client-1.1.dev1468.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+qmenta_client-1.1.dev1468.dist-info/RECORD,,

qmenta_client-1.1.dev1446.dist-info/RECORD

@@ -1,10 +0,0 @@
-qmenta/__init__.py,sha256=jv2YF__bseklT3OWEzlqJ5qE24c4aWd5F4r0TTjOrWQ,65
-qmenta/client/Account.py,sha256=S9D0-lmcBln2o3DwJfmLfu5G2wjE7gEJCIeJu89v0Is,9647
-qmenta/client/File.py,sha256=ZgvSqejIosUt4uoX7opUnPnp5XGEaJNMRwFC0mQVB8k,5344
-qmenta/client/Project.py,sha256=7MPUskUznuCSN7SOdNyIZckDcnBnJvlMnIoIbF3KvzE,83483
-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.dev1446.dist-info/METADATA,sha256=Itzicjy42tkFa1VpEvKNWSu4X7YpB6AFfeA63CFwZv8,672
-qmenta_client-1.1.dev1446.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-qmenta_client-1.1.dev1446.dist-info/RECORD,,