qmenta-client 1.1.dev1507__py3-none-any.whl → 2.1__py3-none-any.whl

qmenta/client/Project.py

@@ -9,9 +9,10 @@ import sys
 import time
 from collections import defaultdict
 from enum import Enum
-
+from typing import Any, Dict, Union
 from qmenta.core import errors
 from qmenta.core import platform
+from qmenta.core.upload.single import SingleUpload, FileInfo, UploadStatus
 
 from qmenta.client import Account
 
@@ -21,6 +22,17 @@ if sys.version_info[0] == 3:
 
 logger_name = "qmenta.client"
 OPERATOR_LIST = ["eq", "ne", "gt", "gte", "lt", "lte"]
+ANALYSIS_NAME_EXCLUDED_CHARACTERS = [
+    "\\",
+    "[",
+    "]",
+    "(",
+    ")",
+    "{",
+    "}",
+    "+",
+    "*",
+]
 
 
 def convert_qc_value_to_qcstatus(value):
@@ -46,7 +58,9 @@ def convert_qc_value_to_qcstatus(value):
     elif value == "":
         return QCStatus.UNDERTERMINED
     else:
-        logger.error(f"The input value '{value}' cannot be converted to class QCStatus.")
+        logger.error(
+            f"The input value '{value}' cannot be converted to class QCStatus."
+        )
         return False
 
 
@@ -84,11 +98,24 @@ 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
@@ -121,7 +148,9 @@ class Project:
         try:
             platform.parse_response(
                 platform.post(
-                    self._account.auth, "projectset_manager/activate_project", data={"project_id": int(project_id)}
+                    self._account.auth,
+                    "projectset_manager/activate_project",
+                    data={"project_id": int(project_id)},
                 )
             )
         except errors.PlatformError:
@@ -156,6 +185,7 @@ class Project:
         result=False,
         add_to_container_id=0,
         split_data=False,
+        mock_response=False,
     ):
         """
         Upload a chunk of a file to the platform.
@@ -189,6 +219,8 @@ class Project:
             "Content-Length": str(length),
             "Content-Disposition": disposition,
         }
+        if mock_response:
+            request_headers["mock_case"] = mock_response
 
         if last_chunk:
             request_headers["X-Mint-Name"] = name
@@ -215,9 +247,12 @@ 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(
@@ -229,10 +264,12 @@ class Project:
         description="",
         result=False,
         name="",
-        input_data_type="qmenta_medical_image_data:3.10",
+        input_data_type="qmenta_medical_image_data:3.11.3",
         add_to_container_id=0,
-        chunk_size=2**9,
+        chunk_size=2**24,  # Optimized for GCS Bucket Storage
+        max_retries=5,
         split_data=False,
+        mock_response=None,
     ):
         """
         Upload a ZIP file to the platform.
@@ -260,121 +297,81 @@ class Project:
         chunk_size : int
             Size in kB of each chunk. Should be expressed as
             a power of 2: 2**x. Default value of x is 9 (chunk_size = 512 kB)
+        max_retries: int
+            Maximum number of retries when uploading a file before raising
+            an error. Default value: 5
         split_data : bool
             If True, the platform will try to split the uploaded file into
             different sessions. It will be ignored when the ssid or a
             add_to_container_id are given.
+        mock_response: None
+            ONLY USED IN UNITTESTING
 
         Returns
         -------
         bool
             True if correctly uploaded, False otherwise.
         """
-        filename = os.path.split(file_path)[1]
-        input_data_type = "offline_analysis:1.0" if result else input_data_type
-
-        chunk_size *= 1024
-        max_retries = 10
-
-        name = name or os.path.split(file_path)[1]
+        input_data_type = (
+            "qmenta_upload_offline_analysis:1.0" if result else input_data_type
+        )
 
-        total_bytes = os.path.getsize(file_path)
+        single_upload = SingleUpload(
+            self._account.auth,
+            file_path,
+            file_info=FileInfo(
+                project_id=self._project_id,
+                subject_name=subject_name,
+                session_id=str(ssid),
+                input_data_type=input_data_type,
+                split_data=split_data,
+                add_to_container_id=add_to_container_id,
+                date_of_scan=date_of_scan,
+                description=description,
+                name=name,
+            ),
+            anonymise=False,  # will be anonymised in the upload tool.
+            chunk_size=chunk_size,
+            max_retries=max_retries,
+        )
 
-        split_data = self.__assert_split_data(split_data, ssid, add_to_container_id)
+        single_upload.start()
 
-        # making chunks of the file and sending one by one
-        logger = logging.getLogger(logger_name)
-        with open(file_path, "rb") as file_object:
+        if single_upload.status == UploadStatus.FAILED:  # FAILED
+            print("Upload Failed!")
+            return False
 
-            file_size = os.path.getsize(file_path)
-            if file_size == 0:
-                logger.error("Cannot upload empty file {}".format(file_path))
-                return False
-            uploaded = 0
-            session_id = self.__get_session_id(file_path)
-            chunk_num = 0
-            retries_count = 0
-            uploaded_bytes = 0
-            response = None
-            last_chunk = False
-
-            while True:
-                data = file_object.read(chunk_size)
-                if not data:
-                    break
-
-                start_position = chunk_num * chunk_size
-                end_position = start_position + chunk_size - 1
-                bytes_to_send = chunk_size
-
-                if end_position >= total_bytes:
-                    last_chunk = True
-                    end_position = total_bytes - 1
-                    bytes_to_send = total_bytes - uploaded_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,
-                    last_chunk,
-                    name,
-                    date_of_scan,
-                    description,
-                    subject_name,
-                    ssid,
-                    filename,
-                    input_data_type,
-                    result,
-                    add_to_container_id,
-                    split_data,
-                )
+        message = (
+            "Your data was successfully uploaded. "
+            "The uploaded file will be soon processed !"
+        )
+        print(message)
+        return True
 
-                if response is None:
-                    retries_count += 1
-                    time.sleep(retries_count * 5)
-                    if retries_count > max_retries:
-                        error_message = "HTTP Connection Problem"
-                        logger.error(error_message)
-                        break
-                elif int(response.status_code) == 201:
-                    chunk_num += 1
-                    retries_count = 0
-                    uploaded_bytes += chunk_size
-                elif int(response.status_code) == 200:
-                    self.__show_progress(file_size, file_size, finish=True)
-                    break
-                elif int(response.status_code) == 416:
-                    retries_count += 1
-                    time.sleep(retries_count * 5)
-                    if retries_count > self.max_retries:
-                        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 !"
-                        logger.error(error_message)
-                        break
+    def delete_file(self, container_id, filenames):
+        """
+        Delete a file or files from a container.
+        Can be an input or an output container
 
-                uploaded += chunk_size
-                self.__show_progress(uploaded, file_size)
+        Parameters
+        ----------
+        container_id : int
+        filenames : str or list of str
 
-        try:
-            platform.parse_response(response)
-        except errors.PlatformError as error:
-            logger.error(error)
-            return False
+        """
+        if not isinstance(filenames, str):
+            if isinstance(filenames, list):
+                if not all([isinstance(f, str) for f in filenames]):
+                    raise TypeError("Elements of `filenames` must be str")
+                filenames = ";".join(filenames)
+            else:
+                raise TypeError("`filenames` must be str or list of str")
 
-        message = "Your data was successfully uploaded. The uploaded file will be soon processed !"
-        logger.info(message)
-        return True
+        platform.post(
+            self._account.auth,
+            "file_manager/delete_files",
+            data={"container_id": container_id, "files": filenames},
+        )
 
     def upload_mri(self, file_path, subject_name):
         """
@@ -412,7 +409,11 @@ class Project:
         """
 
         if self.__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):
@@ -435,7 +436,9 @@ class Project:
             return self.upload_file(file_path, subject_name, result=True)
         return False
 
-    def download_file(self, container_id, file_name, local_filename=False, overwrite=False):
+    def download_file(
+        self, container_id, file_name, local_filename=None, overwrite=False
+    ):
         """
         Download a single file from a  specific container.
 
@@ -445,43 +448,57 @@ class Project:
             ID of the container inside which the file is.
         file_name : str
             Name of the file in the container.
