qmenta-client 1.1.dev1378__py3-none-any.whl → 1.1.dev1389__py3-none-any.whl

qmenta/client/Project.py

@@ -20,186 +20,6 @@ logger_name = "qmenta.client"
 OPERATOR_LIST = ["eq", "ne", "gt", "gte", "lt", "lte"]
 
 
-def show_progress(done, total, finish=False):
-    bytes_in_mb = 1024 * 1024
-    progress_message = "\r[{:.2f} %] Uploaded {:.2f} of {:.2f} Mb".format(
-        done / float(total) * 100, done / bytes_in_mb, total / bytes_in_mb
-    )
-    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(file_path):
-    m = hashlib.md5()
-    m.update(file_path.encode("utf-8"))
-    return str(time.time()).replace(".", "") + "_" + m.hexdigest()
-
-
-def check_upload_file(file_path):
-    """
-    Check whether a file has the correct extension to upload.
-
-    Parameters
-    ----------
-    file_path : str
-        Path to the file
-
-    Returns
-    -------
-    bool
-        True if correct extension, False otherwise.
-    """
-
-    # TODO: Add a file zipper here so zips files in a folder
-
-    file_parts = file_path.split(".")
-    extension = file_parts[-1]
-
-    if extension != "zip":
-        logging.getLogger(logger_name).error("You must upload a zip.")
-        return False
-    else:
-        return True
-
-
-def operation(reference_value, operator, input_value):
-    """
-    The method performs an operation by comparing the two input values.
-    The Operation is applied to the Input Value in comparison to the Reference
-    Value.
-
-    Parameters
-    ----------
-    reference_value : str, list, or int
-        Reference value.
-    operator : str
-        Operation.
-    input_value : str, list, or int
-        Input value.
-
-    Returns
-    -------
-    bool
-        True if the operation is satisfied, False otherwise.
-    """
-    if input_value is None or input_value == "":
-        return False
-
-    if operator == "in":
-        return reference_value in input_value
-
-    elif operator == "in-list":
-        return all([el in input_value for el in reference_value])
-
-    elif operator == "eq":
-        return input_value == reference_value
-
-    elif operator == "gt":
-        return input_value > reference_value
-
-    elif operator == "gte":
-        return input_value >= reference_value
-
-    elif operator == "lt":
-        return input_value < reference_value
-
-    elif operator == "lte":
-        return input_value <= reference_value
-    else:
-        return False
-
-
-def wrap_search_criteria(search_criteria={}):
-    """
-    Wraps the conditions specified within the Search Criteria in order for
-    other methods to handle it easily. The conditions are grouped only into
-    three groups: Modality, Tags and the File Metadata (if DICOM it corresponds
-    to the DICOM information), and each of them is output in a different
-    variable.
-
-    Parameters
-    ----------
-    search_criteria : dict
-        Each element is a string and is built using the formatting
-            "KEYTYPE;VALUE", or "KEYTYPE;OPERATOR|VALUE".
-
-            Full list of keys avaiable for the dictionary:
-
-            search_criteria = {
-                "pars_patient_secret_name": "string;SUBJECTID",
-                "pars_ssid": "integer;OPERATOR|SSID",
-                "pars_modalities": "string;MODALITY",
-                "pars_tags": "tags;TAGS",
-                "pars_age_at_scan": "integer;OPERATOR|AGE_AT_SCAN",
-                "pars_[dicom]_KEY": "KEYTYPE;KEYVALUE",
-                "pars_PROJECTMETADATA": "METADATATYPE;METADATAVALUE",
-                }
-
-            See documentation for a complete definition.
-
-    Returns
-    -------
-    modality : str
-        String containing the modality of the search criteria extracted from
-        'pars_modalities'
-
-    tags : list of str
-        List of strings containing the tags of the search criteria extracted
-        'from pars_tags'
-
-    file_metadata : Dict
-        Dictionary containing the file metadata of the search criteria
-        extracted from 'pars_[dicom]_KEY'
-    """
-
-    # The keys not included bellow apply to the whole session.
-    modality, tags, file_metadata = "", list(), dict()
-    for key, value in search_criteria.items():
-        if key == "pars_modalities":
-            modalities = value.split(";")[1].split(",")
-            if len(modalities) != 1:
-                raise ValueError(f"A file can only have one modality. "
-                                 f"Provided Modalities: "
-                                 f"{', '.join(modalities)}.")
-            modality = modalities[0]
-        elif key == "pars_tags":
-            tags = value.split(";")[1].split(",")
-        elif "pars_[dicom]_" in key:
-            d_tag = key.split("pars_[dicom]_")[1]
-            d_type = value.split(";")[0]
-            if d_type == "string":
-                file_metadata[d_tag] = {
-                    "operation": "in",
-                    "value": value.replace(d_type + ";", "")
-                }
-            elif d_type == "integer":
-                d_operator = value.split(";")[1].split("|")[0]
-                d_value = value.split(";")[1].split("|")[1]
-                file_metadata[d_tag] = {
-                    "operation": d_operator,
-                    "value": int(d_value)}
-            elif d_type == "decimal":
-                d_operator = value.split(";")[1].split("|")[0]
-                d_value = value.split(";")[1].split("|")[1]
-                file_metadata[d_tag] = {
-                    "operation": d_operator,
-                    "value": float(d_value)
-                }
-            elif d_type == "list":
-                value.replace(d_type + ";", "")
-                file_metadata[d_tag] = {
-                    "operation": "in-list",
-                    "value": value.replace(d_type + ";", "").split(";")
-                }
-    return modality, tags, file_metadata
-
-
 def convert_qc_value_to_qcstatus(value):
     """
     Convert input string to QCStatus class.
@@ -255,6 +75,7 @@ class Project:
 
     """
 
+    """ Project Related Methods """
     def __init__(self, account: Account, project_id, max_upload_retries=5):
         # if project_id is a string (the name of the project), get the
         # project id (int)
@@ -312,964 +133,998 @@ class Project:
         rep = "<Project {}>".format(self._project_name)
         return rep
 
-    @property
-    def subjects_metadata(self):
-        """
-        List all subject data from the selected project.
-
-        Returns
-        -------
-        dict
-            A list of dictionary of {"metadata_name": "metadata_value"}
-        """
-        return self.get_subjects_metadata()
-
-    def get_subjects_metadata(self, search_criteria={}, items=(0, 9999)):
+    """ Upload / Download Data Related Methods """
+    def _upload_chunk(
+        self,
+        data,
+        range_str,
+        length,
+        session_id,
+        disposition,
+        last_chunk,
+        name="",
+        date_of_scan="",
+        description="",
+        subject_name="",
+        ssid="",
+        filename="DATA.zip",
+        input_data_type="mri_brain_data:1.0",
+        result=False,
+        add_to_container_id=0,
+        split_data=False,
+    ):
         """
-        List all Subject ID/Session ID from the selected project that meet the
-            defined search criteria at a session level.
+        Upload a chunk of a file to the platform.
 
         Parameters
         ----------
-        search_criteria: dict
-            Each element is a string and is built using the formatting
-            "type;value", or "type;operation|value"
-
-        Complete search_criteria Dictionary Explanation:
-
-        search_criteria = {
-            "pars_patient_secret_name": "string;SUBJECTID",
-            "pars_ssid": "integer;OPERATOR|SSID",
-            "pars_modalities": "string;MODALITY",
-            "pars_tags": "tags;TAGS",
-            "pars_age_at_scan": "integer;OPERATOR|AGE_AT_SCAN",
-            "pars_[dicom]_KEY": "KEYTYPE;KEYVALUE",
-            "pars_PROJECTMETADATA": "METADATATYPE;METADATAVALUE",
-            }
-
-        Where:
-        "pars_patient_secret_name": Applies the search to the 'Subject ID'.
-        SUBJECTID is a comma separated list of strings.
-        "pars_ssid": Applies the search to the 'Session ID'.
-        SSID is an integer.
-        OPERATOR is the operator to apply. One of:
-            - Equal: eq
-            - Different Than: ne
-            - Greater Than: gt
-            - Greater/Equal To: gte
-            - Lower Than: lt
-            - Lower/Equal To: lte
-
-        "pars_modalities": Applies the search to the file 'Modalities'
-            available within each Subject ID.
-        MODALITY is a comma separated list of string. A session is provided as
-            long as one MODALITY is available.
-        "pars_tags": Applies the search to the file 'Tags' available within
-            each Subject ID and to the subject-level 'Tags'.
-        TAGS is a comma separated list of strings. A session is provided as
-            long as one tag is available.
-        "pars_age_at_scan": Applies the search to the 'age_at_scan' metadata
-            field.
-        AGE_AT_SCAN is an integer.
-        "pars_[dicom]_KEY": Applies the search to the metadata fields
-            available within each file. KEY must be one of the
-        metadata keys of the files. The full list of KEYS is shown above via
-            'file_m["metadata"]["info"].keys()'.
-        KEYTYPE is the type of the KEY. One of:
-            - integer
-            - decimal
-            - string
-            - list
-
-            if 'integer' or 'decimal' you must also include an OPERATOR
-                (i.e., "integer;OPERATOR|KEYVALUE").
-            if 'list' the KEYVALUE should be a semicolon separated list of
-                values. (i.e., "list;KEYVALUE1;KEYVALUE2;KEYVALUE3)
-                KEYVALUEs must be strings.
-        KEYVALUE is the expected value of the KEY.
-        "pars_[dicom]_PROJECTMETADATA": Applies to the metadata defined
-            within the 'Metadata Manager' of the project.
-        PROJECTMETADATA is the ID of the metadata field.
-        METADATATYPE is the type of the metadata field. One of:
-            - string
-            - integer
-            - list
-            - decimal
-            - single_option
-            - multiple_option
-
-            if 'integer' or 'decimal' you must also include an OPERATOR
-                (i.e., "integer;OPERATOR|METADATAVALUE").
-        KEYVALUE is the expected value of the metadata.
+        data
+            The file chunk to upload
+        range_str
+            The string to send that describes the content range
+        length
+            The content length of the chunk to send
+        session_id
+            The session ID from the file path
+        filename
+            The name of the file to be sent
+        disposition
+            The disposition of the content
+        last_chunk
+            Set this only for the last chunk to be uploaded.
+            All following parameters are ignored when False.
+        split_data
+            Sets the header that informs the platform to split
+            the uploaded file into multiple sessions.
+        """
 
-        1) Example:
-        search_criteria = {
-            "pars_patient_secret_name": "string;abide",
-            "pars_ssid": "integer;eq|2"
+        request_headers = {
+            "Content-Type": "application/zip",
+            "Content-Range": range_str,
+            "Session-ID": str(session_id),
+            "Content-Length": str(length),
+            "Content-Disposition": disposition,
         }
 
-        2) Example:
-        search_criteria = {
-            "pars_modalities": "string;T1",
-            "pars_tags": "tags;flair",
-            "pars_[dicom]_Manufacturer": "string;ge",
-            "pars_[dicom]_FlipAngle": "integer;gt|5",
-            "pars_[dicom]_ImageType": "list;PRIMARY;SECONDARY",
-        }
+        if last_chunk:
+            request_headers["X-Mint-Name"] = name
+            request_headers["X-Mint-Date"] = date_of_scan
+            request_headers["X-Mint-Description"] = description
+            request_headers["X-Mint-Patient-Secret"] = subject_name
+            request_headers["X-Mint-SSID"] = ssid
+            request_headers["X-Mint-Filename"] = filename
+            request_headers["X-Mint-Project-Id"] = str(self._project_id)
+            request_headers["X-Mint-Split-Data"] = str(int(split_data))
 
