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

qmenta/client/Project.py

@@ -11,7 +11,6 @@ from enum import Enum
 from qmenta.client import Account
 from qmenta.core import errors
 from qmenta.core import platform
-from .Subject import Subject
 
 if sys.version_info[0] == 3:
     # Note: this branch & variable is only needed for python 2/3 compatibility
@@ -23,7 +22,8 @@ logger_name = "qmenta.client"
 def show_progress(done, total, finish=False):
     bytes_in_mb = 1024 * 1024
     progress_message = "\r[{:.2f} %] Uploaded {:.2f} of {:.2f} Mb".format(
-        done / float(total) * 100, done / bytes_in_mb, total / bytes_in_mb)
+        done / float(total) * 100, done / bytes_in_mb, total / bytes_in_mb
+    )
     sys.stdout.write(progress_message)
     sys.stdout.flush()
     if not finish:
@@ -72,6 +72,7 @@ class QCStatus(Enum):
     Enum with the following options:
     FAIL, PASS
     """
+
     PASS = "pass"
     FAIL = "fail"
 
@@ -95,15 +96,11 @@ class Project:
         # project id (int)
         if isinstance(project_id, str):
             project_name = project_id
-            project_id = next(iter(filter(
-                lambda proj: proj["name"] == project_id, account.projects)
-            ))["id"]
+            project_id = next(iter(filter(lambda proj: proj["name"] == project_id, account.projects)))["id"]
         else:
             if isinstance(project_id, float):
                 project_id = int(project_id)
-            project_name = next(iter(filter(
-                lambda proj: proj["id"] == project_id, account.projects)
-            ))["name"]
+            project_name = next(iter(filter(lambda proj: proj["id"] == project_id, account.projects)))["name"]
 
         self._account = account
         self._project_id = project_id
@@ -134,11 +131,11 @@ class Project:
         """
         logger = logging.getLogger(logger_name)
         try:
-            platform.parse_response(platform.post(
-                self._account.auth,
-                "projectset_manager/activate_project",
-                data={"project_id": int(project_id)}
-            ))
+            platform.parse_response(
+                platform.post(
+                    self._account.auth, "projectset_manager/activate_project", data={"project_id": int(project_id)}
+                )
+            )
         except errors.PlatformError:
             logger.error("Unable to activate the project.")
             return False
@@ -161,45 +158,139 @@ class Project:
         dict
             A list of dictionary of {"metadata_name": "metadata_value"}
         """
-        return self.get_subjects_metadata(cache=False)
+        return self.get_subjects_metadata()
 
-    def get_subjects_metadata(self, cache=True, search_criteria=None):
+    def get_subjects_metadata(self, search_criteria={}, items=(0, 9999)):
         """
-        List all subject data from the selected project.
+        List all subjects data from the selected project that meet the defined
+            search criteria.
+
         Parameters
         ----------
-        cache: bool
-            Whether to use the cached metadata or not
-
         search_criteria: dict
             Each element is a string and is built using the formatting
-        "type;value", or "type;operation|value"
+            "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 comma separated list of string.
+        "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.
+        "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()'.
+        KEYTYPE is the type of the KEY. One of:
+            - integer
+            - string
+            - list
+
+            if 'integer' you must also include an OPERATOR
+                (i.e., "integer;OPERATOR|KEYVALUE").
+        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_modalities": "string;T1",
+            "pars_tags": "tags;flair",
+            "pars_[dicom]_Manufacturer": "string;ge",
+            "pars_[dicom]_FlipAngle": "integer;gt|5",
+        }
 
-        Example:
-        search_criteria = {"pars_patient_secret_name": "string;abide",
-        "pars_ssid": "integer;eq|2"}
+        Note the search criteria applies to all the files included within a
+            session. Hence, it does not imply that all the criteria conditions
+            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.
 
         Returns
         -------
         dict
             A list of dictionary of {"metadata_name": "metadata_value"}
+
         """
 
-        if not cache or not self._subjects_metadata:
-            content = platform.parse_response(platform.post(
-                self._account.auth, "patient_manager/get_patient_list",
+        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_'."
+        )
+
+        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": "items=0-9999"}
-            ))
-            self._subjects_metadata = content
-        else:
-            content = self._subjects_metadata
+                headers={"X-Range": f"items={items[0]}-{items[1]}"},
+            )
+        )
         return content
 
     @property
     def subjects(self):
         """
-        Return the list of subject names from the selected project.
+        Return the list of subject names (Subject ID) from the selected
+        project.
 
         :return: a list of subject names
         :rtype: List(Strings)
