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

qmenta/client/Project.py

@@ -17,12 +17,14 @@ if sys.version_info[0] == 3:
     unicode = str
 
 logger_name = "qmenta.client"
+OPERATOR_LIST = ["eq", "ne", "gt", "gte", "lt", "lte"]
 
 
 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:
@@ -66,11 +68,144 @@ def check_upload_file(file_path):
         return True
 
 
+def operation(reference_value, operator, input_value):
+    """
+    The method performs an operation by comparing the two input values.
+    The Operation is applied to the Input Value in comparison to the Reference
+    Value.
+
+    Parameters
+    ----------
+    reference_value : str, list, or int
+        Reference value.
+    operator : str
+        Operation.
+    input_value : str, list, or int
+        Input value.
+
+    Returns
+    -------
+    bool
+        True if the operation is satisfied, False otherwise.
+    """
+    if input_value is None or input_value == "":
+        return False
+
+    if operator == "in":
+        return reference_value in input_value
+
+    elif operator == "in-list":
+        return all([el in input_value for el in reference_value])
+
+    elif operator == "eq":
+        return input_value == reference_value
+
+    elif operator == "gt":
+        return input_value > reference_value
+
+    elif operator == "gte":
+        return input_value >= reference_value
+
+    elif operator == "lt":
+        return input_value < reference_value
+
+    elif operator == "lte":
+        return input_value <= reference_value
+    else:
+        return False
+
+
+def wrap_search_criteria(search_criteria={}):
+    """
+    Wraps the conditions specified within the Search Criteria in order for
+    other methods to handle it easily. The conditions are grouped only into
+    three groups: Modality, Tags and the File Metadata (if DICOM it corresponds
+    to the DICOM information), and each of them is output in a different
+    variable.
+
+    Parameters
+    ----------
+    search_criteria : dict
+        Each element is a string and is built using the formatting
+            "KEYTYPE;VALUE", or "KEYTYPE;OPERATOR|VALUE".
+
+            Full list of keys avaiable for the dictionary:
+
+            search_criteria = {
+                "pars_patient_secret_name": "string;SUBJECTID",
+                "pars_ssid": "integer;OPERATOR|SSID",
+                "pars_modalities": "string;MODALITY",
+                "pars_tags": "tags;TAGS",
+                "pars_age_at_scan": "integer;OPERATOR|AGE_AT_SCAN",
+                "pars_[dicom]_KEY": "KEYTYPE;KEYVALUE",
+                "pars_PROJECTMETADATA": "METADATATYPE;METADATAVALUE",
+                }
+
+            See documentation for a complete definition.
+
+    Returns
+    -------
+    modality : str
+        String containing the modality of the search criteria extracted from
+        'pars_modalities'
+
+    tags : list of str
+        List of strings containing the tags of the search criteria extracted
+        'from pars_tags'
+
+    file_metadata : Dict
+        Dictionary containing the file metadata of teh search criteria
+        exgtracted from 'pars_[dicom]_KEY'
+    """
+
+    # The keys not included bellow apply to the whole session.
+    modality, tags, file_metadata = "", list(), dict()
+    for key, value in search_criteria.items():
+        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)}.")
+            modality = modalities[0]
+        elif key == "pars_tags":
+            tags = value.split(";")[1].split(",")
+        elif "pars_[dicom]_" in key:
+            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 + ";", "")
+                }
+            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)}
+            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)
+                }
+            elif d_type == "list":
+                value.replace(d_type + ";", "")
+                file_metadata[d_tag] = {
+                    "operation": "in-list",
+                    "value": value.replace(d_type + ";", "").split(";")
+                }
+    return modality, tags, file_metadata
+
+
 class QCStatus(Enum):
     """
     Enum with the following options:
     FAIL, PASS
     """
+
     PASS = "pass"
     FAIL = "fail"
 