-        local_filename : str
+        local_filename : str, optional
             Name of the file to be created. By default, the same as file_name.
         overwrite : bool
             Whether to overwrite the file if existing.
         """
         logger = logging.getLogger(logger_name)
         if not isinstance(file_name, str):
-            raise ValueError("The name of the file to download (file_name) should be of type string.")
-        if not isinstance(file_name, str):
-            raise ValueError("The name of the output file (local_filename) should be of type string.")
+            raise ValueError(
+                "The name of the file to download (file_name) should be of "
+                "type string."
+            )
+        if not isinstance(local_filename, str):
+            raise ValueError(
+                "The name of the output file (local_filename) should be of "
+                "type string."
+            )
 
         if file_name not in self.list_container_files(container_id):
-            msg = f'File "{file_name}" does not exist in container {container_id}'
-            logger.error(msg)
-            return False
+            msg = (
+                f'File "{file_name}" does not exist in container '
+                f"{container_id}"
+            )
+            raise Exception(msg)
 
         local_filename = local_filename or file_name
 
         if os.path.exists(local_filename) and not overwrite:
             msg = f"File {local_filename} already exists"
-            logger.error(msg)
-            return False
+            raise Exception(msg)
 
         params = {"container_id": container_id, "files": file_name}
-
         with platform.post(
-            self._account.auth, "file_manager/download_file", data=params, stream=True
+            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):
                 f.write(chunk)
             f.flush()
 
-        logger.info(f"File {file_name} from container {container_id} saved to {local_filename}")
+        logger.info(
+            f"File {file_name} from container {container_id} saved "
+            f"to {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.
 
@@ -499,32 +516,51 @@ class Project:
         logger = logging.getLogger(logger_name)
 
         if not all([isinstance(file_name, str) for file_name in filenames]):
-            raise ValueError("The name of the files to download (filenames) should be of type string.")
+            raise ValueError(
+                "The name of the files to download (filenames) should be "
+                "of type string."
+            )
         if not isinstance(zip_name, str):
-            raise ValueError("The name of the output ZIP file (zip_name) should be of type string.")
+            raise ValueError(
+                "The name of the output ZIP file (zip_name) should be "
+                "of type string."
+            )
 
-        files_not_in_container = list(filter(lambda f: f not in self.list_container_files(container_id), filenames))
+        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 {container_id}: {', '.join(files_not_in_container)}"
-            logger.error(msg)
-            return False
+            msg = (
+                f"The following files are missing in container "
+                f"{container_id}: {', '.join(files_not_in_container)}"
+            )
+            raise Exception(msg)
 
         if os.path.exists(zip_name) and not overwrite:
             msg = f'File "{zip_name}" already exists'
-            logger.error(msg)
-            return False
+            raise Exception(msg)
 
         params = {"container_id": container_id, "files": ";".join(filenames)}
         with platform.post(
-            self._account.auth, "file_manager/download_file", data=params, stream=True
+            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):
                 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 copy_container_to_project(self, container_id, project_id):
@@ -548,9 +584,14 @@ class Project:
             p_id = int(project_id)
         elif type(project_id) is 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")
@@ -561,10 +602,16 @@ class Project:
 
         try:
             platform.parse_response(
-                platform.post(self._account.auth, "file_manager/copy_container_to_another_project", data=data)
+                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))
+            logging.getLogger(logger_name).error(
+                "Couldn not copy container: {}".format(e)
+            )
             return False
 
         return True
@@ -598,7 +645,7 @@ class Project:
         return self.get_subjects_metadata()
 
     @property
-    def metadata_parameters(self):
+    def metadata_parameters(self) -> Union[Dict, None]:
         """
         List all the parameters in the subject-level metadata.
 
@@ -609,20 +656,28 @@ class Project:
         modification of these subject-level metadata parameters via the
         'change_subject_metadata()' method.
 
+        Example:
+        dictionary {"param_name":
+            { "order": Int,
+            "tags": [tag1, tag2, ..., ],
+            "title: "Title",
+            "type": "integer|string|date|list|decimal",
+            "visible": 0|1
+            }
+        }
+
         Returns
         -------
-        dict[str] -> dict[str] -> x
-            dictionary {"param_name":
-                 { "order": Int,
-                 "tags": [tag1, tag2, ..., ],
-                 "title: "Title",
-                 "type": "integer|string|date|list|decimal",
-                 "visible": 0|1
-                 }}
+        metadata_parameters : dict[str] or None
+
         """
         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
@@ -668,7 +723,10 @@ class Project:
         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
 
@@ -692,20 +750,25 @@ 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 get_subjects_metadata(self, search_criteria={}, items=(0, 9999)):
+    def get_subjects_metadata(self, search_criteria=None, items=(0, 9999)):
         """
         List all Subject ID/Session ID from the selected project that meet the
-            defined search criteria at a session level.
+        defined search criteria at a session level.
 
         Parameters
         ----------
         search_criteria: dict
             Each element is a string and is built using the formatting
             "type;value", or "type;operation|value"
+        items : List[int]
+            list containing two elements [min, max] that correspond to the
+            mininum and maximum range of analysis listed
 
         Complete search_criteria Dictionary Explanation:
 
@@ -719,8 +782,8 @@ class Project:
             "pars_PROJECTMETADATA": "METADATATYPE;METADATAVALUE",
             }
 
-        Where:
-        "pars_patient_secret_name": Applies the search to the 'Subject ID'.
+        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.
@@ -806,12 +869,26 @@ class Project:
 
         """
 
-        assert len(items) == 2, f"The number of elements in items '{len(items)}' should be equal to two."
-        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
+        if search_criteria is None:
+            search_criteria = {}
+        if len(items) != 2:
+            raise ValueError(
+                f"The number of elements in items '{len(items)}' "
+                f"should be equal to two."
+            )
 
-        assert all(
-            [key[:5] == "pars_" for key in search_criteria.keys()]
-        ), f"All keys of the search_criteria dictionary '{search_criteria.keys()}' must start with 'pars_'."
+        if not all([isinstance(item, int) for item in items]):
+            raise ValueError(
+                f"All values in items " f"'{items}' must be integers"
+            )
+
+        if search_criteria != {} and not all(
+            [item.startswith("pars_") for item in search_criteria.keys()]
+        ):
+            raise ValueError(
+                f"All keys of the search_criteria dictionary "
+                f"'{search_criteria.keys()}' must start with 'pars_'."
+            )
 
         for key, value in search_criteria.items():
             if value.split(";")[0] in ["integer", "decimal"]:
@@ -830,7 +907,9 @@ class Project:
         )
         return content
 
-    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
@@ -865,36 +944,60 @@ class Project:
         try:
             patient_id = str(int(patient_id))
         except ValueError:
-            raise ValueError(f"'patient_id': '{patient_id}' not valid. Must be convertible to int.")
+            raise ValueError(
+                f"'patient_id': '{patient_id}' not valid. Must be convertible "
+                f"to int."
+            )
 
-        assert isinstance(tags, list) and all(
+        if not isinstance(tags, list) or not all(
             isinstance(item, str) for item in tags
-        ), f"tags: '{tags}' should be a list of strings."
+        ):
+            raise ValueError(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."
+        if not isinstance(subject_name, str) or (
+            subject_name is None or subject_name == ""
+        ):
+            raise ValueError("subject_name must be a non empty string.")
+
+        if not isinstance(ssid, str) or (ssid is None or ssid == ""):
+            raise ValueError("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. 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 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)."
-        )
+            raise ValueError(
+                f"age_at_scan: '{age_at_scan}' not valid. Must be an integer."
+            )
+
+        if not isinstance(metadata, dict):
+            raise ValueError(f"metadata: '{metadata}' should be a dictionary.")
+
+        has_md_prefix = ["md_" == key[:3] for key in metadata.keys()]
+        if not (all(has_md_prefix) or not any(has_md_prefix)):
+            raise ValueError(
+                f"metadata: '{metadata}' must be a dictionary whose keys are "
+                f"either all starting with 'md_' or none."
+            )
+
+        metadata_keys = []
+        if self.metadata_parameters:
+            metadata_keys = self.metadata_parameters.keys()
+
+        if not all(
+            (
+                key[3:] in metadata_keys
+                if "md_" == key[:3]
+                else key in metadata_keys
+            )
+            for key in metadata.keys()
+        ):
+            raise ValueError(
+                f"Some metadata keys provided ({', '.join(metadata.keys())}) "
+                "are not available in the project. They can be added via the "
+                "Metadata Manager via the QMENTA Platform graphical user "
+                "interface (GUI)."
+            )
 
         post_data = {
             "patient_id": patient_id,
@@ -904,11 +1007,17 @@ class Project:
             "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
+            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))
+            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
@@ -916,7 +1025,9 @@ class Project:
         logger.info(f"Patient ID '{patient_id}' successfully modified.")
         return True
 
-    def get_subjects_files_metadata(self, search_criteria={}, items=(0, 9999)):
+    def get_subjects_files_metadata(
+        self, search_criteria=None, items=(0, 9999)
+    ):
         """
         List all Subject ID/Session ID from the selected project that meet the
             defined search criteria at a file level.