-        Note the search criteria applies to all the files included within a
-            session. Hence, it does not imply that all the criteria conditions
-            are applied to the same files. In example 2) above, it means that
-            any Subject ID/Session ID that has a file classified with a 'T1'
-            modality, a file with a 'flair' tag, a file whose Manufacturer
-            contains 'ge', a file whose FlipAngle is greater than '5º', and a
-            file with ImageType with any of the values: PRIMARY or SECONDARY
-            will be selected.
+            if input_data_type:
+                request_headers["X-Mint-Type"] = input_data_type
 
-        Returns
-        -------
-        dict
-            A list of dictionary of {"metadata_name": "metadata_value"}
+                if result:
+                    request_headers["X-Mint-In-Out"] = "out"
+                else:
+                    request_headers["X-Mint-In-Out"] = "in"
 
-        """
+            if add_to_container_id > 0:
+                request_headers["X-Mint-Add-To"] = str(add_to_container_id)
 
-        assert len(items) == 2, f"The number of elements in items " f"'{len(items)}' should be equal to two."
-        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
+            request_headers["X-Requested-With"] = "XMLHttpRequest"
 
-        assert all([key[:5] == "pars_" for key in search_criteria.keys()]), (
-            f"All keys of the search_criteria dictionary " f"'{search_criteria.keys()}' must start with 'pars_'."
+        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
         )
 
-        for key, value in search_criteria.items():
-            if value.split(";")[0] in ["integer", "decimal"]:
-                assert value.split(";")[1].split("|")[0] in OPERATOR_LIST, (
-                    f"Search criteria of type '{value.split(';')[0]}' must "
-                    f"include an operator ({', '.join(OPERATOR_LIST)})."
-                )
-
-        content = platform.parse_response(
-            platform.post(
-                self._account.auth,
-                "patient_manager/get_patient_list",
-                data=search_criteria,
-                headers={"X-Range": f"items={items[0]}-{items[1]}"},
-            )
-        )
-        return content
+        return response
 
-    def get_subjects_files_metadata(self, search_criteria={}, items=(0, 9999)):
-        """
-        List all Subject ID/Session ID from the selected project that meet the
-            defined search criteria at a file level.
-
-        Note, albeit the search criteria is similar to the one defined in
-            method 'get_subjects_metadata()' (see differences below), the
-            output is different as this method provides the sessions which
-            have a file that satisfy all the conditions of the search criteria.
-            This method is slow.
+    def upload_file(
+        self,
+        file_path,
+        subject_name,
+        ssid="",
+        date_of_scan="",
+        description="",
+        result=False,
+        name="",
+        input_data_type="qmenta_mri_brain_data:1.0",
+        add_to_container_id=0,
+        chunk_size=2**9,
+        split_data=False,
+    ):
+        """
+        Upload a ZIP file to the platform.
 
         Parameters
         ----------
-        search_criteria: dict
-            Each element is a string and is built using the formatting
-            "type;value", or "type;operation|value"
-
-        Complete search_criteria Dictionary Explanation:
-
-        search_criteria = {
-            "pars_patient_secret_name": "string;SUBJECTID",
-            "pars_ssid": "integer;OPERATOR|SSID",
-            "pars_modalities": "string;MODALITY",
-            "pars_tags": "tags;TAGS",
-            "pars_age_at_scan": "integer;OPERATOR|AGE_AT_SCAN",
-            "pars_[dicom]_KEY": "KEYTYPE;KEYVALUE",
-            "pars_PROJECTMETADATA": "METADATATYPE;METADATAVALUE",
-            }
+        file_path : str
+            Path to the ZIP file to upload.
+        subject_name : str
+            Subject ID of the data to upload in the project in QMENTA Platform.
+        ssid : str
+            Session ID of the Subject ID (i.e., ID of the timepoint).
+        date_of_scan : str
+            Date of scan/creation of the file
+        description : str
+            Description of the file
+        result : bool
+            If result=True then the upload will be taken as an offline analysis
+        name : str
+            Name of the file in the platform
+        input_data_type : str
+            qmenta_medical_image_data:3.11
+        add_to_container_id : int
+            ID of the container to which this file should be added (if id > 0)
+        chunk_size : int
+            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)
+        split_data : bool
+            If True, the platform will try to split the uploaded file into
+            different sessions. It will be ignored when the ssid is given.
 
-        Where:
-        "pars_patient_secret_name": Applies the search to the 'Subject ID'.
-        SUBJECTID is a comma separated list of strings.
-        "pars_ssid": Applies the search to the 'Session ID'.
-        SSID is an integer.
-        OPERATOR is the operator to apply. One of:
-            - Equal: eq
-            - Different Than: ne
-            - Greater Than: gt
-            - Greater/Equal To: gte
-            - Lower Than: lt
-            - Lower/Equal To: lte
+        Returns
+        -------
+        bool
+            True if correctly uploaded, False otherwise.
+        """
 
-        "pars_modalities": Applies the search to the file 'Modalities'
-            available within each Subject ID.
-        MODALITY is a string.
-        "pars_tags": Applies only the search to the file 'Tags' available
-            within each Subject ID.
-        TAGS is a comma separated list of strings. All tags must be present in
-            the same file.
-        "pars_age_at_scan": Applies the search to the 'age_at_scan' metadata
-            field.
-        AGE_AT_SCAN is an integer.
-        "pars_[dicom]_KEY": Applies the search to the metadata fields
-            available within each file. KEY must be one of the
-        metadata keys of the files. The full list of KEYS is shown above via
-            'file_m["metadata"]["info"].keys()'.  # TODO: SEE HOW TO WRITE THIS
-        KEYTYPE is the type of the KEY. One of:
-            - integer
-            - decimal
-            - string
-            - list
+        filename = os.path.split(file_path)[1]
+        input_data_type = "offline_analysis:1.0" if result else input_data_type
 
-            if 'integer' or 'decimal' you must also include an OPERATOR
-                (i.e., "integer;OPERATOR|KEYVALUE").
-            if 'list' the KEYVALUE should be a semicolon separated list of
-                values. (i.e., "list;KEYVALUE1;KEYVALUE2;KEYVALUE3)
-                KEYVALUEs must be strings.
-        KEYVALUE is the expected value of the KEY.
-        "pars_[dicom]_PROJECTMETADATA": Applies to the metadata defined
-            within the 'Metadata Manager' of the project.
-        PROJECTMETADATA is the ID of the metadata field.
-        METADATATYPE is the type of the metadata field. One of:
-            - string
-            - integer
-            - list
-            - decimal
-            - single_option
-            - multiple_option
+        chunk_size *= 1024
+        max_retries = 10
 
-            if 'integer' or 'decimal' you must also include an OPERATOR
-                (i.e., "integer;OPERATOR|METADATAVALUE").
-        KEYVALUE is the expected value of the metadata.
+        name = name or os.path.split(file_path)[1]
 
-        1) Example:
-        search_criteria = {
-            "pars_patient_secret_name": "string;abide",
-            "pars_ssid": "integer;eq|2"
-        }
+        total_bytes = os.path.getsize(file_path)
 
-        2) Example:
-        search_criteria = {
-            "pars_patient_secret_name": "string;001"
-            "pars_modalities": "string;T2",
-            "pars_tags": "tags;flair",
-            "pars_[dicom]_Manufacturer": "string;ge",
-            "pars_[dicom]_FlipAngle": "integer;gt|5",
-            "pars_[dicom]_ImageType": "list;PRIMARY;SECONDARY",
-        }
+        # making chunks of the file and sending one by one
+        logger = logging.getLogger(logger_name)
+        with open(file_path, "rb") as file_object:
 
-        Note the search criteria might apply to both the files metadata
-            information available within a session and the metadata of the
-            session. And the method provides a session only if all the file
-            related conditions are satisfied within the same file.
-            In example 2) above, it means that the output will contain any
-            session whose Subject ID contains '001', and there is a file with
-            modality 'T2', tag 'flair', FlipAngle greater than 5º, and
-            ImageType with both values PRIMARY and SECONDARY.
-            Further, the acquisition had to be performed in a Manufacturer
-            containing 'ge'.
+            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
 
-        Returns
-        -------
-        dict
-            A list of dictionary of {"metadata_name": "metadata_value"}
+            if ssid and split_data:
+                logger.warning("split-data argument will be ignored because" + " ssid has been specified")
+                split_data = False
 
-        """
+            while True:
+                data = file_object.read(chunk_size)
+                if not data:
+                    break
 
-        content = self.get_subjects_metadata(search_criteria, items=(0, 9999))
+                start_position = chunk_num * chunk_size
+                end_position = start_position + chunk_size - 1
+                bytes_to_send = chunk_size
 
-        # Wrap search criteria.
-        modality, tags, dicoms = wrap_search_criteria(search_criteria)
+                if end_position >= total_bytes:
+                    last_chunk = True
+                    end_position = total_bytes - 1
+                    bytes_to_send = total_bytes - uploaded_bytes
 
-        # Iterate over the files of each subject selected to include/exclude
-        # them from the results.
-        subjects = list()
-        for subject in content:
-            files = platform.parse_response(platform.post(
-                self._account.auth, "file_manager/get_container_files",
-                data={"container_id": str(int(subject["container_id"]))}
-                ))
+                bytes_range = "bytes " + str(start_position) + "-" + str(end_position) + "/" + str(total_bytes)
 
-            for file in files["meta"]:
-                if modality and \
-                   modality != (file.get("metadata") or {}).get("modality"):
-                    continue
-                if tags and not all([tag in file.get("tags") for tag in tags]):
-                    continue
-                if dicoms:
-                    result_values = list()
-                    for key, dict_value in dicoms.items():
-                        f_value = ((file.get("metadata") or {})
-                                   .get("info") or {}).get(key)
-                        d_operator = dict_value["operation"]
-                        d_value = dict_value["value"]
-                        result_values.append(
-                            operation(d_value, d_operator, f_value)
-                        )
+                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,
+                )
 
-                    if not all(result_values):
-                        continue
-                subjects.append(subject)
-                break
-        return subjects
+                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
 
-    @property
-    def subjects(self):
-        """
-        Return the list of subject names (Subject ID) from the selected
-        project.
+                uploaded += chunk_size
+                self.__show_progress(uploaded, file_size)
 
-        :return: a list of subject names
-        :rtype: List(Strings)
-        """
+        try:
+            platform.parse_response(response)
+        except errors.PlatformError as error:
+            logger.error(error)
+            return False
 
-        subjects = self.subjects_metadata
-        names = [s["patient_secret_name"] for s in subjects]
-        return list(set(names))
+        message = "Your data was successfully uploaded."
+        message += "The uploaded file will be soon processed !"
+        logger.info(message)
+        return True
 
-    def check_subject_name(self, subject_name):
+    def upload_mri(self, file_path, subject_name):
         """
-        Check if a given subject name (Subject ID) exists in the selected
-        project.
+        Upload new MRI data to the subject.
 
         Parameters
         ----------
-        subject_name : str
-            Subject ID of the subject to check
+        file_path : str
+            Path to the file to upload
+        subject_name: str
 
         Returns
         -------
         bool
-            True if subject name exists in project, False otherwise
+            True if upload was correctly done, False otherwise.
         """
 
-        return subject_name in self.subjects
+        if self.__check_upload_file(file_path):
+            return self.upload_file(file_path, subject_name)
 
-    @property
-    def metadata_parameters(self):
+    def upload_gametection(self, file_path, subject_name):
         """
-        List all the parameters in the subject-level metadata.
+        Upload new Gametection data to the subject.
 