@@ -211,12 +302,13 @@ class Project:
 
     def check_subject_name(self, subject_name):
         """
-        Check if a given subject name exists in the selected project.
+        Check if a given subject name (Subject ID) exists in the selected
+        project.
 
         Parameters
         ----------
         subject_name : str
-            name of the subject to check
+            Subject ID of the subject to check
 
         Returns
         -------
@@ -247,16 +339,13 @@ class Project:
         """
         logger = logging.getLogger(logger_name)
         try:
-            data = platform.parse_response(platform.post(
-                self._account.auth, "patient_manager/module_config"
-            ))
+            data = platform.parse_response(platform.post(self._account.auth, "patient_manager/module_config"))
         except errors.PlatformError:
             logger.error("Could not retrieve metadata parameters.")
             return None
         return data["fields"]
 
-    def add_metadata_parameter(self, title, param_id=None,
-                               param_type="string", visible=False):
+    def add_metadata_parameter(self, title, param_id=None, param_type="string", visible=False):
         """
         Add a metadata parameter to the project.
 
@@ -282,18 +371,13 @@ class Project:
 
         param_properties = [title, param_id, param_type, str(int(visible))]
 
-        post_data = {"add": "|".join(param_properties),
-                     "edit": "",
-                     "delete": ""
-                     }
+        post_data = {"add": "|".join(param_properties), "edit": "", "delete": ""}
 
         logger = logging.getLogger(logger_name)
         try:
-            answer = platform.parse_response(platform.post(
-                self._account.auth,
-                "patient_manager/save_metadata_changes",
-                data=post_data
-            ))
+            answer = platform.parse_response(
+                platform.post(self._account.auth, "patient_manager/save_metadata_changes", data=post_data)
+            )
         except errors.PlatformError:
             answer = {}
 
@@ -310,20 +394,17 @@ class Project:
         elif isinstance(analysis_name_or_id, str):
             search_tag = "p_n"
         else:
-            raise Exception("The analysis identifier must be its name or an "
-                            "integer")
+            raise Exception("The analysis identifier must be its name or an " "integer")
 
         search_condition = {
             search_tag: analysis_name_or_id,
         }
-        response = platform.parse_response(platform.post(
-            self._account.auth, "analysis_manager/get_analysis_list",
-            data=search_condition
-        ))
+        response = platform.parse_response(
+            platform.post(self._account.auth, "analysis_manager/get_analysis_list", data=search_condition)
+        )
 
         if len(response) > 1:
-            raise Exception(f"multiple analyses with name "
-                            f"{analysis_name_or_id} found")
+            raise Exception(f"multiple analyses with name " f"{analysis_name_or_id} found")
         elif len(response) == 1:
             return response[0]
         else:
@@ -363,10 +444,8 @@ class Project:
         dict
             List of analysis, each a dictionary
         """