@@ -94,15 +229,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 +264,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
@@ -164,8 +295,8 @@ class Project:
 
     def get_subjects_metadata(self, search_criteria={}, items=(0, 9999)):
         """
-        List all subjects data from the selected project that meet the defined
-            search criteria.
+        List all Subject ID/Session ID from the selected project that meet the
+            defined search criteria at a session level.
 
         Parameters
         ----------
@@ -200,10 +331,12 @@ class Project:
 
         "pars_modalities": Applies the search to the file 'Modalities'
             available within each Subject ID.
-        MODALITY is a comma separated list of string.
+        MODALITY is a comma separated list of string. A session is provided as
+            long as one MODALITY is available.
         "pars_tags": Applies the search to the file 'Tags' available within
             each Subject ID and to the subject-level 'Tags'.
-        TAGS is a comma separated list of strings.
+        TAGS is a comma separated list of strings. A session is provided as
+            long as one tag is available.
         "pars_age_at_scan": Applies the search to the 'age_at_scan' metadata
             field.
         AGE_AT_SCAN is an integer.
@@ -213,11 +346,15 @@ class Project:
             'file_m["metadata"]["info"].keys()'.
         KEYTYPE is the type of the KEY. One of:
             - integer
+            - decimal
             - string
             - list
 
-            if 'integer' you must also include an OPERATOR
+            if 'integer' or 'decimal' you must also include an OPERATOR
                 (i.e., "integer;OPERATOR|KEYVALUE").
+            if 'list' the KEYVALUE should be a semicolon separated list of
+                values. (i.e., "list;KEYVALUE1;KEYVALUE2;KEYVALUE3)
+                KEYVALUEs must be strings.
         KEYVALUE is the expected value of the KEY.
         "pars_[dicom]_PROJECTMETADATA": Applies to the metadata defined
             within the 'Metadata Manager' of the project.
@@ -246,6 +383,7 @@ class Project:
             "pars_tags": "tags;flair",
             "pars_[dicom]_Manufacturer": "string;ge",
             "pars_[dicom]_FlipAngle": "integer;gt|5",
+            "pars_[dicom]_ImageType": "list;PRIMARY;SECONDARY",
         }
 
         Note the search criteria applies to all the files included within a
@@ -253,8 +391,9 @@ class Project:
             are applied to the same files. In example 2) above, it means that
             any Subject ID/Session ID that has a file classified with a 'T1'
             modality, a file with a 'flair' tag, a file whose Manufacturer
-            contains 'ge', and a file whose FlipAngle is greater than '5º' will
-            be selected.
+            contains 'ge', a file whose FlipAngle is greater than '5º', and a
+            file with ImageType with any of the values: PRIMARY or SECONDARY
+            will be selected.
 
         Returns
         -------
@@ -263,29 +402,184 @@ 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 " \
-                    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]}"}
-        ))
+                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]}"},
+            )
+        )
         return content
 
+    def get_subjects_files_metadata(self, search_criteria={}, items=(0, 9999)):
+        """
+        List all Subject ID/Session ID from the selected project that meet the
+            defined search criteria at a file level.
+
+        Note, albeit the search criteria is similar to the one defined in
+            method 'get_subjects_metadata()' (see differences below), the
+            output is different as this method provides the sessions which
+            have a file that satisfy all the conditions of the search criteria.
+            This method is slow.
+
+        Parameters
+        ----------
+        search_criteria: dict
+            Each element is a string and is built using the formatting
+            "type;value", or "type;operation|value"
+
+        Complete search_criteria Dictionary Explanation:
+
+        search_criteria = {
+            "pars_patient_secret_name": "string;SUBJECTID",
+            "pars_ssid": "integer;OPERATOR|SSID",
+            "pars_modalities": "string;MODALITY",
+            "pars_tags": "tags;TAGS",
+            "pars_age_at_scan": "integer;OPERATOR|AGE_AT_SCAN",
+            "pars_[dicom]_KEY": "KEYTYPE;KEYVALUE",
+            "pars_PROJECTMETADATA": "METADATATYPE;METADATAVALUE",
+            }
+
+        Where:
+        "pars_patient_secret_name": Applies the search to the 'Subject ID'.
+        SUBJECTID is a comma separated list of strings.
+        "pars_ssid": Applies the search to the 'Session ID'.
+        SSID is an integer.
+        OPERATOR is the operator to apply. One of:
+            - Equal: eq
+            - Different Than: ne
+            - Greater Than: gt
+            - Greater/Equal To: gte
+            - Lower Than: lt
+            - Lower/Equal To: lte
+
+        "pars_modalities": Applies the search to the file 'Modalities'
+            available within each Subject ID.
+        MODALITY is a string.
+        "pars_tags": Applies only the search to the file 'Tags' available
+            within each Subject ID.
+        TAGS is a comma separated list of strings. All tags must be present in
+            the same file.
+        "pars_age_at_scan": Applies the search to the 'age_at_scan' metadata
+            field.
+        AGE_AT_SCAN is an integer.
+        "pars_[dicom]_KEY": Applies the search to the metadata fields
+            available within each file. KEY must be one of the
+        metadata keys of the files. The full list of KEYS is shown above via
+            'file_m["metadata"]["info"].keys()'.  # TODO: SEE HOW TO WRITE THIS
+        KEYTYPE is the type of the KEY. One of:
+            - integer
+            - decimal
+            - string
+            - list
+
+            if 'integer' or 'decimal' you must also include an OPERATOR
+                (i.e., "integer;OPERATOR|KEYVALUE").
+            if 'list' the KEYVALUE should be a semicolon separated list of
+                values. (i.e., "list;KEYVALUE1;KEYVALUE2;KEYVALUE3)
+                KEYVALUEs must be strings.
+        KEYVALUE is the expected value of the KEY.
+        "pars_[dicom]_PROJECTMETADATA": Applies to the metadata defined
+            within the 'Metadata Manager' of the project.
+        PROJECTMETADATA is the ID of the metadata field.
+        METADATATYPE is the type of the metadata field. One of:
+            - string
+            - integer
+            - list
+            - decimal
+            - single_option
+            - multiple_option
+
+            if 'integer' or 'decimal' you must also include an OPERATOR
+                (i.e., "integer;OPERATOR|METADATAVALUE").
+        KEYVALUE is the expected value of the metadata.
+
+        1) Example:
+        search_criteria = {
+            "pars_patient_secret_name": "string;abide",
+            "pars_ssid": "integer;eq|2"
+        }
+
+        2) Example:
+        search_criteria = {
+            "pars_patient_secret_name": "string;001"
+            "pars_modalities": "string;T2",
+            "pars_tags": "tags;flair",
+            "pars_[dicom]_Manufacturer": "string;ge",
+            "pars_[dicom]_FlipAngle": "integer;gt|5",
+            "pars_[dicom]_ImageType": "list;PRIMARY;SECONDARY",
+        }
+
+        Note the search criteria might apply to both the files metadata
+            information available within a session and the metadata of the
+            session. And the method provides a session only if all the file
+            related conditions are satisfied within the same file.
+            In example 2) above, it means that the output will contain any
+            session whose Subject ID contains '001', and there is a file with
+            modality 'T2', tag 'flair', FlipAngle greater than 5º, and
+            ImageType with both values PRIMARY and SECONDARY.
+            Further, the acquisition had to be performed in a Manufacturer
+            containing 'ge'.
+
+        Returns
+        -------
+        dict
+            A list of dictionary of {"metadata_name": "metadata_value"}
+
+        """
+
+        content = self.get_subjects_metadata(search_criteria, items=(0, 9999))
+
+        # Wrap search criteria.
+        modality, tags, dicoms = wrap_search_criteria(search_criteria)
+
+        # Iterate over the files of each subject selected to include/exclude
+        # 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"]))}
+                ))
+
+            for file in files["meta"]:
+                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)
+                        d_operator = dict_value["operation"]
+                        d_value = dict_value["value"]
+                        result_values.append(
+                            operation(d_value, d_operator, f_value)
+                        )
+
+                    if not all(result_values):
+                        continue
+                subjects.append(subject)
+                break
+        return subjects
+
     @property
     def subjects(self):
         """