-        Each project has a set of parameters that define the subjects-level
-        metadata. This function returns all these parameters and its
-        properties. New subject-level metadata parameters can be creted in the
-        QMENTA Platform via the Metadata Manager. The API only allow
-        modification of these subject-level metadata parameters via the
-        'change_subject_metadata()' method.
+        Parameters
+        ----------
+        file_path : str
+            Path to the file to upload
+        subject_name: str
 
         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
-                 }}
+        bool
+            True if upload was correctly done, False otherwise.
         """
-        logger = logging.getLogger(logger_name)
-        try:
-            data = platform.parse_response(platform.post(self._account.auth, "patient_manager/module_config"))
-        except errors.PlatformError:
-            logger.error("Could not retrieve metadata parameters.")
-            return None
-        return data["fields"]
 
-    def get_analysis(self, analysis_name_or_id):
+        if self.__check_upload_file(file_path):
+            return self.upload_file(file_path, subject_name, input_data_type="parkinson_gametection")
+        return False
+
+    def upload_result(self, file_path, subject_name):
         """
-        Returns the analysis corresponding with the analysis id or analysis name
+        Upload new result data to the subject.
 
         Parameters
         ----------
-        analysis_name_or_id : int, str
-            analysis_id or analysis name to search for
+        file_path : str
+            Path to the file to upload
+        subject_name: str
 
         Returns
         -------
-        analysis: dict
-            A dictionary containing the analysis information
+        bool
+            True if upload was correctly done, False otherwise.
         """
-        if isinstance(analysis_name_or_id, int):
-            search_tag = "id"
-        elif isinstance(analysis_name_or_id, str):
-            if analysis_name_or_id.isdigit():
-                search_tag = "id"
-                analysis_name_or_id = int(analysis_name_or_id)
-            else:
-                search_tag = "p_n"
-        else:
-            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)
-        )
+        if self.__check_upload_file(file_path):
+            return self.upload_file(file_path, subject_name, result=True)
+        return False
 
-        if len(response) > 1:
-            raise Exception(f"multiple analyses with name " f"{analysis_name_or_id} found")
-        elif len(response) == 1:
-            return response[0]
-        else:
-            return None
+    def download_file(self, container_id, file_name, local_filename=False, overwrite=False):
+        """
+        Download a single file from a  specific container.
 
-    def list_analysis(self, search_condition={}, items=(0, 9999)):
+        Parameters
+        ----------
+        container_id : str
+            ID of the container inside which the file is.
+        file_name : str
+            Name of the file in the container.
+        local_filename : str
+            Name of the file to be created. By default, the same as file_name.
+        overwrite : bool
+            Whether to overwrite the file if existing.
         """
-        List the analysis available to the user.\n
+        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.")
 
-        Examples
-        --------
+        if file_name not in self.list_container_files(container_id):
+            msg = f'File "{file_name}" does not exist in container ' f"{container_id}"
+            logger.error(msg)
+            return False
 
-        >>> search_condition = {
-            "secret_name":"014_S_6920",
-            "from_d": "06.02.2025",
-            "with_child_analysis": 1,
-            "state": "completed"
-        }
-            list_analysis(search_condition=search_condition)
+        local_filename = local_filename or file_name
 
-        Parameters
-        ----------
-        search_condition : dict
-            - p_n: str or None Analysis name
-            - type: str or None Type
-            - from_d: str or None dd.mm.yyyy Date from
-            - to_d: str or None dd.mm.yyyy Date to
-            - qa_status: str or None pass/fail/nd QC status
-            - 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
-            - id: str or None ID
-            - state: running, completed, pending, exception or None
-            - username: str or None
+        if os.path.exists(local_filename) and not overwrite:
+            msg = f"File {local_filename} already exists"
+            logger.error(msg)
+            return False
 
-        items : List[int]
-            list containing two elements [min, max] that correspond to the
-            mininum and maximum range of analysis listed
+        params = {"container_id": container_id, "files": file_name}
 
-        Returns
-        -------
-        dict
-            List of analysis, each a dictionary
-        """
-        assert len(items) == 2, f"The number of elements in items " f"'{len(items)}' should be equal to two."
-        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
-        search_keys = {
-            "p_n": str,
-            "type": str,
-            "from_d": str,
-            "to_d": str,
-            "qa_status": str,
-            "secret_name": str,
-            "tags": str,
-            "with_child_analysis": int,
-            "id": int,
-            "state": str,
-            "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" f"is not type {search_keys[key]}"))
-        req_headers = {"X-Range": f"items={items[0]}-{items[1] - 1}"}
-        return platform.parse_response(
-            platform.post(
-                auth=self._account.auth,
-                endpoint="analysis_manager/get_analysis_list",
-                headers=req_headers,
-                data=search_condition,
-            )
-        )
+        with platform.post(
+            self._account.auth, "file_manager/download_file", data=params, stream=True
+        ) as response, open(local_filename, "wb") as f:
+
+            for chunk in response.iter_content(chunk_size=2**9 * 1024):
+                f.write(chunk)
+            f.flush()
+
+        logger.info(f"File {file_name} from container {container_id} saved to" f" {local_filename}")
+        return True
 
-    def get_subject_container_id(self, subject_name, ssid):
+    def download_files(self, container_id, filenames, zip_name="files.zip", overwrite=False):
         """
-        Given a Subject ID and Session ID, return its Container ID.
+        Download a set of files from a given container.
 
         Parameters
         ----------
-        subject_name : str
-            Subject ID of the subject in the project.
-        ssid : str
-            Session ID of the subject in the project.
-
-        Returns
-        -------
-        int or bool
-            The Container ID of the subject in the project, or False if
-            the subject is not found.
+        container_id : int
+            ID of the container inside which the file is.
+        filenames : list[str]
+            List of files to download.
+        overwrite : bool
+            Whether to overwrite the file if existing.
+        zip_name : str
+            Name of the zip where the downloaded files are stored.
         """
+        logger = logging.getLogger(logger_name)
 
-        search_criteria = {"s_n": subject_name, "ssid": ssid}
-        response = self.list_input_containers(search_criteria=search_criteria)
+        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.")
+        if not isinstance(zip_name, str):
+            raise ValueError("The name of the output ZIP file (zip_name) "
+                             "should be of type string.")
 
-        for subject in response:
-            if subject["patient_secret_name"] == subject_name and subject["ssid"] == ssid:
-                return subject["container_id"]
-        return False
+        files_not_in_container = list(filter(lambda f: f not in self.list_container_files(container_id), filenames))
 
-    def list_input_containers(self, search_criteria={}, items=(0, 9999)):
+        if files_not_in_container:
+            msg = (
+                f"The following files are missing in container " f"{container_id}: {', '.join(files_not_in_container)}"
+            )
+            logger.error(msg)
+            return False
+
+        if os.path.exists(zip_name) and not overwrite:
+            msg = f'File "{zip_name}" already exists'
+            logger.error(msg)
+            return False
+
+        params = {"container_id": container_id, "files": ";".join(filenames)}
+        with platform.post(
+            self._account.auth, "file_manager/download_file", data=params, stream=True
+        ) as response, open(zip_name, "wb") as f:
+
+            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))
+        return True
+
+    def copy_container_to_project(self, container_id, project_id):
         """
-        Retrieve the list of input containers available to the user under a
-        certain search criteria.
+        Copy a container to another project.
 
         Parameters
         ----------
-        search_criteria : dict
-            Each element is a string and is built using the formatting
-        "type;value".
-
-        List of possible keys:
-        d_n: container_name # TODO: WHAT IS THIS???
-        s_n: subject_id
-            Subject ID of the subject in the platform.
-        ssid: session_id
-            Session ID of the subejct in the platform.
-        from_d: from date
-            Starting date in which perform the search. Format: DD.MM.YYYY
-        to_d: to date
-            End date in which perform the search. Format: DD.MM.YYYY
-        sets: data sets (modalities)  # TODO: WHAT IS THIS???
-
-        items: Tuple(int, int)
-            Starting and ending element of the search.
+        container_id : int
+            ID of the container to copy.
+        project_id : int or str
+            ID of the project to retrieve, either the numeric ID or the name
 
         Returns
         -------
-        dict
-        List of containers, each a dictionary containing the following
-        information:
-            {"container_name", "container_id", "patient_secret_name", "ssid"}
+        bool
+            True on success, False on fail
         """
 
-        assert len(items) == 2, f"The number of elements in items " f"'{len(items)}' should be equal to two."
-        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
+        if type(project_id) == int or type(project_id) == float:
+            p_id = int(project_id)
+        elif type(project_id) == str:
+            projects = self._account.projects
+            projects_match = [proj for proj in projects if proj["name"] == project_id]
+            if not projects_match:
+                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")
+        data = {
+            "container_id": container_id,
+            "project_id": p_id,
+        }
 