-        assert len(items) == 2, f"The number of elements in items " \
-            f"'{len(items)}' should be equal to two."
-        assert all([isinstance(item, int) for item in items]), \
-            f"All items elements '{items}' should be integers."
+        assert len(items) == 2, f"The number of elements in items " f"'{len(items)}' should be equal to two."
+        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
         search_keys = {
             "p_n": str,
             "type": str,
@@ -382,70 +461,90 @@ 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
-        ))
-
-    def get_container(self, subject_name):
-        search_condition = {
-            "s_n": subject_name,
-        }
-        response = self.list_input_containers(
-            search_condition=search_condition
+        return platform.parse_response(
+            platform.post(
+                auth=self._account.auth,
+                endpoint="analysis_manager/get_analysis_list",
+                headers=req_headers,
+                data=search_condition,
+            )
         )
 
-        if len(response) > 1:
-            raise Exception(f"multiple containers for subject {subject_name} "
-                            f"found")
-        elif len(response) == 1:
-            return response[0]
-        else:
-            return None
+    def get_subject_container_id(self, subject_name, ssid):
+        """
+        Given a Subject ID and Session ID, return its Container ID.
+
+        Parameters
+        ----------
+        subject_name : str
+            Subject ID of the subject in the project.
+        ssid : str
+            Session ID of the subject in the project.
+
+        Returns
+        -------
+        int or bool
+            The Container ID of the subject in the project, or False if
+            the subject is not found.
+        """
+
+        search_criteria = {"s_n": subject_name, "ssid": ssid}
+        response = self.list_input_containers(search_criteria=search_criteria)
 
-    def list_input_containers(self, search_condition=None, limit=1000):
+        for subject in response:
+            if subject["patient_secret_name"] == subject_name and subject["ssid"] == ssid:
+                return subject["container_id"]
+        return False
+
+    def list_input_containers(self, search_criteria={}, items=(0, 9999)):
         """
-        List the containers available to the user.
+        Retrieve the list of input containers available to the user under a
+        certain search criteria.
 
         Parameters
         ----------
-        search_condition : dict
-            d_n: container_name
-            s_n: subject_id
-            from_d: from date
-            to_d: to date
-            sets: data sets (modalities)
-        limit : int
-            Max number of results
+        search_criteria : dict
+            Each element is a string and is built using the formatting
+        "type;value".
+
+        List of possible keys:
+        d_n: container_name # TODO: WHAT IS THIS???
+        s_n: subject_id
+            Subject ID of the subject in the platform.
+        ssid: session_id
+            Session ID of the subejct in the platform.
+        from_d: from date
+            Starting date in which perform the search. Format: DD.MM.YYYY
+        to_d: to date
+            End date in which perform the search. Format: DD.MM.YYYY
+        sets: data sets (modalities)  # TODO: WHAT IS THIS???
+
+        items: Tuple(int, int)
+            Starting and ending element of the search.
 
         Returns
         -------
         dict
-            List of containers, each a dictionary
-            {"name": "container-name", "id": "container_id"}
+        List of containers, each a dictionary containing the following
+        information:
+            {"container_name", "container_id", "patient_secret_name", "ssid"}
         """
 
-        req_headers = {"X-Range": "items=0-" + str(limit - 1)}
-        response = platform.parse_response(platform.post(
-            self._account.auth, "file_manager/get_container_list",
-            data=search_condition, headers=req_headers
-        ))
+        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]}"},
+            )
+        )
         containers = [
             {
                 "patient_secret_name": container_item["patient_secret_name"],
@@ -473,8 +572,7 @@ class Project:
             {"name": "container-name", "id": "container_id"}
         """
         analysis = self.list_analysis(limit)
-        return [{"name": a["name"],
-                 "id": a["out_container_id"]} for a in analysis]
+        return [{"name": a["name"], "id": a["out_container_id"]} for a in analysis]
 
     def list_container_files(self, container_id):
         """
@@ -491,10 +589,11 @@ class Project:
             List of file names (strings)
         """
         try:
-            content = platform.parse_response(platform.post(
-                self._account.auth, "file_manager/get_container_files",
-                data={"container_id": container_id}
-            ))
+            content = platform.parse_response(
+                platform.post(
+                    self._account.auth, "file_manager/get_container_files", data={"container_id": container_id}
+                )
+            )
         except errors.PlatformError as e:
             logging.getLogger(logger_name).error(e)
             return False
@@ -521,10 +620,11 @@ class Project:
         """
 
         try:
-            data = platform.parse_response(platform.post(
-                self._account.auth, "file_manager/get_container_files",
-                data={"container_id": container_id}
-            ))
+            data = platform.parse_response(
+                platform.post(
+                    self._account.auth, "file_manager/get_container_files", data={"container_id": container_id}
+                )
+            )
         except errors.PlatformError as e:
             logging.getLogger(logger_name).error(e)
             return False
@@ -545,12 +645,15 @@ class Project:
         Returns
         -------
         dict
-            Dictionary with the metadata.
+            Dictionary with the metadata. False otherwise.
         """
         all_metadata = self.list_container_files_metadata(container_id)
-        for file_meta in all_metadata:
-            if file_meta["name"] == filename:
-                return file_meta
+        if all_metadata:
+            for file_meta in all_metadata:
+                if file_meta["name"] == filename:
+                    return file_meta
+        else:
+            return False
 
     def change_file_metadata(self, container_id, filename, modality, tags):
         """
@@ -570,18 +673,15 @@ class Project:
         """
 
         tags_str = "" if tags is None else ";".join(tags)
-        platform.parse_response(platform.post(
-            self._account.auth, "file_manager/edit_file",
-            data={
-                "container_id": container_id,
-                "filename": filename,
-                "tags": tags_str,
-                "modality": modality
-            }
-        ))
+        platform.parse_response(
+            platform.post(
+                self._account.auth,
+                "file_manager/edit_file",
+                data={"container_id": container_id, "filename": filename, "tags": tags_str, "modality": modality},
+            )
+        )
 
-    def download_file(self, container_id, file_name, local_filename=False,
-                      overwrite=False):
+    def download_file(self, container_id, file_name, local_filename=False, overwrite=False):
         """
         Download a single file from a  specific container.
 
@@ -598,8 +698,7 @@ class Project:
         """
         logger = logging.getLogger(logger_name)
         if file_name not in self.list_container_files(container_id):
-            msg = (f"File \"{file_name}\" does not exist in container "
-                   f"{container_id}")
+            msg = f'File "{file_name}" does not exist in container ' f"{container_id}"
             logger.error(msg)
             return False
 
@@ -612,22 +711,18 @@ class Project:
 
         params = {"container_id": container_id, "files": file_name}
 
-        with platform.post(self._account.auth, "file_manager/download_file",
-                           data=params, stream=True) as response, \
-                open(local_filename, "wb") as f:
+        with platform.post(
+            self._account.auth, "file_manager/download_file", data=params, stream=True
+        ) as response, open(local_filename, "wb") as f:
 
-            for chunk in response.iter_content(chunk_size=2 ** 9 * 1024):
+            for chunk in response.iter_content(chunk_size=2**9 * 1024):
                 f.write(chunk)
             f.flush()
 
-        logger.info(
-            f"File {file_name} from container {container_id} saved to"
-            f" {local_filename}"
-        )
+        logger.info(f"File {file_name} from container {container_id} saved to" f" {local_filename}")
         return True
 
-    def download_files(self, container_id, filenames, zip_name="files.zip",
-                       overwrite=False):
+    def download_files(self, container_id, filenames, zip_name="files.zip", overwrite=False):
         """
         Download a set of files from a given container.
 
@@ -643,46 +738,43 @@ 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, cache=False):
+    def get_subject_id(self, subject_name, ssid):
         """
-        Given a subject name, return its ID in the project.
+        Given a Subject ID and Session ID, return its Patient ID in the
+        project.
 
         Parameters
         ----------
         subject_name : str
-            Name of the subject in the project.
-        cache : bool
-            Whether to use the cached metadata or not
+            Subject ID of the subject in the project.
+        ssid : str
+            Session ID of the subject in the project.
 
         Returns
         -------
@@ -691,37 +783,11 @@ class Project:
             the subject is not found.
         """
 
-        for user in self.get_subjects_metadata(cache):
-            if user["patient_secret_name"] == subject_name:
+        for user in self.get_subjects_metadata():
+            if user["patient_secret_name"] == str(subject_name) and user["ssid"] == str(ssid):
                 return int(user["_id"])
         return False
 
-    def get_subject(self, subject_name, cache=True):
-        """
-        Return a subject object, representing a subject from the project.
-
-        Parameters
-        ----------
-        subject_name : str
-            Name of the subject.
-        cache: bool
-            Whether to use the cached metadata or not
-
-        Returns
-        -------
-        Subject or bool
-            A Subject instance representing the desired subject, or
-            False if the subject was not found.
-
-        """
-        subject_id = self.get_subject_id(subject_name, cache=cache)
-        if subject_id is False:
-            return False
-        subj = Subject(subject_name)
-        subj.subject_id = subject_id
-        subj.project = self
-        return subj
-
     def add_subject(self, subject):
         """
         Add a subject to the project.
@@ -738,37 +804,119 @@ class Project:
         """
         logger = logging.getLogger(logger_name)
         if self.check_subject_name(subject.name):
-            logger.error(f"Subject with name {subject.name} already exists in "
-                         f"project!")
+            logger.error(f"Subject with name {subject.name} already exists in " f"project!")
             return False
 
         try:
-            platform.parse_response(platform.post(
-                self._account.auth, "patient_manager/upsert_patient",
-                data={"secret_name": subject.name}
-            ))
+            platform.parse_response(
+                platform.post(self._account.auth, "patient_manager/upsert_patient", data={"secret_name": subject.name})
+            )
         except errors.PlatformError:
             logger.error(f"Subject {subject.name} could not be created.")
             return False
 
         subject.subject_id = self.get_subject_id(subject.name)
         subject.project = self
-        logger.info(
-            "Subject {0} was successfully created".format(subject.name))
+        logger.info("Subject {0} was successfully created".format(subject.name))
+        return True
+
+    def change_subject_metadata(self, patient_id, subject_name, ssid, tags, age_at_scan, metadata):
+        """
+        Change the Subject ID, Session ID, Tags, Age at Scan and Metadata of
+        the session with Patient ID
+
+        Parameters
+        ----------
+        patient_id : Integer
+            Patient ID representing the session to modify.
+        subject_name : String
+            Represents the new Subject ID.
+        ssid : String
+            Represents the new Session ID.
+        tags : list of strings in lowercase
+            Represents the new tags of the session.
+        age_at_scan : Integer
+            Represents the new Age at Scan of the Session.
+        metadata : Dictionary
+            Each pair key/value representing the new metadata values.
+
+            The keys must either all start with "md\\_" or none start
+            with "md\\_".
+
+            The key represents the ID of the metadata field.
+
+        Returns
+        -------
+        bool
+            True if correctly modified, False otherwise
+        """
+        logger = logging.getLogger(logger_name)
+
+        try:
+            patient_id = str(int(patient_id))
+        except ValueError:
+            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."
+        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."
+
+        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.")
+
+        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."
+        )
+
+        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 "
+            f"interface (GUI)."
+        )
+
+        post_data = {
+            "patient_id": patient_id,
+            "secret_name": str(subject_name),
+            "ssid": str(ssid),
+            "tags": ",".join(tags),
+            "age_at_scan": age_at_scan,
+        }
+        for key, value in metadata.items():
+            id = key[3:] if "md_" == key[:3] else key
+            post_data[f"last_vals.{id}"] = value
+
+        try:
+            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
+
+        logger.info(f"Patient ID '{patient_id}' successfully modified.")
         return True
 