@@ -321,10 +615,14 @@ class Project:
     @property
     def metadata_parameters(self):
         """
-        List all the parameters in the subject metadata.
+        List all the parameters in the subject-level metadata.
 
-        Each project has a set of parameters that define the subjects metadata.
-        This function returns all these parameters and its properties.
+        Each project has a set of parameters that define the subjects-level
+        metadata. This function returns all these parameters and its
+        properties. New subject-level metadata parameters can be creted in the
+        QMENTA Platform via the Metadata Manager. The API only allow
+        modification of these subject-level metadata parameters via the
+        'change_subject_metadata()' method.
 
         Returns
         -------
@@ -339,83 +637,29 @@ 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):
-        """
-        Add a metadata parameter to the project.
-
-        Parameters
-        ----------
-        title : str
-            Identifier of this new parameter
-        param_id : str
-            Title of this new parameter
-        param_type : str
-            Type of the parameter. One of:
-            "integer", "date", "string", "list", "decimal"
-        visible : bool
-            whether the parameter will be visible in the table of patients
-
-        Returns
-        -------
-        bool
-            True if parameter was correctly added, False otherwise.
-        """
-        # use param_id equal to title if param_id is not provided
-        param_id = param_id or title
-
-        param_properties = [title, param_id, param_type, str(int(visible))]
-
-        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
-            ))
-        except errors.PlatformError:
-            answer = {}
-
-        if title not in answer:
-            logger.error(f"Could not add new parameter: {title}")
-            return False
-
-        logger.info("New parameter added:", title, param_properties)
-        return True
-
     def get_analysis(self, analysis_name_or_id):
         if isinstance(analysis_name_or_id, int):
             search_tag = "id"
         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 +699,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 +716,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 +747,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 +789,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 +827,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 +844,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 +875,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 +928,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 +953,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 +966,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 +993,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,48 +1039,11 @@ 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
 
-    def add_subject(self, subject):
-        """
-        Add a subject to the project.
-
-        Parameters
-        ----------
-        subject : Subject
-            Instance of Subject representing the subject to add.
-
-        Returns
-        -------
-        bool
-            True if correctly added, False otherwise
-        """
-        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!")
-            return False
-
-        try:
-            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))
-        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 +1078,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 +1121,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 +1150,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 +1196,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 +1230,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 +1241,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 +1286,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 +1318,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 +1400,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 +1417,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 +1457,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 +1518,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 +1562,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 +1574,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 +1632,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 +1664,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 +1676,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 +1704,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 +1735,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 +1747,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 +1795,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 +1813,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 +1832,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 +1887,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 +1897,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