-        response = platform.parse_response(
-            platform.post(
-                self._account.auth,
-                "file_manager/get_container_list",
-                data=search_criteria,
-                headers={"X-Range": f"items={items[0]}-{items[1]}"},
+        try:
+            platform.parse_response(
+                platform.post(self._account.auth, "file_manager/copy_container_to_another_project", data=data)
             )
-        )
-        containers = [
-            {
-                "patient_secret_name": container_item["patient_secret_name"],
-                "container_name": container_item["name"],
-                "container_id": container_item["_id"],
-                "ssid": container_item["ssid"],
-            }
-            for container_item in response
-        ]
-        return containers
+        except errors.PlatformError as e:
+            logging.getLogger(logger_name).error("Couldn not copy container: {}".format(e))
+            return False
 
-    def list_result_containers(self, search_condition={}, items=(0, 9999)):
+        return True
+
+    """ Subject/Session Related Methods """
+    @property
+    def subjects(self):
         """
-        List the result containers available to the user.
-        Examples
-        --------
+        Return the list of subject names (Subject ID) from the selected
+        project.
 
-        >>> search_condition = {
-            "secret_name":"014_S_6920",
-            "from_d": "06.02.2025",
-            "with_child_analysis": 1,
-            "state": "completed"
-        }
-            list_result_containers(search_condition=search_condition)
+        :return: a list of subject names
+        :rtype: List(Strings)
+        """
 
-        Parameters
-        ----------
-        search_condition : dict
-            - p_n: str or None Analysis name
-            - type: str or None Type
-            - from_d: str or None dd.mm.yyyy Date from
-            - to_d: str or None dd.mm.yyyy Date to
-            - qa_status: str or None pass/fail/nd QC status
-            - 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
-            - id: str or None ID
-            - state: running, completed, pending, exception or None
-            - username: str or None
-        items : List[int]
-            list containing two elements [min, max] that correspond to the
-            mininum and maximum range of analysis listed
+        subjects = self.subjects_metadata
+        names = [s["patient_secret_name"] for s in subjects]
+        return list(set(names))
+
+    @property
+    def subjects_metadata(self):
+        """
+        List all subject data from the selected project.
 
         Returns
         -------
         dict
-            List of containers, each a dictionary
-            {"name": "container-name", "id": "container_id"}
-            if "id": None, that analysis did not had an output container,
-            probably it is a workflow
+            A list of dictionary of {"metadata_name": "metadata_value"}
         """
-        analyses = self.list_analysis(search_condition, items)
-        return [{"name": analysis["name"], "id": (analysis.get("out_container_id") or None)} for analysis in analyses]
+        return self.get_subjects_metadata()
 
-    def list_container_files(
-        self,
-        container_id,
-    ):
+    @property
+    def metadata_parameters(self):
         """
-        List the name of the files available inside a given container.
-        Parameters
-        ----------
-        container_id : str or int
-            Container identifier.
+        List all the parameters in the subject-level metadata.
+
+        Each project has a set of parameters that define the subjects-level
+        metadata. This function returns all these parameters and its
+        properties. New subject-level metadata parameters can be creted in the
+        QMENTA Platform via the Metadata Manager. The API only allow
+        modification of these subject-level metadata parameters via the
+        'change_subject_metadata()' method.
 
         Returns
         -------
-        list[str]
-            List of file names (strings)
+        dict[str] -> dict[str] -> x
+            dictionary {"param_name":
+                 { "order": Int,
+                 "tags": [tag1, tag2, ..., ],
+                 "title: "Title",
+                 "type": "integer|string|date|list|decimal",
+                 "visible": 0|1
+                 }}
         """
+        logger = logging.getLogger(logger_name)
         try:
-            content = platform.parse_response(
-                platform.post(
-                    self._account.auth, "file_manager/get_container_files", data={"container_id": container_id}
-                )
-            )
-        except errors.PlatformError as e:
-            logging.getLogger(logger_name).error(e)
-            return False
-        if "files" not in content.keys():
-            logging.getLogger(logger_name).error("Could not get files")
-            return False
-        return content["files"]
+            data = platform.parse_response(platform.post(self._account.auth, "patient_manager/module_config"))
+        except errors.PlatformError:
+            logger.error("Could not retrieve metadata parameters.")
+            return None
+        return data["fields"]
 
-    def list_container_filter_files(
-        self,
-        container_id,
-        modality="",
-        metadata_info={},
-        tags=[]
-    ):
+    def check_subject_name(self, subject_name):
         """
-        List the name of the files available inside a given container.
-        search condition example:
-        "metadata": {"SliceThickness":1},
-        }
+        Check if a given subject name (Subject ID) exists in the selected
+        project.
+
         Parameters
         ----------
-        container_id : str or int
-            Container identifier.
-
-        modality: str
-            String containing the modality of the files being filtered
-
-        metadata_info: dict
-            Dictionary containing the file metadata of the files being filtered
-
-        tags: list[str]
-            List of strings containing the tags of the files being filtered
+        subject_name : str
+            Subject ID of the subject to check
 
         Returns
         -------
-        selected_files: list[str]
-            List of file names (strings)
+        bool
+            True if subject name exists in project, False otherwise
         """
-        content_files = self.list_container_files(container_id)
-        content_meta = self.list_container_files_metadata(container_id)
-        selected_files = []
-        for index, file in enumerate(content_files):
-            metadata_file = content_meta[index]
-            tags_file = metadata_file.get("tags")
-            tags_bool = [tag in tags_file for tag in tags]
-            info_bool = []
-            if modality == "":
-                modality_bool = True
-            else:
-                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
-                    )
-                if meta_key is None:
-                    logging.getLogger(logger_name).warning(
-                        f"{key} is not in file_info from file {file}"
-                    )
-                info_bool.append(
-                    metadata_info[key] == meta_key
-                    )
-            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):
+        return subject_name in self.subjects
+
+    def get_subject_container_id(self, subject_name, ssid):
         """
-        List all the metadata of the files available inside a given container.
+        Given a Subject ID and Session ID, return its Container ID.
 
         Parameters
         ----------
-        container_id : str
-            Container identifier.
+        subject_name : str
+            Subject ID of the subject in the project.
+        ssid : str
+            Session ID of the subject in the project.
 
         Returns
         -------
-        dict
-            Dictionary of {"metadata_name": "metadata_value"}
+        int or bool
+            The Container ID of the subject in the project, or False if
+            the subject is not found.
         """
 
-        try:
-            data = platform.parse_response(
-                platform.post(
-                    self._account.auth, "file_manager/get_container_files", data={"container_id": container_id}
-                )
-            )
-        except errors.PlatformError as e:
-            logging.getLogger(logger_name).error(e)
-            return False
+        search_criteria = {"s_n": subject_name, "ssid": ssid}
+        response = self.list_input_containers(search_criteria=search_criteria)
 
-        return data["meta"]
+        for subject in response:
+            if subject["patient_secret_name"] == subject_name and subject["ssid"] == ssid:
+                return subject["container_id"]
+        return False
 
-    def get_file_metadata(self, container_id, filename):
+    def get_subject_id(self, subject_name, ssid):
         """
-        Retrieve the metadata from a particular file in a particular container.
+        Given a Subject ID and Session ID, return its Patient ID in the
+        project.
 
         Parameters
         ----------
-        container_id : str
-            Container identifier.
-        filename : str
-            Name of the file.
+        subject_name : str
+            Subject ID of the subject in the project.
+        ssid : str
+            Session ID of the subject in the project.
 
         Returns
         -------
-        dict
-            Dictionary with the metadata. False otherwise.
+        int or bool
+            The ID of the subject in the project, or False if
+            the subject is not found.
         """
-        all_metadata = self.list_container_files_metadata(container_id)
-        if all_metadata:
-            for file_meta in all_metadata:
-                if file_meta["name"] == filename:
-                    return file_meta
-        else:
-            return False
 
-    def change_file_metadata(self, container_id, filename, modality, tags):
+        for user in self.get_subjects_metadata():
+            if user["patient_secret_name"] == str(subject_name) and user["ssid"] == str(ssid):
+                return int(user["_id"])
+        return False
+
+    def get_subjects_metadata(self, search_criteria={}, items=(0, 9999)):
         """
-        Change modality and tags of `filename` in `container_id`
+        List all Subject ID/Session ID from the selected project that meet the
+            defined search criteria at a session level.
 
         Parameters
         ----------
-        container_id : int
-            Container identifier.
-        filename : str
-            Name of the file to be edited.
-        modality : str or None
-            Modality identifier, or None if the file shouldn't have
-            any modality
-        tags : list[str] or None
-            List of tags, or None if the filename shouldn't have any tags
+        search_criteria: dict
+            Each element is a string and is built using the formatting
+            "type;value", or "type;operation|value"
+
+        Complete search_criteria Dictionary Explanation:
+
+        search_criteria = {
+            "pars_patient_secret_name": "string;SUBJECTID",
+            "pars_ssid": "integer;OPERATOR|SSID",
+            "pars_modalities": "string;MODALITY",
+            "pars_tags": "tags;TAGS",
+            "pars_age_at_scan": "integer;OPERATOR|AGE_AT_SCAN",
+            "pars_[dicom]_KEY": "KEYTYPE;KEYVALUE",
+            "pars_PROJECTMETADATA": "METADATATYPE;METADATAVALUE",
+            }
+
+        Where:
+        "pars_patient_secret_name": Applies the search to the 'Subject ID'.
+        SUBJECTID is a comma separated list of strings.
+        "pars_ssid": Applies the search to the 'Session ID'.
+        SSID is an integer.
+        OPERATOR is the operator to apply. One of:
+            - Equal: eq
+            - Different Than: ne
+            - Greater Than: gt
+            - Greater/Equal To: gte
+            - Lower Than: lt
+            - Lower/Equal To: lte
+
+        "pars_modalities": Applies the search to the file 'Modalities'
+            available within each Subject ID.
+        MODALITY is a comma separated list of string. A session is provided as
+            long as one MODALITY is available.
+        "pars_tags": Applies the search to the file 'Tags' available within
+            each Subject ID and to the subject-level 'Tags'.
+        TAGS is a comma separated list of strings. A session is provided as
+            long as one tag is available.
+        "pars_age_at_scan": Applies the search to the 'age_at_scan' metadata
+            field.
+        AGE_AT_SCAN is an integer.
+        "pars_[dicom]_KEY": Applies the search to the metadata fields
+            available within each file. KEY must be one of the
+            metadata keys of the files. The full list of KEYS for a given
+            file is shown in the QMENTA Platform within the File Information
+            of such File.
+        KEYTYPE is the type of the KEY. One of:
+            - integer
+            - decimal
+            - string
+            - list
+
+            if 'integer' or 'decimal' you must also include an OPERATOR
+                (i.e., "integer;OPERATOR|KEYVALUE").
+            if 'list' the KEYVALUE should be a semicolon separated list of
+                values. (i.e., "list;KEYVALUE1;KEYVALUE2;KEYVALUE3)
+                KEYVALUEs must be strings.
+        KEYVALUE is the expected value of the KEY.
+        "pars_[dicom]_PROJECTMETADATA": Applies to the metadata defined
+            within the 'Metadata Manager' of the project.
+        PROJECTMETADATA is the ID of the metadata field.
+        METADATATYPE is the type of the metadata field. One of:
+            - string
+            - integer
+            - list
+            - decimal
+            - single_option
+            - multiple_option
+
+            if 'integer' or 'decimal' you must also include an OPERATOR
+                (i.e., "integer;OPERATOR|METADATAVALUE").
+        KEYVALUE is the expected value of the metadata.
+
+        1) Example:
+        search_criteria = {
+            "pars_patient_secret_name": "string;abide",
+            "pars_ssid": "integer;eq|2"
+        }
+
+        2) Example:
+        search_criteria = {
+            "pars_modalities": "string;T1",
+            "pars_tags": "tags;flair",
+            "pars_[dicom]_Manufacturer": "string;ge",
+            "pars_[dicom]_FlipAngle": "integer;gt|5",
+            "pars_[dicom]_ImageType": "list;PRIMARY;SECONDARY",
+        }
+
+        Note the search criteria applies to all the files included within a
+            session. Hence, it does not imply that all the criteria conditions
+            are applied to the same files. In example 2) above, it means that
+            any Subject ID/Session ID that has a file classified with a 'T1'
+            modality, a file with a 'flair' tag, a file whose Manufacturer
+            contains 'ge', a file whose FlipAngle is greater than '5º', and a
+            file with ImageType with any of the values: PRIMARY or SECONDARY
+            will be selected.
+
+        Returns
+        -------
+        dict
+            A list of dictionary of {"metadata_name": "metadata_value"}
+
         """
 