-    def delete_session(self, subject_name, session_id, cache=False):
+    def delete_session(self, subject_name, session_id):
         """
-        Delete a session from a subject within a project.
+        Delete a session from a subject within a project providing the
+        Subject ID and Session ID.
 
         Parameters
         ----------
         subject_name : str
-            Name of the subject
+            Subject ID of the subject
         session_id : int
-            The SSID of the session that will be deleted
-        cache : bool
-            Whether to use the cached metadata or not
+            The Session ID of the session that will be deleted
 
         Returns
         -------
@@ -776,58 +924,78 @@ class Project:
             True if correctly deleted, False otherwise.
         """
         logger = logging.getLogger(logger_name)
-        all_sessions = self.get_subjects_metadata(cache)
+        all_sessions = self.get_subjects_metadata()
 
-        sessions_to_del = [
-            s for s in all_sessions if
-            s["patient_secret_name"] == subject_name and int(
-                s["ssid"]
-            ) == session_id
+        session_to_del = [
+            s for s in all_sessions if s["patient_secret_name"] == subject_name and s["ssid"] == session_id
         ]
 
-        if not sessions_to_del:
-            logger.error(
-                f"Session {subject_name}/{session_id} could not be found "
-                f"in this project."
-            )
+        if not session_to_del:
+            logger.error(f"Session {subject_name}/{session_id} could not be found " f"in this project.")
             return False
-        elif len(sessions_to_del) > 1:
-            raise RuntimeError(
-                "Multiple sessions with same SID and SSID. Contact support."
-            )
+        elif len(session_to_del) > 1:
+            raise RuntimeError("Multiple sessions with same Subject ID and Session ID." " Contact support.")
         else:
-            logger.info("{}/{} found (id {})".format(
-                subject_name, session_id, sessions_to_del[0]["_id"]
-            ))
+            logger.info("{}/{} found (id {})".format(subject_name, session_id, session_to_del[0]["_id"]))
 
-        session = sessions_to_del[0]
+        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):
+        """
+        Delete a session from a subject within a project providing the
+        Patient ID.
+
+        Parameters
+        ----------
+        patient_id : str
+            Patient ID of the Session ID/Subject ID
+
+        Returns
+        -------
+        bool
+            True if correctly deleted, False otherwise.
+        """
+        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},
+                )
+            )
+        except errors.PlatformError:
+            logger.error(f"Patient ID {patient_id} could not be deleted.")
+            return False
+
+        logger.info(f"Patient ID {patient_id} successfully deleted.")
         return True
 
     def delete_subject(self, subject_name):
         """
-        Delete a subject from the project.
+        Delete a subject from the project. It deletes all its available
+        sessions only providing the Subject ID.
 
         Parameters
         ----------
         subject_name : str
-            Name of the subject to be deleted.
+            Subject ID of the subject to be deleted.
 
         Returns
         -------
@@ -837,34 +1005,38 @@ class Project:
 
         logger = logging.getLogger(logger_name)
         # Always fetch the session IDs from the platform before deleting them
-        all_sessions = self.get_subjects_metadata(False)
+        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]:
-            if not self.delete_session(subject_name, ssid, cache=True):
+            if not self.delete_session(subject_name, ssid):
                 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.
 
@@ -891,10 +1063,11 @@ class Project:
         """
 
         request_headers = {
-            "Content-Type": "application/zip", "Content-Range":
-                range_str, "Session-ID": str(session_id),
+            "Content-Type": "application/zip",
+            "Content-Range": range_str,
+            "Session-ID": str(session_id),
             "Content-Length": str(length),
-            "Content-Disposition": disposition
+            "Content-Disposition": disposition,
         }
 
         if last_chunk:
@@ -922,31 +1095,36 @@ 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 file to the platform, associated with the current user.
+        Upload a ZIP file to the platform.
 
         Parameters
         ----------
         file_path : str
-            Path to the file to upload.
+            Path to the ZIP file to upload.
         subject_name : str
-            Subject to which this file will belong
+            Subject ID of the data to upload in the project in QMENTA Platform.
         ssid : str
-            The ID of the timepoint
+            Session ID of the Subject ID (i.e., ID of the timepoint).
         date_of_scan : str
             Date of scan/creation of the file
         description : str
@@ -956,7 +1134,7 @@ class Project:
         name : str
             Name of the file in the platform
         input_data_type : str
-            mri_brain_data:1.0 or gametection:1.0
+            qmenta_medical_image_data:3.11
         add_to_container_id : int
             ID of the container to which this file should be added (if id > 0)
         chunk_size : int
@@ -999,8 +1177,7 @@ class Project:
             last_chunk = False
 
             if ssid and split_data:
-                logger.warning("split-data argument will be ignored because" +
-                               " ssid has been specified")
+                logger.warning("split-data argument will be ignored because" + " ssid has been specified")
                 split_data = False
 
             while True:
@@ -1017,16 +1194,27 @@ class Project:
                     end_position = total_bytes - 1
                     bytes_to_send = total_bytes - uploaded_bytes
 