@@ -932,6 +1043,9 @@ class Project:
         search_criteria: dict
             Each element is a string and is built using the formatting
             "type;value", or "type;operation|value"
+        items : List[int]
+            list containing two elements [min, max] that correspond to the
+            mininum and maximum range of analysis listed
 
         Complete search_criteria Dictionary Explanation:
 
@@ -1034,10 +1148,14 @@ class Project:
 
         """
 
-        content = self.get_subjects_metadata(search_criteria, items=(0, 9999))
+        if search_criteria is None:
+            search_criteria = {}
+        content = self.get_subjects_metadata(search_criteria, items=items)
 
         # Wrap search criteria.
-        modality, tags, dicoms = self.__wrap_search_criteria(search_criteria)
+        modality, tags, dicom_metadata = self.__wrap_search_criteria(
+            search_criteria
+        )
 
         # Iterate over the files of each subject selected to include/exclude
         # them from the results.
@@ -1052,17 +1170,23 @@ class Project:
             )
 
             for file in files["meta"]:
-                if modality and modality != (file.get("metadata") or {}).get("modality"):
+                if modality and modality != (file.get("metadata") or {}).get(
+                    "modality"
+                ):
                     continue
                 if tags and not all([tag in file.get("tags") for tag in tags]):
                     continue
-                if dicoms:
+                if dicom_metadata:
                     result_values = list()
-                    for key, dict_value in dicoms.items():
-                        f_value = ((file.get("metadata") or {}).get("info") or {}).get(key)
+                    for key, dict_value in dicom_metadata.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(self.__operation(d_value, d_operator, f_value))
+                        result_values.append(
+                            self.__operation(d_value, d_operator, f_value)
+                        )
 
                     if not all(result_values):
                         continue
@@ -1083,7 +1207,7 @@ class Project:
 
         Returns
         -------
-        dict
+        dict or bool
             Dictionary with the metadata. False otherwise.
         """
         all_metadata = self.list_container_files_metadata(container_id)
@@ -1116,7 +1240,12 @@ class Project:
             platform.post(
                 self._account.auth,
                 "file_manager/edit_file",
-                data={"container_id": container_id, "filename": filename, "tags": tags_str, "modality": modality},
+                data={
+                    "container_id": container_id,
+                    "filename": filename,
+                    "tags": tags_str,
+                    "modality": modality,
+                },
             )
         )
 
@@ -1129,7 +1258,7 @@ class Project:
         ----------
         subject_name : str
             Subject ID of the subject
-        session_id : int
+        session_id : str
             The Session ID of the session that will be deleted
 
         Returns
@@ -1141,16 +1270,29 @@ 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 in this project.")
+            logger.error(
+                f"Session {subject_name}/{session_id} could not be found in "
+                f"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]
 
@@ -1159,14 +1301,23 @@ class Project:
                 platform.post(
                     self._account.auth,
                     "patient_manager/delete_patient",
-                    data={"patient_id": str(int(session["_id"])), "delete_files": 1},
+                    data={
+                        "patient_id": str(int(session["_id"])),
+                        "delete_files": 1,
+                    },
                 )
             )
         except errors.PlatformError:
-            logger.error(f"Session \"{subject_name}/{session['ssid']}\" could 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 deleted.")
+        logger.info(
+            f"Session \"{subject_name}/{session['ssid']}\" successfully "
+            f"deleted."
+        )
         return True
 
     def delete_session_by_patientid(self, patient_id):
@@ -1191,7 +1342,10 @@ class Project:
                 platform.post(
                     self._account.auth,
                     "patient_manager/delete_patient",
-                    data={"patient_id": str(int(patient_id)), "delete_files": 1},
+                    data={
+                        "patient_id": str(int(patient_id)),
+                        "delete_files": 1,
+                    },
                 )
             )
         except errors.PlatformError:
@@ -1221,10 +1375,16 @@ 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]:
@@ -1234,7 +1394,7 @@ class Project:
 
     """ Container Related Methods """
 
-    def list_input_containers(self, search_criteria={}, items=(0, 9999)):
+    def list_input_containers(self, search_criteria=None, items=(0, 9999)):
         """
         Retrieve the list of input containers available to the user under a
         certain search criteria.
@@ -1268,8 +1428,17 @@ class Project:
             {"container_name", "container_id", "patient_secret_name", "ssid"}
         """
 