-        tags_str = "" if tags is None else ";".join(tags)
-        platform.parse_response(
+        assert len(items) == 2, f"The number of elements in items " f"'{len(items)}' should be equal to two."
+        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
+
+        assert all([key[:5] == "pars_" for key in search_criteria.keys()]), (
+            f"All keys of the search_criteria dictionary " f"'{search_criteria.keys()}' must start with 'pars_'."
+        )
+
+        for key, value in search_criteria.items():
+            if value.split(";")[0] in ["integer", "decimal"]:
+                assert value.split(";")[1].split("|")[0] in OPERATOR_LIST, (
+                    f"Search criteria of type '{value.split(';')[0]}' must "
+                    f"include an operator ({', '.join(OPERATOR_LIST)})."
+                )
+
+        content = platform.parse_response(
             platform.post(
                 self._account.auth,
-                "file_manager/edit_file",
-                data={"container_id": container_id, "filename": filename, "tags": tags_str, "modality": modality},
+                "patient_manager/get_patient_list",
+                data=search_criteria,
+                headers={"X-Range": f"items={items[0]}-{items[1]}"},
             )
         )
+        return content
+
+    def change_subject_metadata(self, patient_id, subject_name, ssid, tags, age_at_scan, metadata):
+        """
+        Change the Subject ID, Session ID, Tags, Age at Scan and Metadata of
+        the session with Patient ID
+
+        Parameters
+        ----------
+        patient_id : Integer
+            Patient ID representing the session to modify.
+        subject_name : String
+            Represents the new Subject ID.
+        ssid : String
+            Represents the new Session ID.
+        tags : list of strings in lowercase
+            Represents the new tags of the session.
+        age_at_scan : Integer
+            Represents the new Age at Scan of the Session.
+        metadata : Dictionary
+            Each pair key/value representing the new metadata values.
+
+            The keys must either all start with "md\\_" or none start
+            with "md\\_".
 
-    def download_file(self, container_id, file_name, local_filename=False, overwrite=False):
-        """
-        Download a single file from a  specific container.
+            The key represents the ID of the metadata field.
 
-        Parameters
-        ----------
-        container_id : str
-            ID of the container inside which the file is.
-        file_name : str
-            Name of the file in the container.
-        local_filename : str
-            Name of the file to be created. By default, the same as file_name.
-        overwrite : bool
-            Whether to overwrite the file if existing.
+        Returns
+        -------
+        bool
+            True if correctly modified, False otherwise
         """
         logger = logging.getLogger(logger_name)
-        if file_name not in self.list_container_files(container_id):
-            msg = f'File "{file_name}" does not exist in container ' f"{container_id}"
-            logger.error(msg)
-            return False
 
-        local_filename = local_filename or file_name
+        try:
+            patient_id = str(int(patient_id))
+        except ValueError:
+            raise ValueError(f"'patient_id': '{patient_id}' not valid. " f"Must be convertible to int.")
 
-        if os.path.exists(local_filename) and not overwrite:
-            msg = f"File {local_filename} already exists"
-            logger.error(msg)
-            return False
+        assert isinstance(tags, list) and all(
+            isinstance(item, str) for item in tags
+        ), f"tags: '{tags}' should be a list of strings."
+        tags = [tag.lower() for tag in tags]
 
-        params = {"container_id": container_id, "files": file_name}
+        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."
 
-        with platform.post(
-            self._account.auth, "file_manager/download_file", data=params, stream=True
-        ) as response, open(local_filename, "wb") as f:
+        try:
+            age_at_scan = str(int(age_at_scan)) if age_at_scan else None
+        except ValueError:
+            raise ValueError(f"age_at_scan: '{age_at_scan}' not valid. " f"Must be an integer.")
 
-            for chunk in response.iter_content(chunk_size=2**9 * 1024):
-                f.write(chunk)
-            f.flush()
+        assert isinstance(metadata, dict), f"metadata: '{metadata}' should be a dictionary."
 
-        logger.info(f"File {file_name} from container {container_id} saved to" f" {local_filename}")
+        assert all("md_" == key[:3] for key in metadata.keys()) or all("md_" != key[:3] for key in metadata.keys()), (
+            f"metadata: '{metadata}' must be a dictionary whose keys " f"are either all starting with 'md_' or none."
+        )
+
+        metadata_keys = self.metadata_parameters.keys()
+        assert all(
+            [key[3:] in metadata_keys if "md_" == key[:3] else key in metadata_keys for key in metadata.keys()]
+        ), (
+            f"Some metadata keys provided ({', '.join(metadata.keys())}) "
+            f"are not available in the project. They can be added via the "
+            f"Metadata Manager via the QMENTA Platform graphical user "
+            f"interface (GUI)."
+        )
+
+        post_data = {
+            "patient_id": patient_id,
+            "secret_name": str(subject_name),
+            "ssid": str(ssid),
+            "tags": ",".join(tags),
+            "age_at_scan": age_at_scan,
+        }
+        for key, value in metadata.items():
+            id = key[3:] if "md_" == key[:3] else key
+            post_data[f"last_vals.{id}"] = value
+
+        try:
+            platform.parse_response(platform.post(self._account.auth, "patient_manager/upsert_patient", data=post_data))
+        except errors.PlatformError:
+            logger.error(f"Patient ID '{patient_id}' could not be modified.")
+            return False
+
+        logger.info(f"Patient ID '{patient_id}' successfully modified.")
         return True
 
-    def download_files(self, container_id, filenames, zip_name="files.zip", overwrite=False):
+    def get_subjects_files_metadata(self, search_criteria={}, items=(0, 9999)):
         """
-        Download a set of files from a given container.
+        List all Subject ID/Session ID from the selected project that meet the
+            defined search criteria at a file level.
+
+        Note, albeit the search criteria is similar to the one defined in
+            method 'get_subjects_metadata()' (see differences below), the
+            output is different as this method provides the sessions which
+            have a file that satisfy all the conditions of the search criteria.
+            This method is slow.
 
         Parameters
         ----------
-        container_id : int
-            ID of the container inside which the file is.
-        filenames : list[str]
-            List of files to download.
-        overwrite : bool
-            Whether to overwrite the file if existing.
-        zip_name : str
-            Name of the zip where the downloaded files are stored.
-        """
-        logger = logging.getLogger(logger_name)
-        files_not_in_container = list(filter(lambda f: f not in self.list_container_files(container_id), filenames))
+        search_criteria: dict
+            Each element is a string and is built using the formatting
+            "type;value", or "type;operation|value"
 
-        if files_not_in_container:
-            msg = (
-                f"The following files are missing in container " f"{container_id}: {', '.join(files_not_in_container)}"
-            )
-            logger.error(msg)
-            return False
+        Complete search_criteria Dictionary Explanation:
 
-        if os.path.exists(zip_name) and not overwrite:
-            msg = f'File "{zip_name}" already exists'
-            logger.error(msg)
-            return False
+        search_criteria = {
+            "pars_patient_secret_name": "string;SUBJECTID",
+            "pars_ssid": "integer;OPERATOR|SSID",
+            "pars_modalities": "string;MODALITY",
+            "pars_tags": "tags;TAGS",
+            "pars_age_at_scan": "integer;OPERATOR|AGE_AT_SCAN",
+            "pars_[dicom]_KEY": "KEYTYPE;KEYVALUE",
+            "pars_PROJECTMETADATA": "METADATATYPE;METADATAVALUE",
+            }
 
-        params = {"container_id": container_id, "files": ";".join(filenames)}
-        with platform.post(
-            self._account.auth, "file_manager/download_file", data=params, stream=True
-        ) as response, open(zip_name, "wb") as f:
+        Where:
+        "pars_patient_secret_name": Applies the search to the 'Subject ID'.
+        SUBJECTID is a comma separated list of strings.
+        "pars_ssid": Applies the search to the 'Session ID'.
+        SSID is an integer.
+        OPERATOR is the operator to apply. One of:
+            - Equal: eq
+            - Different Than: ne
+            - Greater Than: gt
+            - Greater/Equal To: gte
+            - Lower Than: lt
+            - Lower/Equal To: lte
 
-            for chunk in response.iter_content(chunk_size=2**9 * 1024):
-                f.write(chunk)
-            f.flush()
+        "pars_modalities": Applies the search to the file 'Modalities'
+            available within each Subject ID.
+        MODALITY is a string.
+        "pars_tags": Applies only the search to the file 'Tags' available
+            within each Subject ID.
+        TAGS is a comma separated list of strings. All tags must be present in
+            the same file.
+        "pars_age_at_scan": Applies the search to the 'age_at_scan' metadata
+            field.
+        AGE_AT_SCAN is an integer.
+        "pars_[dicom]_KEY": Applies the search to the metadata fields
+            available within each file. KEY must be one of the
+        metadata keys of the files. The full list of KEYS for a given
+            file is shown in the QMENTA Platform within the File Information
+            of such File.
+        KEYTYPE is the type of the KEY. One of:
+            - integer
+            - decimal
+            - string
+            - list
 
-        logger.info("Files from container {} saved to {}".format(container_id, zip_name))
-        return True
+            if 'integer' or 'decimal' you must also include an OPERATOR
+                (i.e., "integer;OPERATOR|KEYVALUE").
+            if 'list' the KEYVALUE should be a semicolon separated list of
+                values. (i.e., "list;KEYVALUE1;KEYVALUE2;KEYVALUE3)
+                KEYVALUEs must be strings.
+        KEYVALUE is the expected value of the KEY.
+        "pars_[dicom]_PROJECTMETADATA": Applies to the metadata defined
+            within the 'Metadata Manager' of the project.
+        PROJECTMETADATA is the ID of the metadata field.
+        METADATATYPE is the type of the metadata field. One of:
+            - string
+            - integer
+            - list
+            - decimal
+            - single_option
+            - multiple_option
 
-    def get_subject_id(self, subject_name, ssid):
-        """
-        Given a Subject ID and Session ID, return its Patient ID in the
-        project.
+            if 'integer' or 'decimal' you must also include an OPERATOR
+                (i.e., "integer;OPERATOR|METADATAVALUE").
+        KEYVALUE is the expected value of the metadata.
 
-        Parameters
-        ----------
-        subject_name : str
-            Subject ID of the subject in the project.
-        ssid : str
-            Session ID of the subject in the project.
+        1) Example:
+        search_criteria = {
+            "pars_patient_secret_name": "string;abide",
+            "pars_ssid": "integer;eq|2"
+        }
+
+        2) Example:
+        search_criteria = {
+            "pars_patient_secret_name": "string;001"
+            "pars_modalities": "string;T2",
+            "pars_tags": "tags;flair",
+            "pars_[dicom]_Manufacturer": "string;ge",
+            "pars_[dicom]_FlipAngle": "integer;gt|5",
+            "pars_[dicom]_ImageType": "list;PRIMARY;SECONDARY",
+        }
+
+        Note the search criteria might apply to both the files metadata
+            information available within a session and the metadata of the
+            session. And the method provides a session only if all the file
+            related conditions are satisfied within the same file.
+            In example 2) above, it means that the output will contain any
+            session whose Subject ID contains '001', and there is a file with
+            modality 'T2', tag 'flair', FlipAngle greater than 5º, and
+            ImageType with both values PRIMARY and SECONDARY.
+            Further, the acquisition had to be performed in a Manufacturer
+            containing 'ge'.
 
         Returns
         -------
-        int or bool
-            The ID of the subject in the project, or False if
-            the subject is not found.
+        dict
+            A list of dictionary of {"metadata_name": "metadata_value"}
+
         """
 
-        for user in self.get_subjects_metadata():
-            if user["patient_secret_name"] == str(subject_name) and user["ssid"] == str(ssid):
-                return int(user["_id"])
-        return False
+        content = self.get_subjects_metadata(search_criteria, items=(0, 9999))
+
+        # Wrap search criteria.
+        modality, tags, dicoms = self.__wrap_search_criteria(search_criteria)
+
+        # Iterate over the files of each subject selected to include/exclude
+        # them from the results.
+        subjects = list()
+        for subject in content:
+            files = platform.parse_response(platform.post(
+                self._account.auth, "file_manager/get_container_files",
+                data={"container_id": str(int(subject["container_id"]))}
+                ))
+
+            for file in files["meta"]:
+                if modality and \
+                   modality != (file.get("metadata") or {}).get("modality"):
+                    continue
+                if tags and not all([tag in file.get("tags") for tag in tags]):
+                    continue
+                if dicoms:
+                    result_values = list()
+                    for key, dict_value in dicoms.items():
+                        f_value = ((file.get("metadata") or {})
+                                   .get("info") or {}).get(key)
+                        d_operator = dict_value["operation"]
+                        d_value = dict_value["value"]
+                        result_values.append(
+                            self.__operation(d_value, d_operator, f_value)
+                        )
 
-    def change_subject_metadata(self, patient_id, subject_name, ssid, tags, age_at_scan, metadata):
+                    if not all(result_values):
+                        continue
+                subjects.append(subject)
+                break
+        return subjects
+
+    def get_file_metadata(self, container_id, filename):
         """
-        Change the Subject ID, Session ID, Tags, Age at Scan and Metadata of
-        the session with Patient ID
+        Retrieve the metadata from a particular file in a particular container.
 
         Parameters
         ----------