-                bytes_range = "bytes " + str(start_position) + "-" + \
-                              str(end_position) + "/" + str(total_bytes)
+                bytes_range = "bytes " + str(start_position) + "-" + str(end_position) + "/" + str(total_bytes)
 
                 dispstr = f"attachment; filename={filename}"
                 response = self._upload_chunk(
-                    data, bytes_range, bytes_to_send, session_id, dispstr,
+                    data,
+                    bytes_range,
+                    bytes_to_send,
+                    session_id,
+                    dispstr,
                     last_chunk,
-                    name, date_of_scan, description, subject_name, ssid,
-                    filename, input_data_type, result, add_to_container_id,
-                    split_data)
+                    name,
+                    date_of_scan,
+                    description,
+                    subject_name,
+                    ssid,
+                    filename,
+                    input_data_type,
+                    result,
+                    add_to_container_id,
+                    split_data,
+                )
 
                 if response is None:
                     retries_count += 1
@@ -1046,17 +1234,14 @@ class Project:
                     retries_count += 1
                     time.sleep(retries_count * 5)
                     if retries_count > self.max_retries:
-                        error_message = (
-                            "Error Code: 416; "
-                            "Requested Range Not Satisfiable (NGINX)")
+                        error_message = "Error Code: 416; " "Requested Range Not Satisfiable (NGINX)"
                         logger.error(error_message)
                         break
                 else:
                     retries_count += 1
                     time.sleep(retries_count * 5)
                     if retries_count > max_retries:
-                        error_message = ("Number of retries has been reached. "
-                                         "Upload process stops here !")
+                        error_message = "Number of retries has been reached. " "Upload process stops here !"
                         logger.error(error_message)
                         break
 
@@ -1110,9 +1295,7 @@ class Project:
         """
 
         if check_upload_file(file_path):
-            return self.upload_file(
-                file_path, subject_name,
-                input_data_type="parkinson_gametection")
+            return self.upload_file(file_path, subject_name, input_data_type="parkinson_gametection")
         return False
 
     def upload_result(self, file_path, subject_name):
@@ -1156,13 +1339,9 @@ class Project:
             p_id = int(project_id)
         elif type(project_id) == str:
             projects = self._account.projects
-            projects_match = [proj for proj in projects
-                              if proj["name"] == project_id]
+            projects_match = [proj for proj in projects if proj["name"] == project_id]
             if not projects_match:
-                raise Exception(
-                    f"Project {project_id}" +
-                    " does not exist or is not available for this user."
-                )
+                raise Exception(f"Project {project_id}" + " does not exist or is not available for this user.")
             p_id = int(projects_match[0]["id"])
         else:
             raise TypeError("project_id")
@@ -1172,30 +1351,26 @@ class Project:
         }
 
         try:
-            platform.parse_response(platform.post(
-                self._account.auth,
-                "file_manager/copy_container_to_another_project",
-                data=data
-            ))
-        except errors.PlatformError as e:
-            logging.getLogger(logger_name).error(
-                "Couldn not copy container: {}".format(e)
+            platform.parse_response(
+                platform.post(self._account.auth, "file_manager/copy_container_to_another_project", data=data)
             )
+        except errors.PlatformError as e:
+            logging.getLogger(logger_name).error("Couldn not copy container: {}".format(e))
             return False
 
         return True
 
     def start_analysis(
-            self,
-            script_name,
-            version,
-            in_container_id=None,
-            analysis_name=None,
-            analysis_description=None,
-            ignore_warnings=False,
-            settings=None,
-            tags=None,
-            preferred_destination=None
+        self,
+        script_name,
+        version,
+        in_container_id=None,
+        analysis_name=None,
+        analysis_description=None,
+        ignore_warnings=False,
+        settings=None,
+        tags=None,
+        preferred_destination=None,
     ):
         """
         Starts an analysis on a subject.
@@ -1234,13 +1409,9 @@ class Project:
         logger = logging.getLogger(logger_name)
 
         if in_container_id is None and settings is None:
-            raise ValueError(
-                "Pass a value for either in_container_id or settings.")
+            raise ValueError("Pass a value for either in_container_id or settings.")
 
-        post_data = {
-            "script_name": script_name,
-            "version": version
-        }
+        post_data = {"script_name": script_name, "version": version}
 
         settings = settings or {}
 
@@ -1270,9 +1441,7 @@ class Project:
             post_data["preferred_destination"] = preferred_destination
 
         logger.debug(f"post_data = {post_data}")
-        return self.__handle_start_analysis(
-            post_data, ignore_warnings=ignore_warnings
-        )
+        return self.__handle_start_analysis(post_data, ignore_warnings=ignore_warnings)
 
     def delete_analysis(self, analysis_id):
         """
@@ -1284,19 +1453,20 @@ class Project:
         logger = logging.getLogger(logger_name)
 
         try:
-            platform.parse_response(platform.post(
-                auth=self._account.auth,
-                endpoint="analysis_manager/delete_analysis",
-                data={"project_id": analysis_id}
-            ))
+            platform.parse_response(
+                platform.post(
+                    auth=self._account.auth,
+                    endpoint="analysis_manager/delete_analysis",
+                    data={"project_id": analysis_id},
+                )
+            )
         except errors.PlatformError as error:
             logger.error("Could not delete analysis: {}".format(error))
             return False
 
         return True
 
-    def __handle_start_analysis(self, post_data, ignore_warnings=False,
-                                n_calls=0):
+    def __handle_start_analysis(self, post_data, ignore_warnings=False, n_calls=0):
         """
         Handle the possible responses from the server after start_analysis.
         Sometimes we have to send a request again, and then check again the
@@ -1311,16 +1481,16 @@ class Project:
 
         logger = logging.getLogger(logger_name)
         if n_calls > call_limit:
-            logger.error(f"__handle_start_analysis_response called itself more\
-                          than {n_calls} times: aborting.")
+            logger.error(
+                f"__handle_start_analysis_response called itself more\
+                          than {n_calls} times: aborting."
+            )
             return None
 
         try:
-            response = platform.parse_response(platform.post(
-                self._account.auth,
-                "analysis_manager/analysis_registration",
-                data=post_data
-            ))
+            response = platform.parse_response(
+                platform.post(self._account.auth, "analysis_manager/analysis_registration", data=post_data)
+            )
             logger.info(response["message"])
             return int(response["analysis_id"])
         except platform.ChooseDataError as choose_data:
@@ -1342,8 +1512,7 @@ class Project:
                 chosen_files = {}
                 for settings_key in choose_data.data_to_choose:
                     chosen_files[settings_key] = {}
-                    filters = choose_data.data_to_choose[
-                        settings_key]["filters"]
+                    filters = choose_data.data_to_choose[settings_key]["filters"]
                     for filter_key in filters:
                         filter_data = filters[filter_key]
 
@@ -1355,35 +1524,24 @@ class Project:
                         if filter_data["range"][0] != 0:
                             number_of_files_to_select = filter_data["range"][0]
                         elif filter_data["range"][1] != 0:
-                            number_of_files_to_select = min(
-                                filter_data["range"][1],
-                                len(filter_data["files"])
-                            )
+                            number_of_files_to_select = min(filter_data["range"][1], len(filter_data["files"]))
                         else:
-                            number_of_files_to_select = len(
-                                filter_data["files"]
-                            )
+                            number_of_files_to_select = len(filter_data["files"])
 
-                        files_selection = [ff["_id"] for ff in
-                                           filter_data["files"]
-                                           [:number_of_files_to_select]]
-                        chosen_files[settings_key][filter_key] = \
-                            files_selection
+                        files_selection = [ff["_id"] for ff in filter_data["files"][:number_of_files_to_select]]
+                        chosen_files[settings_key][filter_key] = files_selection
 
                 new_post["user_preference"] = json.dumps(chosen_files)
             else:
                 if has_warning and not ignore_warnings:
-                    logger.info("cancelling analysis due to warnings, " +
-                                "set \"ignore_warnings\" to True to override")
+                    logger.info("cancelling analysis due to warnings, " + 'set "ignore_warnings" to True to override')
                     new_post["cancel"] = "1"
                 else:
                     logger.info("suppressing warnings")
                     new_post["user_preference"] = "{}"
                     new_post["_mint_only_warning"] = "1"
 
-            return self.__handle_start_analysis(
-                new_post, ignore_warnings=ignore_warnings, n_calls=n_calls
-            )
+            return self.__handle_start_analysis(new_post, ignore_warnings=ignore_warnings, n_calls=n_calls)
         except platform.ActionFailedError as e:
             logger.error(f"Unable to start the analysis: {e}")
             return None