-        assert len(items) == 2, f"The number of elements in items '{len(items)}' should be equal to two."
-        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
+        if search_criteria is None:
+            search_criteria = {}
+        if len(items) != 2:
+            raise ValueError(
+                f"The number of elements in items '{len(items)}' "
+                f"should be equal to two."
+            )
+        if not all(isinstance(item, int) for item in items):
+            raise ValueError(
+                f"All items elements '{items}' should be integers."
+            )
 
         response = platform.parse_response(
             platform.post(
@@ -1282,7 +1451,7 @@ class Project:
         containers = [
             {
                 "patient_secret_name": container_item["patient_secret_name"],
-                "container_name": container_item["name"],
+                "container_name": container_item["name"],  # ???
                 "container_id": container_item["_id"],
                 "ssid": container_item["ssid"],
             }
@@ -1290,7 +1459,7 @@ class Project:
         ]
         return containers
 
-    def list_result_containers(self, search_condition={}, items=(0, 9999)):
+    def list_result_containers(self, search_condition=None, items=(0, 9999)):
         """
         List the result containers available to the user.
         Examples
@@ -1318,7 +1487,8 @@ class Project:
             - qa_status: str or None pass/fail/nd QC status
             - secret_name: str or None Subject ID
             - tags: str or None
-            - with_child_analysis: 1 or None if 1, child analysis of workflows will appear
+            - with_child_analysis: 1 or None if 1, child analysis of workflows
+            will appear
             - id: str or None ID
             - state: running, completed, pending, exception or None
             - username: str or None
@@ -1335,13 +1505,21 @@ class Project:
             if "id": None, that analysis did not had an output container,
             probably it is a workflow
         """
+        if search_condition is None:
+            search_condition = {}
         analyses = self.list_analysis(search_condition, items)
-        return [{"name": analysis["name"], "id": (analysis.get("out_container_id") or None)} for analysis in analyses]
+        return [
+            {
+                "name": analysis["name"],
+                "id": (analysis.get("out_container_id") or None),
+            }
+            for analysis in analyses
+        ]
 
     def list_container_files(
         self,
         container_id,
-    ):
+    ) -> Any:
         """
         List the name of the files available inside a given container.
         Parameters
@@ -1357,7 +1535,9 @@ class Project:
         try:
             content = platform.parse_response(
                 platform.post(
-                    self._account.auth, "file_manager/get_container_files", data={"container_id": container_id}
+                    self._account.auth,
+                    "file_manager/get_container_files",
+                    data={"container_id": container_id},
                 )
             )
         except errors.PlatformError as e:
@@ -1368,7 +1548,9 @@ class Project:
             return False
         return content["files"]
 
-    def list_container_filter_files(self, container_id, modality="", metadata_info={}, tags=[]):
+    def list_container_filter_files(
+        self, container_id, modality="", metadata_info={}, tags=[]
+    ):
         """
         List the name of the files available inside a given container.
         search condition example:
@@ -1404,17 +1586,23 @@ class Project:
             if modality == "":
                 modality_bool = True
             else:
-                modality_bool = modality == metadata_file["metadata"].get("modality")
+                modality_bool = modality == metadata_file["metadata"].get(
+                    "modality"
+                )
             for key in metadata_info.keys():
-                meta_key = ((metadata_file.get("metadata") or {}).get("info") or {}).get(key)
+                meta_key = (
+                    (metadata_file.get("metadata") or {}).get("info") or {}
+                ).get(key)
                 if meta_key is None:
-                    logging.getLogger(logger_name).warning(f"{key} is not in file_info from file {file}")
+                    logging.getLogger(logger_name).warning(
+                        f"{key} is not in file_info from file {file}"
+                    )
                 info_bool.append(metadata_info[key] == meta_key)
             if all(tags_bool) and all(info_bool) and modality_bool:
                 selected_files.append(file)
         return selected_files
 
-    def list_container_files_metadata(self, container_id):
+    def list_container_files_metadata(self, container_id) -> dict:
         """
         List all the metadata of the files available inside a given container.
 
@@ -1432,7 +1620,9 @@ class Project:
         try:
             data = platform.parse_response(
                 platform.post(
-                    self._account.auth, "file_manager/get_container_files", data={"container_id": container_id}
+                    self._account.auth,
+                    "file_manager/get_container_files",
+                    data={"container_id": container_id},
                 )
             )
         except errors.PlatformError as e:
@@ -1443,9 +1633,10 @@ class Project:
 
     """ Analysis Related Methods """
 
-    def get_analysis(self, analysis_name_or_id):
+    def get_analysis(self, analysis_name_or_id) -> dict:
         """
-        Returns the analysis corresponding with the analysis id or analysis name
+        Returns the analysis corresponding with the analysis id or analysis
+        name
 
         Parameters
         ----------
@@ -1465,28 +1656,41 @@ class Project:
                 analysis_name_or_id = int(analysis_name_or_id)
             else:
                 search_tag = "p_n"
-                excluded_characters = ["\\", "[", "]", "(", ")", "{", "}", "+", "*"]
-                excluded_bool = [character in analysis_name_or_id for character in excluded_characters]
+                excluded_bool = [
+                    character in analysis_name_or_id
+                    for character in ANALYSIS_NAME_EXCLUDED_CHARACTERS
+                ]
                 if any(excluded_bool):
-                    raise Exception(f"p_n does not allow characters {excluded_characters}")
+                    raise Exception(
+                        f"p_n does not allow "
+                        f"characters {ANALYSIS_NAME_EXCLUDED_CHARACTERS}"
+                    )
         else:
-            raise Exception("The analysis identifier must be its name or an integer")
+            raise Exception(
+                "The analysis identifier must be its name or an integer"
+            )
 
         search_condition = {
             search_tag: analysis_name_or_id,
         }
         response = platform.parse_response(
-            platform.post(self._account.auth, "analysis_manager/get_analysis_list", data=search_condition)
+            platform.post(
+                self._account.auth,
+                "analysis_manager/get_analysis_list",
+                data=search_condition,
+            )
         )
 
         if len(response) > 1:
-            raise Exception(f"multiple analyses with name {analysis_name_or_id} found")
+            raise Exception(
+                f"multiple analyses with name {analysis_name_or_id} found"
+            )
         elif len(response) == 1:
             return response[0]
         else:
             return None
 
-    def list_analysis(self, search_condition={}, items=(0, 9999)):
+    def list_analysis(self, search_condition=None, items=(0, 9999)):
         """
         List the analysis available to the user.
 
@@ -1515,10 +1719,12 @@ class Project:
             - qa_status: str or None pass/fail/nd QC status
             - secret_name: str or None Subject ID
             - tags: str or None
-            - with_child_analysis: 1 or None if 1, child analysis of workflows will appear
+            - with_child_analysis: 1 or None if 1, child analysis of workflows
+            will appear
             - id: int or None ID
             - state: running, completed, pending, exception or None
             - username: str or None
+            - only_data: int or None
 
         items : List[int]
             list containing two elements [min, max] that correspond to the
@@ -1529,8 +1735,17 @@ class Project:
         dict
             List of analysis, each a dictionary
         """
-        assert len(items) == 2, f"The number of elements in items '{len(items)}' should be equal to two."
-        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
+        if search_condition is None:
+            search_condition = {}
+        if len(items) != 2:
+            raise ValueError(
+                f"The number of elements in items '{len(items)}' "
+                f"should be equal to two."
+            )
+        if not all(isinstance(item, int) for item in items):
+            raise ValueError(
+                f"All items elements '{items}' should be integers."
+            )
         search_keys = {
             "p_n": str,
             "type": str,
@@ -1543,19 +1758,37 @@ class Project:
             "with_child_analysis": int,
             "id": int,
             "state": str,
+            "only_data": int,
             "username": str,
         }
         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"))
-            if not isinstance(search_condition[key], search_keys[key]) and search_condition[key] is not None:
-                raise Exception((f"The key {key} in the search condition is not type {search_keys[key]}"))
+                raise Exception(
+                    (
+                        f"This key '{key}' is not accepted by this search "
+                        f"condition"
+                    )
+                )
+            if (
+                not isinstance(search_condition[key], search_keys[key])
+                and search_condition[key] is not None
+            ):
+                raise Exception(
+                    (
+                        f"The key {key} in the search condition is not type "
+                        f"{search_keys[key]}"
+                    )
+                )
             if "p_n" == key:
-                excluded_characters = ["\\", "[", "]", "(", ")", "{", "}", "+", "*"]
-                excluded_bool = [character in search_condition["p_n"] for character in excluded_characters]
+                excluded_bool = [
+                    character in search_condition["p_n"]
+                    for character in ANALYSIS_NAME_EXCLUDED_CHARACTERS
+                ]
                 if any(excluded_bool):
-                    raise Exception(f"p_n does not allow characters {excluded_characters}")
-        req_headers = {"X-Range": f"items={items[0]}-{items[1] - 1}"}
+                    raise Exception(
+                        "p_n does not allow "
+                        f"characters {ANALYSIS_NAME_EXCLUDED_CHARACTERS}"
+                    )
         req_headers = {"X-Range": f"items={items[0]}-{items[1] - 1}"}
         return platform.parse_response(
             platform.post(
@@ -1620,7 +1853,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}
 
@@ -1653,15 +1888,19 @@ class Project:
 
         logger.debug(f"post_data = {post_data}")
         return self.__handle_start_analysis(
-            post_data, ignore_warnings=ignore_warnings, ignore_file_selection=ignore_file_selection
+            post_data,
+            ignore_warnings=ignore_warnings,
+            ignore_file_selection=ignore_file_selection,
         )
 
     def delete_analysis(self, analysis_id):
         """
         Delete an analysis
 
-        :param analysis_id: id of the analysis to be deleted
-        :type analysis_id: Int
+        Parameters
+        ----------
+        analysis_id : int
+            ID of the analysis to be deleted
         """
         logger = logging.getLogger(logger_name)
 
@@ -1689,18 +1928,23 @@ class Project:
         Tools can not be restarted given that they are considered as single
         processing units. You can start execution of another analysis instead.
 
-        For the workflow to restart, all its failed child must be removed first.
-        You can only restart your own analysis.
+        For the workflow to restart, all its failed child must be removed
+        first. You can only restart your own analysis.
 
-        :param analysis_id: id of the analysis to be restarted
-        :type analysis_id: Int
+        Parameters
+        ----------
+        analysis_id : int
+            ID of the analysis to be restarted
         """
         logger = logging.getLogger(logger_name)
 
         analysis = self.list_analysis({"id": analysis_id})[0]
 
         if analysis.get("super_analysis_type") != 1:
-            raise ValueError("The analysis indicated is not a workflow and hence, it cannot be restarted.")
+            raise ValueError(
+                "The analysis indicated is not a workflow and hence, it "
+                "cannot be restarted."
+            )
 
         try:
             platform.parse_response(
@@ -1722,7 +1966,8 @@ class Project:
         Get the log of an analysis and save it in the provided file.
         The logs of analysis can only be obtained for the tools you created.
 
-        Note workflows do not have a log so the printed message will only be ERROR.
+        Note workflows do not have a log so the printed message will only be
+        ERROR.
         You can only download the anlaysis log of the tools that you own.
 
         Note this method is very time consuming.
@@ -1745,22 +1990,32 @@ class Project:
         try:
             analysis_id = str(int(analysis_id))
         except ValueError:
-            raise ValueError(f"'analysis_id' has to be an integer not '{analysis_id}'.")
+            raise ValueError(
+                f"'analysis_id' has to be an integer not '{analysis_id}'."
+            )
 
         file_name = file_name if file_name else f"logs_{analysis_id}.txt"
         try:
             res = platform.post(
                 auth=self._account.auth,
                 endpoint="analysis_manager/download_execution_file",
-                data={"project_id": analysis_id, "file": f"logs_{analysis_id}"},
+                data={
+                    "project_id": analysis_id,
+                    "file": f"logs_{analysis_id}",
+                },
                 timeout=1000,
             )
         except Exception:
-            logger.error(f"Could not export the analysis log of '{analysis_id}'")
+            logger.error(
+                f"Could not export the analysis log of '{analysis_id}'"
+            )
             return False
 
         if not res.ok:
-            logger.error(f"The log file could not be extracted for Analysis ID: {analysis_id}.")
+            logger.error(
+                f"The log file could not be extracted for Analysis ID:"
+                f" {analysis_id}."
+            )
             return False
 
         with open(file_name, "w") as f:
@@ -1769,7 +2024,9 @@ class Project:
 
     """ QC Status Related Methods """
 
-    def set_qc_status_analysis(self, analysis_id, status=QCStatus.UNDERTERMINED, comments=""):
+    def set_qc_status_analysis(
+        self, analysis_id, status=QCStatus.UNDERTERMINED, comments=""
+    ):
         """
         Changes the analysis QC status.
 
@@ -1798,7 +2055,10 @@ class Project:
         try:
             analysis_id = str(int(analysis_id))
         except ValueError:
-            raise ValueError(f"analysis_id: '{analysis_id}' not valid. Must be convertible to int.")
+            raise ValueError(
+                f"analysis_id: '{analysis_id}' not valid. Must be convertible "
+                f"to int."
+            )
 
         try:
             platform.parse_response(
@@ -1814,11 +2074,16 @@ class Project:
                 )
             )
         except Exception:
-            logger.error(f"It was not possible to change the QC status of Analysis ID: {analysis_id}")
+            logger.error(
+                f"It was not possible to change the QC status of Analysis ID:"
+                f" {analysis_id}"
+            )
             return False
         return True
 
-    def set_qc_status_subject(self, patient_id, status=QCStatus.UNDERTERMINED, comments=""):
+    def set_qc_status_subject(
+        self, patient_id, status=QCStatus.UNDERTERMINED, comments=""
+    ):
         """
         Changes the QC status of a Patient ID (equivalent to a
         Subject ID/Session ID).
@@ -1847,7 +2112,10 @@ class Project:
         try:
             patient_id = str(int(patient_id))
         except ValueError:
-            raise ValueError(f"'patient_id': '{patient_id}' not valid. Must be convertible to int.")
+            raise ValueError(
+                f"'patient_id': '{patient_id}' not valid. Must be convertible"
+                f" to int."
+            )
 
         try:
             platform.parse_response(
@@ -1863,7 +2131,10 @@ class Project:
                 )
             )
         except Exception:
-            logger.error(f"It was not possible to change the QC status of Patient ID: {patient_id}")
+            logger.error(
+                f"It was not possible to change the QC status of Patient ID:"
+                f" {patient_id}"
+            )
             return False
         return True
 
@@ -1888,17 +2159,28 @@ class Project:
         try:
             search_criteria = {"id": analysis_id}
             to_return = self.list_analysis(search_criteria)
-            return convert_qc_value_to_qcstatus(to_return[0]["qa_status"]), to_return[0]["qa_comments"]
+            return (
+                convert_qc_value_to_qcstatus(to_return[0]["qa_status"]),
+                to_return[0]["qa_comments"],
+            )
         except IndexError:
             # Handle the case where no matching analysis is found
-            logging.error(f"No analysis was found with such Analysis ID: '{analysis_id}'.")
+            logging.error(
+                f"No analysis was found with such Analysis ID: "
+                f"'{analysis_id}'."
+            )
             return False, False
         except Exception:
             # Handle other potential exceptions
-            logging.error(f"It was not possible to extract the QC status from Analysis ID: {analysis_id}")
+            logging.error(
+                f"It was not possible to extract the QC status from Analysis "
+                f"ID: {analysis_id}"
+            )
             return False, False
 
-    def get_qc_status_subject(self, patient_id=None, subject_name=None, ssid=None):
+    def get_qc_status_subject(
+        self, patient_id=None, subject_name=None, ssid=None
+    ):
         """
         Gets the session QC status via the patient ID or the Subject ID
         and the Session ID.
@@ -1926,26 +2208,50 @@ class Project:
             try:
                 patient_id = int(patient_id)
             except ValueError:
-                raise ValueError(f"patient_id '{patient_id}' should be an integer.")
+                raise ValueError(
+                    f"patient_id '{patient_id}' should be an integer."
+                )
             sessions = self.get_subjects_metadata(search_criteria={})
-            session = [session for session in sessions if int(session["_id"]) == patient_id]
+            session = [
+                session
+                for session in sessions
+                if int(session["_id"]) == patient_id
+            ]
             if len(session) < 1:
-                logging.error(f"No session was found with Patient ID: '{patient_id}'.")
+                logging.error(
+                    f"No session was found with Patient ID: '{patient_id}'."
+                )
                 return False, False
-            return convert_qc_value_to_qcstatus(session[0]["qa_status"]), session[0]["qa_comments"]
+            return (
+                convert_qc_value_to_qcstatus(session[0]["qa_status"]),
+                session[0]["qa_comments"],
+            )
         elif subject_name and ssid:
             session = self.get_subjects_metadata(
                 search_criteria={
                     "pars_patient_secret_name": f"string;{subject_name}",
-                    "pars_ssid": f"integer;eq|{ssid}" if str(ssid).isdigit() else f"string;{ssid}",
+                    "pars_ssid": (
+                        f"integer;eq|{ssid}"
+                        if str(ssid).isdigit()
+                        else f"string;{ssid}"
+                    ),
                 }
             )
             if len(session) < 1:
-                logging.error(f"No session was found with Subject ID: '{subject_name}' and Session ID: '{ssid}'.")
+                logging.error(
+                    f"No session was found with Subject ID: '{subject_name}'"
+                    f" and Session ID: '{ssid}'."
+                )
                 return False, False
-            return convert_qc_value_to_qcstatus(session[0]["qa_status"]), session[0]["qa_comments"]
+            return (
+                convert_qc_value_to_qcstatus(session[0]["qa_status"]),
+                session[0]["qa_comments"],
+            )
         else:
-            raise ValueError("Either 'patient_id' or 'subject_name' and 'ssid' must not be empty.")
+            raise ValueError(
+                "Either 'patient_id' or 'subject_name' and 'ssid' must "
+                "not be empty."
+            )
 
     """ Protocol Adherence Related Methods """
 
@@ -1973,7 +2279,9 @@ class Project:
             with open(rules_file_path, "r") as fr:
                 rules = json.load(fr)
         except FileNotFoundError:
-            logger.error(f"Pprotocol adherence rule file '{rules_file_path}' not found.")
+            logger.error(
+                f"Protocol adherence rule file '{rules_file_path}' not found."
+            )
             return False
 
         # Update the project's QA rules
@@ -1981,18 +2289,26 @@ class Project:
             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},