-        patient_id : Integer
-            Patient ID representing the session to modify.
-        subject_name : String
-            Represents the new Subject ID.
-        ssid : String
-            Represents the new Session ID.
-        tags : list of strings in lowercase
-            Represents the new tags of the session.
-        age_at_scan : Integer
-            Represents the new Age at Scan of the Session.
-        metadata : Dictionary
-            Each pair key/value representing the new metadata values.
-
-            The keys must either all start with "md\\_" or none start
-            with "md\\_".
-
-            The key represents the ID of the metadata field.
+        container_id : str
+            Container identifier.
+        filename : str
+            Name of the file.
 
         Returns
         -------
-        bool
-            True if correctly modified, False otherwise
+        dict
+            Dictionary with the metadata. False otherwise.
         """
-        logger = logging.getLogger(logger_name)
-
-        try:
-            patient_id = str(int(patient_id))
-        except ValueError:
-            raise ValueError(f"'patient_id': '{patient_id}' not valid. " f"Must be convertible to int.")
-
-        assert isinstance(tags, list) and all(
-            isinstance(item, str) for item in tags
-        ), f"tags: '{tags}' should be a list of strings."
-        tags = [tag.lower() for tag in tags]
-
-        assert subject_name is not None and subject_name != "", "subject_name must be a non empty string."
-        assert ssid is not None and ssid != "", "ssid must be a non empty string."
-
-        try:
-            age_at_scan = str(int(age_at_scan)) if age_at_scan else None
-        except ValueError:
-            raise ValueError(f"age_at_scan: '{age_at_scan}' not valid. " f"Must be an integer.")
+        all_metadata = self.list_container_files_metadata(container_id)
+        if all_metadata:
+            for file_meta in all_metadata:
+                if file_meta["name"] == filename:
+                    return file_meta
+        else:
+            return False
 
-        assert isinstance(metadata, dict), f"metadata: '{metadata}' should be a dictionary."
+    def change_file_metadata(self, container_id, filename, modality, tags):
+        """
+        Change modality and tags of `filename` in `container_id`
 
-        assert all("md_" == key[:3] for key in metadata.keys()) or all("md_" != key[:3] for key in metadata.keys()), (
-            f"metadata: '{metadata}' must be a dictionary whose keys " f"are either all starting with 'md_' or none."
-        )
+        Parameters
+        ----------
+        container_id : int
+            Container identifier.
+        filename : str
+            Name of the file to be edited.
+        modality : str or None
+            Modality identifier, or None if the file shouldn't have
+            any modality
+        tags : list[str] or None
+            List of tags, or None if the filename shouldn't have any tags
+        """
 
-        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)."
+        tags_str = "" if tags is None else ";".join(tags)
+        platform.parse_response(
+            platform.post(
+                self._account.auth,
+                "file_manager/edit_file",
+                data={"container_id": container_id, "filename": filename, "tags": tags_str, "modality": modality},
+            )
         )
 
-        post_data = {
-            "patient_id": patient_id,
-            "secret_name": str(subject_name),
-            "ssid": str(ssid),
-            "tags": ",".join(tags),
-            "age_at_scan": age_at_scan,
-        }
-        for key, value in metadata.items():
-            id = key[3:] if "md_" == key[:3] else key
-            post_data[f"last_vals.{id}"] = value
-
-        try:
-            platform.parse_response(platform.post(self._account.auth, "patient_manager/upsert_patient", data=post_data))
-        except errors.PlatformError:
-            logger.error(f"Patient ID '{patient_id}' could not be modified.")
-            return False
-
-        logger.info(f"Patient ID '{patient_id}' successfully modified.")
-        return True
-
     def delete_session(self, subject_name, session_id):
         """
         Delete a session from a subject within a project providing the
@@ -1305,424 +1160,420 @@ class Project:
         session = session_to_del[0]
 
         try:
-            platform.parse_response(
-                platform.post(
-                    self._account.auth,
-                    "patient_manager/delete_patient",
-                    data={"patient_id": str(int(session["_id"])), "delete_files": 1},
-                )
-            )
-        except errors.PlatformError:
-            logger.error(f"Session \"{subject_name}/{session['ssid']}\" could" f" not be deleted.")
-            return False
-
-        logger.info(f"Session \"{subject_name}/{session['ssid']}\" successfully " f"deleted.")
-        return True
-
-    def delete_session_by_patientid(self, patient_id):
-        """
-        Delete a session from a subject within a project providing the
-        Patient ID.
-
-        Parameters
-        ----------
-        patient_id : str
-            Patient ID of the Session ID/Subject ID
-
-        Returns
-        -------
-        bool
-            True if correctly deleted, False otherwise.
-        """
-        logger = logging.getLogger(logger_name)
-
-        try:
-            platform.parse_response(
-                platform.post(
-                    self._account.auth,
-                    "patient_manager/delete_patient",
-                    data={"patient_id": str(int(patient_id)), "delete_files": 1},
-                )
-            )
-        except errors.PlatformError:
-            logger.error(f"Patient ID {patient_id} could not be deleted.")
-            return False
-
-        logger.info(f"Patient ID {patient_id} successfully deleted.")
-        return True
-
-    def delete_subject(self, subject_name):
-        """
-        Delete a subject from the project. It deletes all its available
-        sessions only providing the Subject ID.
-
-        Parameters
-        ----------
-        subject_name : str
-            Subject ID of the subject to be deleted.
-
-        Returns
-        -------
-        bool
-            True if correctly deleted, False otherwise.
-        """
-
-        logger = logging.getLogger(logger_name)
-        # 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]
-
-        if not sessions_to_del:
-            logger.error("Subject {} cannot be found in this project.".format(subject_name))
-            return False
-
-        for ssid in [s["ssid"] for s in sessions_to_del]:
-            if not self.delete_session(subject_name, ssid):
-                return False
-        return True
-
-    def _upload_chunk(
-        self,
-        data,
-        range_str,
-        length,
-        session_id,
-        disposition,
-        last_chunk,
-        name="",
-        date_of_scan="",
-        description="",
-        subject_name="",
-        ssid="",
-        filename="DATA.zip",
-        input_data_type="mri_brain_data:1.0",
-        result=False,
-        add_to_container_id=0,
-        split_data=False,
-    ):
-        """
-        Upload a chunk of a file to the platform.
-
-        Parameters
-        ----------
-        data
-            The file chunk to upload
-        range_str
-            The string to send that describes the content range
-        length
-            The content length of the chunk to send
-        session_id
-            The session ID from the file path
-        filename
-            The name of the file to be sent
-        disposition
-            The disposition of the content
-        last_chunk
-            Set this only for the last chunk to be uploaded.
-            All following parameters are ignored when False.
-        split_data
-            Sets the header that informs the platform to split
-            the uploaded file into multiple sessions.
-        """
-
-        request_headers = {
-            "Content-Type": "application/zip",
-            "Content-Range": range_str,
-            "Session-ID": str(session_id),
-            "Content-Length": str(length),
-            "Content-Disposition": disposition,
-        }
-
-        if last_chunk:
-            request_headers["X-Mint-Name"] = name
-            request_headers["X-Mint-Date"] = date_of_scan
-            request_headers["X-Mint-Description"] = description
-            request_headers["X-Mint-Patient-Secret"] = subject_name
-            request_headers["X-Mint-SSID"] = ssid
-            request_headers["X-Mint-Filename"] = filename
-            request_headers["X-Mint-Project-Id"] = str(self._project_id)
-            request_headers["X-Mint-Split-Data"] = str(int(split_data))
+            platform.parse_response(
+                platform.post(
+                    self._account.auth,
+                    "patient_manager/delete_patient",
+                    data={"patient_id": str(int(session["_id"])), "delete_files": 1},
+                )
+            )
+        except errors.PlatformError:
+            logger.error(f"Session \"{subject_name}/{session['ssid']}\" could" f" not be deleted.")
+            return False
 
-            if input_data_type:
-                request_headers["X-Mint-Type"] = input_data_type
+        logger.info(f"Session \"{subject_name}/{session['ssid']}\" successfully " f"deleted.")
+        return True
 
-                if result:
-                    request_headers["X-Mint-In-Out"] = "out"
-                else:
-                    request_headers["X-Mint-In-Out"] = "in"
+    def delete_session_by_patientid(self, patient_id):
+        """
+        Delete a session from a subject within a project providing the
+        Patient ID.
 
-            if add_to_container_id > 0:
-                request_headers["X-Mint-Add-To"] = str(add_to_container_id)
+        Parameters
+        ----------
+        patient_id : str
+            Patient ID of the Session ID/Subject ID
 
-            request_headers["X-Requested-With"] = "XMLHttpRequest"
+        Returns
+        -------
+        bool
+            True if correctly deleted, False otherwise.
+        """
+        logger = logging.getLogger(logger_name)
 
-        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
-        )
+        try:
+            platform.parse_response(
+                platform.post(
+                    self._account.auth,
+                    "patient_manager/delete_patient",
+                    data={"patient_id": str(int(patient_id)), "delete_files": 1},
+                )
+            )
+        except errors.PlatformError:
+            logger.error(f"Patient ID {patient_id} could not be deleted.")
+            return False
 
-        return response
+        logger.info(f"Patient ID {patient_id} successfully deleted.")
+        return True
 
-    def upload_file(
-        self,
-        file_path,
-        subject_name,
-        ssid="",
-        date_of_scan="",
-        description="",
-        result=False,
-        name="",
-        input_data_type="qmenta_mri_brain_data:1.0",
-        add_to_container_id=0,
-        chunk_size=2**9,
-        split_data=False,
-    ):
+    def delete_subject(self, subject_name):
         """
-        Upload a ZIP file to the platform.
+        Delete a subject from the project. It deletes all its available
+        sessions only providing the Subject ID.
 
         Parameters
         ----------
-        file_path : str
-            Path to the ZIP file to upload.
         subject_name : str
-            Subject ID of the data to upload in the project in QMENTA Platform.
-        ssid : str
-            Session ID of the Subject ID (i.e., ID of the timepoint).
-        date_of_scan : str
-            Date of scan/creation of the file
-        description : str
-            Description of the file
-        result : bool
-            If result=True then the upload will be taken as an offline analysis
-        name : str
-            Name of the file in the platform
-        input_data_type : str
-            qmenta_medical_image_data:3.11
-        add_to_container_id : int
-            ID of the container to which this file should be added (if id > 0)
-        chunk_size : int
-            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)
-        split_data : bool
-            If True, the platform will try to split the uploaded file into
-            different sessions. It will be ignored when the ssid is given.
+            Subject ID of the subject to be deleted.
 
         Returns
         -------
         bool
-            True if correctly uploaded, False otherwise.
+            True if correctly deleted, 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]
+        logger = logging.getLogger(logger_name)
+        # Always fetch the session IDs from the platform before deleting them
+        all_sessions = self.get_subjects_metadata()
 
-        total_bytes = os.path.getsize(file_path)
+        sessions_to_del = [s for s in all_sessions if s["patient_secret_name"] == subject_name]
 
-        # making chunks of the file and sending one by one
-        logger = logging.getLogger(logger_name)
-        with open(file_path, "rb") as file_object:
+        if not sessions_to_del:
+            logger.error("Subject {} cannot be found in this project.".format(subject_name))
+            return False
 
-            file_size = os.path.getsize(file_path)
-            if file_size == 0:
-                logger.error("Cannot upload empty file {}".format(file_path))
+        for ssid in [s["ssid"] for s in sessions_to_del]:
+            if not self.delete_session(subject_name, ssid):
                 return False
-            uploaded = 0
-            session_id = get_session_id(file_path)
-            chunk_num = 0
-            retries_count = 0
-            uploaded_bytes = 0
-            response = None
-            last_chunk = False
+        return True
 
-            if ssid and split_data:
-                logger.warning("split-data argument will be ignored because" + " ssid has been specified")
-                split_data = False
+    """ Container Related Methods """
 
-            while True:
-                data = file_object.read(chunk_size)
-                if not data:
-                    break
+    def list_input_containers(self, search_criteria={}, items=(0, 9999)):
+        """
+        Retrieve the list of input containers available to the user under a
+        certain search criteria.
 