@@ -1414,19 +1572,15 @@ class Project:
         logger = logging.getLogger(__name__)
         logger.info(f"Setting QC status to {status}: {comments}")
 
-        platform.parse_response(platform.post(
-            auth=self._account.auth,
-            endpoint="projectset_manager/set_qa_status",
-            data={
-                "item_ids": analysis_id,
-                "status": status.value,
-                "comments": comments,
-                "entity": "analysis"
-            }
-        ))
+        platform.parse_response(
+            platform.post(
+                auth=self._account.auth,
+                endpoint="projectset_manager/set_qa_status",
+                data={"item_ids": analysis_id, "status": status.value, "comments": comments, "entity": "analysis"},
+            )
+        )
 
-    def get_qc_status(
-            self, patient_secret_name=None, ssid=None, analysis_id=None):
+    def get_qc_status(self, patient_secret_name=None, ssid=None, analysis_id=None):
         """
         Gets the session QC status of a session. If the analysis_id is
         specified, it returns the QC of the
@@ -1436,17 +1590,15 @@ class Project:
         if patient_secret_name and ssid:
             session = self.get_subjects_metadata(
                 search_criteria={
-                    "pars_patient_secret_name": f"string;"
-                                                f"{patient_secret_name}",
-                    "pars_ssid": f"integer;eq|{ssid}"
+                    "pars_patient_secret_name": f"string;" f"{patient_secret_name}",
+                    "pars_ssid": f"integer;eq|{ssid}",
                 }
             )
             to_return = session["qa_status"], session["qa_comments"]
         elif analysis_id:
             try:
                 to_return = [
-                    analysis["qa_data"] for analysis in self.list_analysis()
-                    if analysis["_id"] == analysis_id
+                    analysis["qa_data"] for analysis in self.list_analysis() if analysis["_id"] == analysis_id
                 ][0]
                 to_return = to_return["qa_status"], to_return["qa_comments"]
             except IndexError:
@@ -1457,22 +1609,21 @@ class Project:
                 print(f"An error occurred: {e}")
                 to_return = None
         else:
-            raise Exception(f"Must specify {patient_secret_name} and "
-                            f"{ssid} or {analysis_id}.")
+            raise Exception(f"Must specify {patient_secret_name} and {ssid} or {analysis_id}.")
         return to_return
 
     def start_multiple_analyses(
-            self,
-            script_name,
-            version,
-            n_times,
-            in_container_id=None,
-            analysis_name=None,
-            analysis_description=None,
-            ignore_warnings=False,
-            settings=None,
-            tags=None,
-            preferred_destination=None
+        self,
+        script_name,
+        version,
+        n_times,
+        in_container_id=None,
+        analysis_name=None,
+        analysis_description=None,
+        ignore_warnings=False,
+        settings=None,
+        tags=None,
+        preferred_destination=None,
     ):
         """
         Starts multiple times the same analysis on a subject with the same
@@ -1513,9 +1664,7 @@ class Project:
         """
         logger = logging.getLogger(logger_name)
         for n in range(n_times):
-            logger.info(
-                f"Running tool {script_name}:{version} {n + 1}/{n_times}"
-            )
+            logger.info(f"Running tool {script_name}:{version} {n + 1}/{n_times}")
             yield self.start_analysis(
                 script_name,
                 version,
@@ -1525,5 +1674,40 @@ class Project:
                 ignore_warnings=ignore_warnings,
                 settings=settings,
                 tags=tags,
-                preferred_destination=preferred_destination
+                preferred_destination=preferred_destination,
             )
+
+    def set_project_qa_rules(self, rules_file_path, guidance_text=""):
+        """
+        Logs in to the Qmenta platform, retrieves the project ID based on the project name,
+        and updates the project's QA rules using the provided rules file.
+
+        Args:
+            rules_file_path (str): The file path to the JSON file containing the QA rules.
+            guidance_text (str): Description of the rules. Only visible for Platform admins.
+
+        Returns:
+            bool: True if the rules were set successfully, False otherwise.
+        """
+        # Read the rules from the JSON file
+        try:
+            with open(rules_file_path, "r") as fr:
+                rules = json.load(fr)
+        except FileNotFoundError:
+            print(f"ERROR: Rules file '{rules_file_path}' not found.")
+            return False
+
+        # Update the project's QA rules
+        res = platform.post(
+            auth=self._account.auth,
+            endpoint="projectset_manager/set_session_qa_requirements",
+            data={"project_id": self._project_id, "rules": json.dumps(rules), "guidance_text": guidance_text},
+        )
+
+        if res.json().get("success") == 1:
+            print("Rules set up successfully!")
+            return True
+        else:
+            print("ERROR setting the rules")
+            print(res.json())
+            return False