+                data={
+                    "project_id": self._project_id,
+                    "rules": json.dumps(rules),
+                    "guidance_text": guidance_text,
+                },
             )
         )
 
         if not res.get("success") == 1:
-            logger.error("There was an error setting up the protocol adherence rules.")
+            logger.error(
+                "There was an error setting up the protocol adherence rules."
+            )
             logger.error(platform.parse_response(res))
             return False
 
         return True
 
-    def get_project_pa_rules(self, rules_file_path):
+    def get_project_pa_rules(
+        self, rules_file_path, project_has_no_rules=False
+    ):
         """
         Retrive the active project's protocol adherence rules
 
@@ -2001,6 +2317,8 @@ class Project:
             rules_file_path : str
                 The file path to the JSON file to store the protocol adherence
                 rules.
+            project_has_no_rules: bool
+                for testing purposes
 
         Returns
         -------
@@ -2020,47 +2338,58 @@ class Project:
             )
         )
 
-        if "rules" not in res:
-            logger.error(f"There was an error extracting the protocol adherence rules from {self._project_name}.")
+        if "rules" not in res or project_has_no_rules:
+            logger.error(
+                f"There was an error extracting the protocol adherence rules"
+                f" from {self._project_name}."
+            )
             logger.error(platform.parse_response(res))
             return False
 
         try:
             for rule in res["rules"]:
-                del rule["_id"]
-                del rule["order"]
-                del rule["time_modified"]
+                for key in ["_id", "order", "time_modified"]:
+                    if rule.get(key, False):
+                        del rule[key]
             with open(rules_file_path, "w") as fr:
                 json.dump(res["rules"], fr, indent=4)
         except FileNotFoundError:
-            logger.error(f"Protocol adherence rules could not be exported to file: '{rules_file_path}'.")
+            logger.error(
+                f"Protocol adherence rules could not be exported to file: "
+                f"'{rules_file_path}'."
+            )
             return False
 
         return res["guidance_text"]
 
     def parse_qc_text(self, patient_id=None, subject_name=None, ssid=None):
         """