-                start_position = chunk_num * chunk_size
-                end_position = start_position + chunk_size - 1
-                bytes_to_send = chunk_size
+        Parameters
+        ----------
+        search_criteria : dict
+            Each element is a string and is built using the formatting
+        "type;value".
 
-                if end_position >= total_bytes:
-                    last_chunk = True
-                    end_position = total_bytes - 1
-                    bytes_to_send = total_bytes - uploaded_bytes
+        List of possible keys:
+        d_n: container_name # TODO: WHAT IS THIS???
+        s_n: subject_id
+            Subject ID of the subject in the platform.
+        ssid: session_id
+            Session ID of the subejct in the platform.
+        from_d: from date
+            Starting date in which perform the search. Format: DD.MM.YYYY
+        to_d: to date
+            End date in which perform the search. Format: DD.MM.YYYY
+        sets: data sets (modalities)  # TODO: WHAT IS THIS???
 
-                bytes_range = "bytes " + str(start_position) + "-" + str(end_position) + "/" + str(total_bytes)
+        items: Tuple(int, int)
+            Starting and ending element of the search.
 
-                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,
-                )
+        Returns
+        -------
+        dict
+        List of containers, each a dictionary containing the following
+        information:
+            {"container_name", "container_id", "patient_secret_name", "ssid"}
+        """
 
-                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:
-                    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
+        assert len(items) == 2, f"The number of elements in items " f"'{len(items)}' should be equal to two."
+        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
 
-                uploaded += chunk_size
-                show_progress(uploaded, file_size)
+        response = platform.parse_response(
+            platform.post(
+                self._account.auth,
+                "file_manager/get_container_list",
+                data=search_criteria,
+                headers={"X-Range": f"items={items[0]}-{items[1]}"},
+            )
+        )
+        containers = [
+            {
+                "patient_secret_name": container_item["patient_secret_name"],
+                "container_name": container_item["name"],
+                "container_id": container_item["_id"],
+                "ssid": container_item["ssid"],
+            }
+            for container_item in response
+        ]
+        return containers
 
-        try:
-            platform.parse_response(response)
-        except errors.PlatformError as error:
-            logger.error(error)
-            return False
+    def list_result_containers(self, search_condition={}, items=(0, 9999)):
+        """
+        List the result containers available to the user.
+        Examples
+        --------
 
-        message = "Your data was successfully uploaded."
-        message += "The uploaded file will be soon processed !"
-        logger.info(message)
-        return True
+        >>> search_condition = {
+            "secret_name":"014_S_6920",
+            "from_d": "06.02.2025",
+            "with_child_analysis": 1,
+            "state": "completed"
+        }
+            list_result_containers(search_condition=search_condition)
 
-    def upload_mri(self, file_path, subject_name):
-        """
-        Upload new MRI data to the subject.
+        Note the keys not needed for the search do not have to be included in
+            the search condition.
 
         Parameters
         ----------
-        file_path : str
-            Path to the file to upload
-        subject_name: str
+        search_condition : dict
+            - p_n: str or None Analysis name
+            - type: str or None Type
+            - from_d: str or None dd.mm.yyyy Date from
+            - to_d: str or None dd.mm.yyyy Date to
+            - qa_status: str or None pass/fail/nd QC status
+            - 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
+            - id: str or None ID
+            - state: running, completed, pending, exception or None
+            - username: str or None
+
+        items : List[int]
+            list containing two elements [min, max] that correspond to the
+            mininum and maximum range of analysis listed
 
         Returns
         -------
-        bool
-            True if upload was correctly done, False otherwise.
+        dict
+            List of containers, each a dictionary
+            {"name": "container-name", "id": "container_id"}
+            if "id": None, that analysis did not had an output container,
+            probably it is a workflow
         """
+        analyses = self.list_analysis(search_condition, items)
+        return [{"name": analysis["name"], "id": (analysis.get("out_container_id") or None)} for analysis in analyses]
 
-        if check_upload_file(file_path):
-            return self.upload_file(file_path, subject_name)
+    def list_container_files(
+        self,
+        container_id,
+    ):
+        """
+        List the name of the files available inside a given container.
+        Parameters
+        ----------
+        container_id : str or int
+            Container identifier.
 
-    def upload_gametection(self, file_path, subject_name):
+        Returns
+        -------
+        list[str]
+            List of file names (strings)
         """
-        Upload new Gametection data to the subject.
+        try:
+            content = platform.parse_response(
+                platform.post(
+                    self._account.auth, "file_manager/get_container_files", data={"container_id": container_id}
+                )
+            )
+        except errors.PlatformError as e:
+            logging.getLogger(logger_name).error(e)
+            return False
+        if "files" not in content.keys():
+            logging.getLogger(logger_name).error("Could not get files")
+            return False
+        return content["files"]
 
+    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:
+        "metadata": {"SliceThickness":1},
+        }
         Parameters
         ----------
-        file_path : str
-            Path to the file to upload
-        subject_name: str
+        container_id : str or int
+            Container identifier.
+
+        modality: str
+            String containing the modality of the files being filtered
+
+        metadata_info: dict
+            Dictionary containing the file metadata of the files being filtered
+
+        tags: list[str]
+            List of strings containing the tags of the files being filtered
 
         Returns
         -------
-        bool
-            True if upload was correctly done, False otherwise.
+        selected_files: list[str]
+            List of file names (strings)
         """
+        content_files = self.list_container_files(container_id)
+        content_meta = self.list_container_files_metadata(container_id)
+        selected_files = []
+        for index, file in enumerate(content_files):
+            metadata_file = content_meta[index]
+            tags_file = metadata_file.get("tags")
+            tags_bool = [tag in tags_file for tag in tags]
+            info_bool = []
+            if modality == "":
+                modality_bool = True
+            else:
+                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
+                    )
+                if meta_key is None:
+                    logging.getLogger(logger_name).warning(
+                        f"{key} is not in file_info from file {file}"
+                    )
+                info_bool.append(
+                    metadata_info[key] == meta_key
+                    )
+            if all(tags_bool) and all(info_bool) and modality_bool:
+                selected_files.append(file)
+        return selected_files
 
-        if check_upload_file(file_path):
-            return self.upload_file(file_path, subject_name, input_data_type="parkinson_gametection")
-        return False
-
-    def upload_result(self, file_path, subject_name):
+    def list_container_files_metadata(self, container_id):
         """
-        Upload new result data to the subject.
+        List all the metadata of the files available inside a given container.
 
         Parameters
         ----------
-        file_path : str
-            Path to the file to upload
-        subject_name: str
+        container_id : str
+            Container identifier.
 
         Returns
         -------
-        bool
-            True if upload was correctly done, False otherwise.
+        dict
+            Dictionary of {"metadata_name": "metadata_value"}
         """
 
-        if check_upload_file(file_path):
-            return self.upload_file(file_path, subject_name, result=True)
-        return False
+        try:
+            data = platform.parse_response(
+                platform.post(
+                    self._account.auth, "file_manager/get_container_files", data={"container_id": container_id}
+                )
+            )
+        except errors.PlatformError as e:
+            logging.getLogger(logger_name).error(e)
+            return False
 
-    def copy_container_to_project(self, container_id, project_id):
+        return data["meta"]
+
+    """ Analysis Related Methods """
+
+    def get_analysis(self, analysis_name_or_id):
         """
-        Copy a container to another project.
+        Returns the analysis corresponding with the analysis id or analysis name
 
         Parameters
         ----------
-        container_id : int
-            ID of the container to copy.
-        project_id : int or str
-            ID of the project to retrieve, either the numeric ID or the name
+        analysis_name_or_id : int, str
+            analysis_id or analysis name to search for
 
         Returns
         -------
-        bool
-            True on success, False on fail
+        analysis: dict
+            A dictionary containing the analysis information
         """
+        if isinstance(analysis_name_or_id, int):
+            search_tag = "id"
+        elif isinstance(analysis_name_or_id, str):
+            if analysis_name_or_id.isdigit():
+                search_tag = "id"
+                analysis_name_or_id = int(analysis_name_or_id)
+            else:
+                search_tag = "p_n"
+        else:
+            raise Exception("The analysis identifier must be its name or an " "integer")
 
-        if type(project_id) == int or type(project_id) == float:
-            p_id = int(project_id)
-        elif type(project_id) == str:
-            projects = self._account.projects
-            projects_match = [proj for proj in projects if proj["name"] == project_id]
-            if not projects_match:
-                raise Exception(f"Project {project_id}" + " does not exist or is not available for this user.")
-            p_id = int(projects_match[0]["id"])
+        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)
+        )
+
+        if len(response) > 1:
+            raise Exception(f"multiple analyses with name " f"{analysis_name_or_id} found")
+        elif len(response) == 1:
+            return response[0]
         else:
-            raise TypeError("project_id")
-        data = {
-            "container_id": container_id,
-            "project_id": p_id,
+            return None
+
+    def list_analysis(self, search_condition={}, items=(0, 9999)):
+        """
+        List the analysis available to the user.
+
+        Examples
+        --------
+
+        >>> search_condition = {
+            "secret_name":"014_S_6920",
+            "from_d": "06.02.2025",
+            "with_child_analysis": 1,
+            "state": "completed"
         }
+            list_analysis(search_condition=search_condition)
 
-        try:
-            platform.parse_response(
-                platform.post(self._account.auth, "file_manager/copy_container_to_another_project", data=data)
+        Note the keys not needed for the search do not have to be included in
+            the search condition.
+
+        Parameters
+        ----------
+        search_condition : dict
+            - p_n: str or None Analysis name
+            - type: str or None Type
+            - from_d: str or None dd.mm.yyyy Date from
+            - to_d: str or None dd.mm.yyyy Date to
+            - qa_status: str or None pass/fail/nd QC status
+            - 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
+            - id: str or None ID
+            - state: running, completed, pending, exception or None
+            - username: str or None
+
+        items : List[int]
+            list containing two elements [min, max] that correspond to the
+            mininum and maximum range of analysis listed
+
+        Returns
+        -------
+        dict
+            List of analysis, each a dictionary
+        """
+        assert len(items) == 2, f"The number of elements in items " f"'{len(items)}' should be equal to two."
+        assert all([isinstance(item, int) for item in items]), f"All items elements '{items}' should be integers."
+        search_keys = {
+            "p_n": str,
+            "type": str,
+            "from_d": str,
+            "to_d": str,
+            "qa_status": str,
+            "secret_name": str,
+            "tags": str,
+            "with_child_analysis": int,
+            "id": int,
+            "state": str,
+            "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" f"is not type {search_keys[key]}"))
+        req_headers = {"X-Range": f"items={items[0]}-{items[1] - 1}"}
+        return platform.parse_response(
+            platform.post(
+                auth=self._account.auth,
+                endpoint="analysis_manager/get_analysis_list",
+                headers=req_headers,
+                data=search_condition,
             )
-        except errors.PlatformError as e:
-            logging.getLogger(logger_name).error("Couldn not copy container: {}".format(e))
-            return False
-
-        return True
+        )
 
     def start_analysis(
         self,
@@ -1830,94 +1681,7 @@ class Project:
 
         return True
 
-    def __handle_start_analysis(self, post_data, ignore_warnings=False, n_calls=0):
-        """
-        Handle the possible responses from the server after start_analysis.
-        Sometimes we have to send a request again, and then check again the
-        response. That"s why this function is separated from start_analysis.
-
-        Since this function sometimes calls itself, n_calls avoids entering an
-        infinite loop due to some misbehaviour in the server.
-        """
-
-        call_limit = 10
-        n_calls += 1
-
-        logger = logging.getLogger(logger_name)
-        if n_calls > call_limit:
-            logger.error(
-                f"__handle_start_analysis_response called itself more\
-                          than {n_calls} times: aborting."
-            )
-            return None
-
-        try:
-            response = platform.parse_response(
-                platform.post(self._account.auth, "analysis_manager/analysis_registration", data=post_data)
-            )
-            logger.info(response["message"])
-            return int(response["analysis_id"])
-        except platform.ChooseDataError as choose_data:
-            has_warning = False
-
-            # logging any warning that we have
-            if choose_data.warning:
-                has_warning = True
-                logger.warning(response["warning"])
-
-            new_post = {
-                "analysis_id": choose_data.analysis_id,
-                "script_name": post_data["script_name"],
-                "version": post_data["version"],
-            }
-
-            if choose_data.data_to_choose:
-                # in case we have data to choose
-                chosen_files = {}
-                for settings_key in choose_data.data_to_choose:
-                    chosen_files[settings_key] = {}
-                    filters = choose_data.data_to_choose[settings_key]["filters"]
-                    for filter_key in filters:
-                        filter_data = filters[filter_key]
-
-                        # skip the filters that did not pass
-                        if not filter_data["passed"]:
-                            continue
-
-                        number_of_files_to_select = 1
-                        if filter_data["range"][0] != 0:
-                            number_of_files_to_select = filter_data["range"][0]
-                        elif filter_data["range"][1] != 0:
-                            number_of_files_to_select = min(filter_data["range"][1], len(filter_data["files"]))
-                        else:
-                            number_of_files_to_select = len(filter_data["files"])
-
-                        files_selection = [ff["_id"] for ff in filter_data["files"][:number_of_files_to_select]]
-                        chosen_files[settings_key][filter_key] = files_selection
-
-                new_post["user_preference"] = json.dumps(chosen_files)
-            else:
-                if has_warning and not ignore_warnings:
-                    logger.info("cancelling analysis due to warnings, " + 'set "ignore_warnings" to True to override')
-                    new_post["cancel"] = "1"
-                else:
-                    logger.info("suppressing warnings")
-                    new_post["user_preference"] = "{}"
-                    new_post["_mint_only_warning"] = "1"
-
-            return self.__handle_start_analysis(new_post, ignore_warnings=ignore_warnings, n_calls=n_calls)
-        except platform.ActionFailedError as e:
-            logger.error(f"Unable to start the analysis: {e}")
-            return None
-
-    @staticmethod
-    def __get_modalities(files):
-        modalities = []
-        for file_ in files:
-            modality = file_["metadata"]["modality"]
-            if modality not in modalities:
-                modalities.append(modality)
-        return modalities
+    """ QC Status Related Methods """
 
     def set_qc_status_analysis(self, analysis_id,
                                status=QCStatus.UNDERTERMINED, comments=""):
@@ -2099,6 +1863,7 @@ class Project:
             raise ValueError("Either 'patient_id' or 'subject_name' and 'ssid'"
                              " must not be empty.")
 
+    """ Protocol Adherence Related Methods """
     def set_project_pa_rules(self, rules_file_path, guidance_text=""):
         """
         Updates the active project's protocol adherence rules using the
@@ -2183,3 +1948,268 @@ class Project:
             return False
 
         return res["guidance_text"]
+
+    """ Helper Methods """
+    def __handle_start_analysis(self, post_data, ignore_warnings=False, n_calls=0):
+        """
+        Handle the possible responses from the server after start_analysis.
+        Sometimes we have to send a request again, and then check again the
+        response. That"s why this function is separated from start_analysis.
+
+        Since this function sometimes calls itself, n_calls avoids entering an
+        infinite loop due to some misbehaviour in the server.
+        """
+
+        call_limit = 10
+        n_calls += 1
+
+        logger = logging.getLogger(logger_name)
+        if n_calls > call_limit:
+            logger.error(
+                f"__handle_start_analysis_response called itself more\
+                          than {n_calls} times: aborting."
+            )
+            return None
+
+        try:
+            response = platform.parse_response(
+                platform.post(self._account.auth, "analysis_manager/analysis_registration", data=post_data)
+            )
+            logger.info(response["message"])
+            return int(response["analysis_id"])
+        except platform.ChooseDataError as choose_data:
+            has_warning = False
+
+            # logging any warning that we have
+            if choose_data.warning:
+                has_warning = True
+                logger.warning(response["warning"])
+
+            new_post = {
+                "analysis_id": choose_data.analysis_id,
+                "script_name": post_data["script_name"],
+                "version": post_data["version"],
+            }
+
+            if choose_data.data_to_choose:
+                # in case we have data to choose
+                chosen_files = {}
+                for settings_key in choose_data.data_to_choose:
+                    chosen_files[settings_key] = {}
+                    filters = choose_data.data_to_choose[settings_key]["filters"]
+                    for filter_key in filters:
+                        filter_data = filters[filter_key]
+
+                        # skip the filters that did not pass
+                        if not filter_data["passed"]:
+                            continue
+
+                        number_of_files_to_select = 1
+                        if filter_data["range"][0] != 0:
+                            number_of_files_to_select = filter_data["range"][0]
+                        elif filter_data["range"][1] != 0:
+                            number_of_files_to_select = min(filter_data["range"][1], len(filter_data["files"]))
+                        else:
+                            number_of_files_to_select = len(filter_data["files"])
+
+                        files_selection = [ff["_id"] for ff in filter_data["files"][:number_of_files_to_select]]
+                        chosen_files[settings_key][filter_key] = files_selection
+
+                new_post["user_preference"] = json.dumps(chosen_files)
+            else:
+                if has_warning and not ignore_warnings:
+                    logger.info("cancelling analysis due to warnings, " + 'set "ignore_warnings" to True to override')
+                    new_post["cancel"] = "1"
+                else:
+                    logger.info("suppressing warnings")
+                    new_post["user_preference"] = "{}"
+                    new_post["_mint_only_warning"] = "1"
+
+            return self.__handle_start_analysis(new_post, ignore_warnings=ignore_warnings, n_calls=n_calls)
+        except platform.ActionFailedError as e:
+            logger.error(f"Unable to start the analysis: {e}")
+            return None
+
+    @staticmethod
+    def __get_modalities(files):
+        modalities = []
+        for file_ in files:
+            modality = file_["metadata"]["modality"]
+            if modality not in modalities:
+                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"))
+        return str(time.time()).replace(".", "") + "_" + m.hexdigest()
+
+    def __check_upload_file(self, file_path):
+        """
+        Check whether a file has the correct extension to upload.
+
+        Parameters
+        ----------
+        file_path : str
+            Path to the file
+
+        Returns
+        -------
+        bool
+            True if correct extension, False otherwise.
+        """
+
+        # TODO: Add a file zipper here so zips files in a folder
+
+        file_parts = file_path.split(".")
+        extension = file_parts[-1]
+
+        if extension != "zip":
+            logging.getLogger(logger_name).error("You must upload a zip.")
+            return False
+        else:
+            return True
+
+    def __operation(self, reference_value, operator, input_value):
+        """
+        The method performs an operation by comparing the two input values.
+        The Operation is applied to the Input Value in comparison to the Reference
+        Value.
+
+        Parameters
+        ----------
+        reference_value : str, list, or int
+            Reference value.
+        operator : str
+            Operation.
+        input_value : str, list, or int
+            Input value.
+
+        Returns
+        -------
+        bool
+            True if the operation is satisfied, False otherwise.
+        """
+        if input_value is None or input_value == "":
+            return False
+
+        if operator == "in":
+            return reference_value in input_value
+
+        elif operator == "in-list":
+            return all([el in input_value for el in reference_value])
+
+        elif operator == "eq":
+            return input_value == reference_value
+
+        elif operator == "gt":
+            return input_value > reference_value
+
+        elif operator == "gte":
+            return input_value >= reference_value
+
+        elif operator == "lt":
+            return input_value < reference_value
+
+        elif operator == "lte":
+            return input_value <= reference_value
+        else:
+            return False
+
+    def __wrap_search_criteria(self, search_criteria={}):
+        """
+        Wraps the conditions specified within the Search Criteria in order for
+        other methods to handle it easily. The conditions are grouped only into
+        three groups: Modality, Tags and the File Metadata (if DICOM it corresponds
+        to the DICOM information), and each of them is output in a different
+        variable.
+
+        Parameters
+        ----------
+        search_criteria : dict
+            Each element is a string and is built using the formatting
+                "KEYTYPE;VALUE", or "KEYTYPE;OPERATOR|VALUE".
+
+                Full list of keys avaiable for the dictionary:
+
+                search_criteria = {
+                    "pars_patient_secret_name": "string;SUBJECTID",
+                    "pars_ssid": "integer;OPERATOR|SSID",
+                    "pars_modalities": "string;MODALITY",
+                    "pars_tags": "tags;TAGS",
+                    "pars_age_at_scan": "integer;OPERATOR|AGE_AT_SCAN",
+                    "pars_[dicom]_KEY": "KEYTYPE;KEYVALUE",
+                    "pars_PROJECTMETADATA": "METADATATYPE;METADATAVALUE",
+                    }
+
+                See documentation for a complete definition.
+
+        Returns
+        -------
+        modality : str
+            String containing the modality of the search criteria extracted from
+            'pars_modalities'
+
+        tags : list of str
+            List of strings containing the tags of the search criteria extracted
+            'from pars_tags'
+
+        file_metadata : Dict
+            Dictionary containing the file metadata of the search criteria
+            extracted from 'pars_[dicom]_KEY'
+        """
+
+        # The keys not included bellow apply to the whole session.
+        modality, tags, file_metadata = "", list(), dict()
+        for key, value in search_criteria.items():
+            if key == "pars_modalities":
+                modalities = value.split(";")[1].split(",")
+                if len(modalities) != 1:
+                    raise ValueError(f"A file can only have one modality. "
+                                     f"Provided Modalities: "
+                                     f"{', '.join(modalities)}.")
+                modality = modalities[0]
+            elif key == "pars_tags":
+                tags = value.split(";")[1].split(",")
+            elif "pars_[dicom]_" in key:
+                d_tag = key.split("pars_[dicom]_")[1]
+                d_type = value.split(";")[0]
+                if d_type == "string":
+                    file_metadata[d_tag] = {
+                        "operation": "in",
+                        "value": value.replace(d_type + ";", "")
+                    }
+                elif d_type == "integer":
+                    d_operator = value.split(";")[1].split("|")[0]
+                    d_value = value.split(";")[1].split("|")[1]
+                    file_metadata[d_tag] = {
+                        "operation": d_operator,
+                        "value": int(d_value)}
+                elif d_type == "decimal":
+                    d_operator = value.split(";")[1].split("|")[0]
+                    d_value = value.split(";")[1].split("|")[1]
+                    file_metadata[d_tag] = {
+                        "operation": d_operator,
+                        "value": float(d_value)
+                    }
+                elif d_type == "list":
+                    value.replace(d_type + ";", "")
+                    file_metadata[d_tag] = {
+                        "operation": "in-list",
+                        "value": value.replace(d_type + ";", "").split(";")
+                    }
+        return modality, tags, file_metadata