-        Parse QC (Quality Control) text output into a structured dictionary format.
+        Parse QC (Quality Control) text output into a structured dictionary
+        format.
 
-        This function takes raw QC text output (from the Protocol Adherence analysis)
-        and parses it into a structured format that separates passed and failed rules,
-        along with their associated files and conditions.
+        This function takes raw QC text output (from the Protocol Adherence
+        analysis) and parses it into a structured format that
+        separates passed and failed rules, along with their associated files
+        and conditions.
 
         Args:
             patient_id (str, optional):
                 Patient identifier. Defaults to None.
             subject_name (str, optional):
-                Subject/patient name. Defaults to None. Mandatory if no patient_id is provided.
+                Subject/patient name. Defaults to None. Mandatory if no
+                patient_id is provided.
             ssid (str, optional):
-                Session ID. Defaults to None. Mandatory if subject_name is provided.
+                Session ID. Defaults to None. Mandatory if subject_name is
+                provided.
 
         Returns:
-            dict: A structured dictionary containing a list of dictionaries with passed rules and their details
-            and failed rules and their details. Details of passed rules are:
-            per each rule: Files that have passed the rule. Per each file name of the file and number of conditions
-            of the rule.
-            Details of failed rules are:
-            - Per each rule failed conditions: Number of times it failed. Each condition status.
+            dict: A structured dictionary containing a list of dictionaries
+            with passed rules and their details and failed rules and their
+            details. Details of passed rules are:
+            per each rule: Files that have passed the rule. Per each file name
+            of the file and number of conditions of the rule. Details of
+            failed rules are: per each rule failed conditions: Number of
+            times it failed. Each condition status.
 
         Example:
             >>> parse_qc_text(subject_name="patient_123", ssid=1)
@@ -2086,7 +2415,7 @@ class Project:
                                 "conditions": [
                                     {
                                         "status": "failed",
-                                        "condition": "SliceThickness between..."
+                                        "condition": "SliceThickness between.."
                                     }
                                 ]
                             }
@@ -2099,7 +2428,9 @@ class Project:
             }
         """
 
-        _, text = self.get_qc_status_subject(patient_id=patient_id, subject_name=subject_name, ssid=ssid)
+        _, text = self.get_qc_status_subject(
+            patient_id=patient_id, subject_name=subject_name, ssid=ssid
+        )
 
         result = {"passed": [], "failed": []}
 
@@ -2129,22 +2460,27 @@ class Project:
 
     def calculate_qc_statistics(self):
         """
-        Calculate comprehensive statistics from multiple QC results across subjects from a project in the QMENTA
-        platform.
+        Calculate comprehensive statistics from multiple QC results across
+        subjects from a project in the QMENTA platform.
 
-        This function aggregates and analyzes QC results from multiple subjects/containers,
-        providing statistical insights about rule pass/fail rates, file statistics,
-        and condition failure patterns.
+        This function aggregates and analyzes QC results from
+        multiple subjects/containers, providing statistical insights about
+        rule pass/fail rates, file statistics, and condition failure patterns.
 
         Returns:
-            dict: A dictionary containing comprehensive QC statistics including:
+            dict: A dictionary containing comprehensive QC statistics
+            including:
                 - passed_rules: Total count of passed rules across all subjects
                 - failed_rules: Total count of failed rules across all subjects
                 - subjects_passed: Count of subjects with no failed rules
-                - subjects_with_failed: Count of subjects with at least one failed rule
-                - num_passed_files_distribution: Distribution of how many rules have N passed files
-                - file_stats: File-level statistics (total, passed, failed, pass percentage)
-                - condition_failure_rates: Frequency and percentage of each failed condition
+                - subjects_with_failed: Count of subjects with at least one
+                failed rule
+                - num_passed_files_distribution: Distribution of how many
+                rules have N passed files
+                - file_stats: File-level statistics (total, passed, failed,
+                pass percentage)
+                - condition_failure_rates: Frequency and percentage of each
+                failed condition
                 - rule_success_rates: Success rates for each rule type
 
         The statistics help identify:
@@ -2190,7 +2526,11 @@ class Project:
         containers = self.list_input_containers()
 
         for c in containers:
-            qc_results_list.append(self.parse_qc_text(subject_name=c["patient_secret_name"], ssid=c["ssid"]))
+            qc_results_list.append(
+                self.parse_qc_text(
+                    subject_name=c["patient_secret_name"], ssid=c["ssid"]
+                )
+            )
 
         # Initialize statistics
         stats = {
@@ -2198,22 +2538,49 @@ class Project:
             "failed_rules": 0,
             "subjects_passed": 0,
             "subjects_with_failed": 0,
-            "num_passed_files_distribution": defaultdict(int),  # How many rules have N passed files
-            "file_stats": {"total": 0, "passed": 0, "failed": 0, "pass_percentage": 0.0},
-            "condition_failure_rates": defaultdict(lambda: {"count": 0, "percentage": 0.0}),
-            "rule_success_rates": defaultdict(lambda: {"passed": 0, "failed": 0, "success_rate": 0.0}),
+            "num_passed_files_distribution": defaultdict(
+                int
+            ),  # How many rules have N passed files
+            "file_stats": {
+                "total": 0,
+                "passed": 0,
+                "failed": 0,
+                "pass_percentage": 0.0,
+            },
+            "condition_failure_rates": defaultdict(
+                lambda: {"count": 0, "percentage": 0.0}
+            ),
+            "rule_success_rates": defaultdict(
+                lambda: {"passed": 0, "failed": 0, "success_rate": 0.0}
+            ),
         }
 
         total_failures = 0
 
         # sum subjects with not failed qc message
-        stats["subjects_passed"] = sum([1 for rules in qc_results_list if not rules["failed"]])
+        stats["subjects_passed"] = sum(
+            [1 for rules in qc_results_list if not rules["failed"]]
+        )
         # sum subjects with some failed qc message
-        stats["subjects_with_failed"] = sum([1 for rules in qc_results_list if rules["failed"]])
+        stats["subjects_with_failed"] = sum(
+            [1 for rules in qc_results_list if rules["failed"]]
+        )
         # sum rules that have passed
-        stats["passed_rules"] = sum([len(rules["passed"]) for rules in qc_results_list if rules["failed"]])
+        stats["passed_rules"] = sum(
+            [
+                len(rules["passed"])
+                for rules in qc_results_list
+                if rules["failed"]
+            ]
+        )
         # sum rules that have failed
-        stats["failed_rules"] = sum([len(rules["failed"]) for rules in qc_results_list if rules["failed"]])
+        stats["failed_rules"] = sum(
+            [
+                len(rules["failed"])
+                for rules in qc_results_list
+                if rules["failed"]
+            ]
+        )
 
         for qc_results in qc_results_list:
 
@@ -2231,42 +2598,72 @@ class Project:
                 stats["file_stats"]["failed"] += len(rule["files"])
                 for condition, count in rule["failed_conditions"].items():
                     # Extract just the condition text without actual value
-                    clean_condition = re.sub(r"\.\s*Actual value:.*$", "", condition)
-                    stats["condition_failure_rates"][clean_condition]["count"] += count
+                    clean_condition = re.sub(
+                        r"\.\s*Actual value:.*$", "", condition
+                    )
+                    stats["condition_failure_rates"][clean_condition][
+                        "count"
+                    ] += count
                     total_failures += count
                 rule_name = rule["rule"]
                 stats["rule_success_rates"][rule_name]["failed"] += 1
 
         if stats["file_stats"]["total"] > 0:
             stats["file_stats"]["pass_percentage"] = round(
-                (stats["file_stats"]["passed"] / stats["file_stats"]["total"]) * 100, 2
+                (stats["file_stats"]["passed"] / stats["file_stats"]["total"])
+                * 100,
+                2,
             )
 
         # Calculate condition failure percentages
         for condition in stats["condition_failure_rates"]:
             if total_failures > 0:
-                stats["condition_failure_rates"][condition]["percentage"] = round(
-                    (stats["condition_failure_rates"][condition]["count"] / total_failures) * 100, 2
+                stats["condition_failure_rates"][condition]["percentage"] = (
+                    round(
+                        (
+                            stats["condition_failure_rates"][condition][
+                                "count"
+                            ]
+                            / total_failures
+                        )
+                        * 100,
+                        2,
+                    )
                 )
 
         # Calculate rule success rates
         for rule in stats["rule_success_rates"]:
-            total = stats["rule_success_rates"][rule]["passed"] + stats["rule_success_rates"][rule]["failed"]
+            total = (
+                stats["rule_success_rates"][rule]["passed"]
+                + stats["rule_success_rates"][rule]["failed"]
+            )
             if total > 0:
                 stats["rule_success_rates"][rule]["success_rate"] = round(
-                    (stats["rule_success_rates"][rule]["passed"] / total) * 100, 2
+                    (stats["rule_success_rates"][rule]["passed"] / total)
+                    * 100,
+                    2,
                 )
 
         # Convert defaultdict to regular dict for cleaner JSON output
-        stats["num_passed_files_distribution"] = dict(stats["num_passed_files_distribution"])
-        stats["condition_failure_rates"] = dict(stats["condition_failure_rates"])
+        stats["num_passed_files_distribution"] = dict(
+            stats["num_passed_files_distribution"]
+        )
+        stats["condition_failure_rates"] = dict(
+            stats["condition_failure_rates"]
+        )
         stats["rule_success_rates"] = dict(stats["rule_success_rates"])
 
         return stats
 
     """ Helper Methods """
 
-    def __handle_start_analysis(self, post_data, ignore_warnings=False, ignore_file_selection=True, n_calls=0):
+    def __handle_start_analysis(
+        self,
+        post_data,
+        ignore_warnings=False,
+        ignore_file_selection=True,
+        n_calls=0,
+    ):
         """
         Handle the possible responses from the server after start_analysis.
         Sometimes we have to send a request again, and then check again the
@@ -2286,13 +2683,21 @@ class Project:
                           than {n_calls} times: aborting."
             )
             return None
-
+        response = None
         try:
             response = platform.parse_response(
-                platform.post(self._account.auth, "analysis_manager/analysis_registration", data=post_data)
+                platform.post(
+                    self._account.auth,
+                    "analysis_manager/analysis_registration",
+                    data=post_data,
+                )
             )
             logger.info(response["message"])
-            return int(response["analysis_id"]) if "analysis_id" in response else None
+            return (
+                int(response["analysis_id"])
+                if "analysis_id" in response
+                else None
+            )
 
         except platform.ChooseDataError as choose_data:
             if ignore_file_selection:
@@ -2312,31 +2717,39 @@ class Project:
             # logging any warning that we have
             if choose_data.warning:
                 has_warning = True
-                logger.warning(response["warning"])
+                logger.warning(choose_data.warning)
 
             new_post = {
                 "analysis_id": choose_data.analysis_id,
                 "script_name": post_data["script_name"],
                 "version": post_data["version"],
             }
+            if "tags" in post_data.keys():
+                new_post["tags"] = post_data["tags"]
 
             if choose_data.data_to_choose:
                 self.__handle_manual_choose_data(new_post, choose_data)
             else:
                 if has_warning and not ignore_warnings:
-                    logger.error("Cancelling analysis due to warnings, set 'ignore_warnings' to True to override.")
+                    logger.error(
+                        "Cancelling analysis due to warnings, set "
+                        "'ignore_warnings' to True to override."
+                    )
                     new_post["cancel"] = "1"
                 else:
                     logger.info("suppressing warnings")
                     new_post["user_preference"] = "{}"
                     new_post["_mint_only_warning"] = "1"
 
-            return self.__handle_start_analysis(new_post, ignore_warnings, ignore_file_selection, n_calls)
+            return self.__handle_start_analysis(
+                new_post, ignore_warnings, ignore_file_selection, n_calls
+            )
         except platform.ActionFailedError as e:
             logger.error(f"Unable to start the analysis: {e}.")
             return None
 
-    def __handle_manual_choose_data(self, post_data, choose_data):
+    @staticmethod
+    def __handle_manual_choose_data(post_data, choose_data):
         """
         Handle the responses of the user when there is need to select a file
         to start the analysis.
@@ -2349,15 +2762,22 @@ class Project:
             post_data : dict
                 Current post_data dictionary. To be mofidied in-place.
             choose_data : platform.ChooseDataError
-                Error raised when trying to start an analysis, but data has to be chosen.
+                Error raised when trying to start an analysis, but data has to
+                be chosen.
         """
 
         logger = logging.getLogger(logger_name)
-        logger.warning("Multiple inputs available. You have to select the desired file/s to continue.")
+        logger.warning(
+            "Multiple inputs available. You have to select the desired file/s "
+            "to continue."
+        )
         # in case we have data to choose
         chosen_files = {}
         for settings_key in choose_data.data_to_choose:
-            logger.warning(f"Type next the file/s for the input with ID: '{settings_key}'.")
+            logger.warning(
+                f"Type next the file/s for the input with ID: "
+                f"'{settings_key}'."
+            )
             chosen_files[settings_key] = {}
             filters = choose_data.data_to_choose[settings_key]["filters"]
             for filter_key in filters:
@@ -2372,7 +2792,9 @@ 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"])
 
@@ -2384,19 +2806,29 @@ class Project:
                 # list_container_filter_files()
 
                 if number_of_files_to_select != len(filter_data["files"]):
+                    substring = ""
+                    if number_of_files_to_select > 1:
+                        substring = "s (i.e., file1.zip, file2.zip, file3.zip)"
                     logger.warning(
                         f"  · File filter name: '{filter_key}'. Type "
-                        f"{number_of_files_to_select} file"
-                        f"{'s (i.e., file1.zip, file2.zip, file3.zip)' if number_of_files_to_select > 1 else ''}."
+                        f"{number_of_files_to_select} file{substring}."
                     )
                     save_file_ids, select_file_filter = {}, ""
                     for file_ in filter_data["files"]:
-                        select_file_filter += f"       · File name: {file_['name']}\n"
+                        select_file_filter += (
+                            f"       · File name: {file_['name']}\n"
+                        )
                         save_file_ids[file_["name"]] = file_["_id"]
-                    names = [el.strip() for el in input(select_file_filter).strip().split(",")]
+                    names = [
+                        el.strip()
+                        for el in input(select_file_filter).strip().split(",")
+                    ]
 
                     if len(names) != number_of_files_to_select:
-                        logger.error("The number of files selected does not correspond to the number of needed files.")
+                        logger.error(
+                            "The number of files selected does not correspond "
+                            "to the number of needed files."
+                        )
                         logger.error(
                             f"Selected: {len(names)} vs. "
                             f"Number of files to select: "
@@ -2406,14 +2838,27 @@ class Project:
                         post_data["cancel"] = "1"
 
                     elif any([name not in save_file_ids for name in names]):
-                        logger.error(f"Some selected file/s '{', '.join(names)}' do not exist. Cancelling analysis...")
+                        logger.error(
+                            f"Some selected file/s '{', '.join(names)}' "
+                            f"do not exist. Cancelling analysis..."
+                        )
                         post_data["cancel"] = "1"
                     else:
-                        chosen_files[settings_key][filter_key] = [save_file_ids[name] for name in names]
+                        chosen_files[settings_key][filter_key] = [
+                            save_file_ids[name] for name in names
+                        ]
 
                 else:
-                    logger.warning("Setting all available files to be input to the analysis.")
-                    files_selection = [ff["_id"] for ff in filter_data["files"][:number_of_files_to_select]]
+                    logger.warning(
+                        "Setting all available files to be input to the "
+                        "analysis."
+                    )
+                    files_selection = [
+                        ff["_id"]
+                        for ff in filter_data["files"][
+                            :number_of_files_to_select
+                        ]
+                    ]
                     chosen_files[settings_key][filter_key] = files_selection
 
         post_data["user_preference"] = json.dumps(chosen_files)
@@ -2427,20 +2872,6 @@ class Project:
                 modalities.append(modality)
         return modalities
 
-    def __show_progress(self, 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
-        )
-        sys.stdout.write(progress_message)
-        sys.stdout.flush()
-        if not finish:
-            pass
-            # sys.stdout.write("")
-            # sys.stdout.flush()
-        else:
-            sys.stdout.write("\n")
-
     def __get_session_id(self, file_path):
         m = hashlib.md5()
         m.update(file_path.encode("utf-8"))
@@ -2472,11 +2903,12 @@ class Project:
         else:
             return True
 
-    def __operation(self, reference_value, operator, input_value):
+    @staticmethod
+    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.
+        The Operation is applied to the Input Value in comparison to the
+        Reference Value.
 
         Parameters
         ----------
@@ -2492,39 +2924,32 @@ class Project:
         bool
             True if the operation is satisfied, False otherwise.
         """
-        if input_value is None or input_value == "":
+        if not input_value:  # Handles None, "", and other falsy values
             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
+        operator_actions = {
+            "in": lambda: reference_value in input_value,
+            "in-list": lambda: all(
+                el in input_value for el in reference_value
+            ),
+            "eq": lambda: input_value == reference_value,
+            "gt": lambda: input_value > reference_value,
+            "gte": lambda: input_value >= reference_value,
+            "lt": lambda: input_value < reference_value,
+            "lte": lambda: input_value <= reference_value,
+        }
 
-        elif operator == "lte":
-            return input_value <= reference_value
-        else:
-            return False
+        action = operator_actions.get(operator, lambda: False)
+        return action()
 
-    def __wrap_search_criteria(self, search_criteria={}):
+    @staticmethod
+    def __wrap_search_criteria(search_criteria=None):
         """
         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.
+        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
         ----------
@@ -2548,27 +2973,27 @@ class Project:
 
         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 the search criteria
+        tuple
+            A tuple containing:
+            - str: modality is a string containing the modality of the search
+            criteria extracted from 'pars_modalities';
+            - list: tags is a list of strings containing the tags of the search
+            criteria extracted 'from pars_tags',
+            - dict: containing the file metadata of the search criteria
             extracted from 'pars_[dicom]_KEY'
         """
 
         # The keys not included bellow apply to the whole session.
+        if search_criteria is None:
+            search_criteria = {}
         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. Provided Modalities: {', '.join(modalities)}."
+                        f"A file can only have one modality. "
+                        f"Provided Modalities: {', '.join(modalities)}."
                     )
                 modality = modalities[0]
             elif key == "pars_tags":
@@ -2577,21 +3002,34 @@ class Project:
                 d_tag = key.split("pars_[dicom]_")[1]
                 d_type = value.split(";")[0]
                 if d_type == "string":
-                    file_metadata[d_tag] = {"operation": "in", "value": value.replace(d_type + ";", "")}
+                    file_metadata[d_tag] = {
+                        "operation": "in",
+                        "value": value.replace(d_type + ";", ""),
+                    }
                 elif d_type == "integer":
                     d_operator = value.split(";")[1].split("|")[0]
                     d_value = value.split(";")[1].split("|")[1]
-                    file_metadata[d_tag] = {"operation": d_operator, "value": int(d_value)}
+                    file_metadata[d_tag] = {
+                        "operation": d_operator,
+                        "value": int(d_value),
+                    }
                 elif d_type == "decimal":
                     d_operator = value.split(";")[1].split("|")[0]
                     d_value = value.split(";")[1].split("|")[1]
-                    file_metadata[d_tag] = {"operation": d_operator, "value": float(d_value)}
+                    file_metadata[d_tag] = {
+                        "operation": d_operator,
+                        "value": float(d_value),
+                    }
                 elif d_type == "list":
                     value.replace(d_type + ";", "")
-                    file_metadata[d_tag] = {"operation": "in-list", "value": value.replace(d_type + ";", "").split(";")}
+                    file_metadata[d_tag] = {
+                        "operation": "in-list",
+                        "value": value.replace(d_type + ";", "").split(";"),
+                    }
         return modality, tags, file_metadata
 
-    def __assert_split_data(self, split_data, ssid, add_to_container_id):
+    @staticmethod
+    def __assert_split_data(split_data, ssid, add_to_container_id):
         """
         Assert if the split_data parameter is possible to use in regards
         to the ssid and add_to_container_id parameters during upload.
@@ -2614,29 +3052,81 @@ class Project:
 
         logger = logging.getLogger(logger_name)
         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
 
         if add_to_container_id and split_data:
-            logger.warning("split-data argument will be ignored because add_to_container_id has been specified")
+            logger.warning(
+                "split-data argument will be ignored because "
+                "add_to_container_id has been specified"
+            )
             split_data = False
 
         return split_data
 
-    def __parse_fail_rules(self, failed_rules, result):
+    @staticmethod
+    def __parse_pass_rules(passed_rules, result):
+        """
+        Parse pass rules.
+        """
+
+        for rule_text in passed_rules[1:]:  # Skip first empty part
+            rule_name = rule_text.split(" ✅")[0].strip()
+            rule_data = {"rule": rule_name, "sub_rule": None, "files": []}
+
+            # Get sub-rule
+            sub_rule_match = re.search(r"Sub-rule: (.*?)\n", rule_text)
+            if sub_rule_match:
+                rule_data["sub_rule"] = sub_rule_match.group(1).strip()
+
+            # Get files passed
+            files_passed = re.search(
+                r"List of files passed:(.*?)(?=\n\n|\Z)", rule_text, re.DOTALL
+            )
+            if files_passed:
+                for line in files_passed.group(1).split("\n"):
+                    line = line.strip()
+                    if line.startswith("·"):
+                        file_match = re.match(r"· (.*?) \((\d+)/(\d+)\)", line)
+                        if file_match:
+                            rule_data["files"].append(
+                                {
+                                    "file": file_match.group(1).strip(),
+                                    "passed_conditions": int(
+                                        file_match.group(2)
+                                    ),
+                                }
+                            )
+
+            result["passed"].append(rule_data)
+        return result
+
+    @staticmethod
+    def __parse_fail_rules(failed_rules, result):
         """
         Parse fail rules.
         """
 
         for rule_text in failed_rules[1:]:  # Skip first empty part
             rule_name = rule_text.split(" ❌")[0].strip()
-            rule_data = {"rule": rule_name, "files": [], "failed_conditions": {}}
+            rule_data = {
+                "rule": rule_name,
+                "files": [],
+                "failed_conditions": {},
+            }
 
             # Extract all file comparisons for this rule
-            file_comparisons = re.split(r"\t- Comparison with file:", rule_text)
+            file_comparisons = re.split(r"- Comparison with file:", rule_text)
             for comp in file_comparisons[1:]:  # Skip first part
                 file_name = comp.split("\n")[0].strip()
-                conditions_match = re.search(r"Conditions:(.*?)(?=\n\t- Comparison|\n\n|$)", comp, re.DOTALL)
+                conditions_match = re.search(
+                    r"Conditions:(.*?)(?=\n\t- Comparison|\n\n|$)",
+                    comp,
+                    re.DOTALL,
+                )
                 if not conditions_match:
                     continue
 
@@ -2648,7 +3138,14 @@ class Project:
                     if line.startswith("·"):
                         status = "✔" if "✔" in line else "🚫"
                         condition = re.sub(r"^· [✔🚫]\s*", "", line)
-                        conditions.append({"status": "passed" if status == "✔" else "failed", "condition": condition})
+                        conditions.append(
+                            {
+                                "status": (
+                                    "passed" if status == "✔" else "failed"
+                                ),
+                                "condition": condition,
+                            }
+                        )
 
                 # Add to failed conditions summary
                 for cond in conditions:
@@ -2658,39 +3155,9 @@ class Project:
                             rule_data["failed_conditions"][cond_text] = 0
                         rule_data["failed_conditions"][cond_text] += 1
 
-                rule_data["files"].append({"file": file_name, "conditions": conditions})
+                rule_data["files"].append(
+                    {"file": file_name, "conditions": conditions}
+                )
 
             result["failed"].append(rule_data)
         return result
-
-    def __parse_pass_rules(self, passed_rules, result):
-        """
-        Parse pass rules.
-        """
-
-        for rule_text in passed_rules[1:]:  # Skip first empty part
-            rule_name = rule_text.split(" ✅")[0].strip()
-            rule_data = {"rule": rule_name, "sub_rule": None, "files": []}
-
-            # Get sub-rule
-            sub_rule_match = re.search(r"Sub-rule: (.*?)\n", rule_text)
-            if sub_rule_match:
-                rule_data["sub_rule"] = sub_rule_match.group(1).strip()
-
-            # Get files passed
-            files_passed = re.search(r"List of files passed:(.*?)(?=\n\n|\Z)", rule_text, re.DOTALL)
-            if files_passed:
-                for line in files_passed.group(1).split("\n"):
-                    line = line.strip()
-                    if line.startswith("·"):
-                        file_match = re.match(r"· (.*?) \((\d+)/(\d+)\)", line)
-                        if file_match:
-                            rule_data["files"].append(
-                                {
-                                    "file": file_match.group(1).strip(),
-                                    "passed_conditions": int(file_match.group(2)),
-                                }
-                            )
-
-            result["passed"].append(rule_data)
-        return result