qmenta-client 1.1.dev1492__py3-none-any.whl → 1.1.dev1507__py3-none-any.whl

qmenta/client/Project.py

@@ -4,14 +4,17 @@ import hashlib
 import json
 import logging
 import os
+import re
 import sys
 import time
+from collections import defaultdict
 from enum import Enum
 
-from qmenta.client import Account
 from qmenta.core import errors
 from qmenta.core import platform
 
+from qmenta.client import Account
+
 if sys.version_info[0] == 3:
     # Note: this branch & variable is only needed for python 2/3 compatibility
     unicode = str
@@ -259,14 +262,14 @@ class Project:
             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.
+            different sessions. It will be ignored when the ssid or a
+            add_to_container_id are given.
 
         Returns
         -------
         bool
             True if correctly uploaded, False otherwise.
         """
-
         filename = os.path.split(file_path)[1]
         input_data_type = "offline_analysis:1.0" if result else input_data_type
 
@@ -277,6 +280,8 @@ class Project:
 
         total_bytes = os.path.getsize(file_path)
 
+        split_data = self.__assert_split_data(split_data, ssid, add_to_container_id)
+
         # making chunks of the file and sending one by one
         logger = logging.getLogger(logger_name)
         with open(file_path, "rb") as file_object:
@@ -293,10 +298,6 @@ class Project:
             response = None
             last_chunk = False
 
-            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:
@@ -371,8 +372,7 @@ class Project:
             logger.error(error)
             return False
 
-        message = "Your data was successfully uploaded."
-        message += "The uploaded file will be soon processed !"
+        message = "Your data was successfully uploaded. The uploaded file will be soon processed !"
         logger.info(message)
         return True
 
@@ -2038,6 +2038,232 @@ class Project:
 
         return res["guidance_text"]
 
+    def parse_qc_text(self, patient_id=None, subject_name=None, ssid=None):
+        """
+        Parse QC (Quality Control) text output into a structured dictionary format.
+
+        This function takes raw QC text output (from the Protocol Adherence analysis)
+        and parses it into a structured format that separates passed and failed rules,
+        along with their associated files and conditions.
+
+        Args:
+            patient_id (str, optional):
+                Patient identifier. Defaults to None.
+            subject_name (str, optional):
+                Subject/patient name. Defaults to None. Mandatory if no patient_id is provided.
+            ssid (str, optional):
+                Session ID. Defaults to None. Mandatory if subject_name is provided.
+
+        Returns:
+            dict: A structured dictionary containing a list of dictionaries with passed rules and their details
+            and failed rules and their details. Details of passed rules are:
+            per each rule: Files that have passed the rule. Per each file name of the file and number of conditions
+            of the rule.
+            Details of failed rules are:
+            - Per each rule failed conditions: Number of times it failed. Each condition status.
+
+        Example:
+            >>> parse_qc_text(subject_name="patient_123", ssid=1)
+            {
+                "passed": [
+                    {
+                        "rule": "T2",
+                        "sub_rule": "rule_15T",
+                        "files": [
+                            {
+                                "file": "path/to/file1",
+                                "passed_conditions": 4
+                            }
+                        ]
+                    }
+                ],
+                "failed": [
+                    {
+                        "rule": "T1",
+                        "files": [
+                            {
+                                "file": "path/to/file2",
+                                "conditions": [
+                                    {
+                                        "status": "failed",
+                                        "condition": "SliceThickness between..."
+                                    }
+                                ]
+                            }
+                        ],
+                        "failed_conditions": {
+                            "SliceThickness between...": 1
+                        }
+                    }
+                ]
+            }
+        """
+
+        _, text = self.get_qc_status_subject(patient_id=patient_id, subject_name=subject_name, ssid=ssid)
+
+        result = {"passed": [], "failed": []}
+
+        # Split into failed and passed sections
+        sections = re.split(r"={10,}\n\n", text)
+        if len(sections) == 3:
+            failed_section = sections[1].split("=" * 10)[0].strip()
+            passed_section = sections[2].strip()
+        else:
+            section = sections[1].split("=" * 10)[0].strip()
+            if "PASSED QC MESSAGES" in section:
+                passed_section = section
+                failed_section = ""
+            else:
+                failed_section = section
+                passed_section = ""
+
+        # Parse failed rules
+        failed_rules = re.split(r"\n ❌ ", failed_section)
+        result = self.__parse_fail_rules(failed_rules, result)
+
+        # Parse passed rules
+        passed_rules = re.split(r"\n ✅ ", passed_section)
+        result = self.__parse_pass_rules(passed_rules, result)
+
+        return result
+
+    def calculate_qc_statistics(self):
+        """
+        Calculate comprehensive statistics from multiple QC results across subjects from a project in the QMENTA
+        platform.
+
+        This function aggregates and analyzes QC results from multiple subjects/containers,
+        providing statistical insights about rule pass/fail rates, file statistics,
+        and condition failure patterns.
+
+        Returns:
+            dict: A dictionary containing comprehensive QC statistics including:
+                - passed_rules: Total count of passed rules across all subjects
+                - failed_rules: Total count of failed rules across all subjects
+                - subjects_passed: Count of subjects with no failed rules
+                - subjects_with_failed: Count of subjects with at least one failed rule
+                - num_passed_files_distribution: Distribution of how many rules have N passed files
+                - file_stats: File-level statistics (total, passed, failed, pass percentage)
+                - condition_failure_rates: Frequency and percentage of each failed condition
+                - rule_success_rates: Success rates for each rule type
+
+        The statistics help identify:
+            - Overall QC pass rates
+            - Most common failure conditions
+            - Rule-specific success rates
+            - Distribution of passed files per rule
+            - Subject-level pass rates
+
+        Example:
+            >>> project.calculate_qc_statistics()
+            {
+                "passed_rules": 42,
+                "failed_rules": 8,
+                "subjects_passed": 15,
+                "subjects_with_failed": 5,
+                "num_passed_files_distribution": {
+                    "1": 30,
+                    "2": 12
+                },
+                "file_stats": {
+                    "total": 50,
+                    "passed": 45,
+                    "failed": 5,
+                    "pass_percentage": 90.0
+                },
+                "condition_failure_rates": {
+                    "SliceThickness": {
+                        "count": 5,
+                        "percentage": 62.5
+                    }
+                },
+                "rule_success_rates": {
+                    "T1": {
+                        "passed": 20,
+                        "failed": 2,
+                        "success_rate": 90.91
+                    }
+                }
+            }
+        """
+        qc_results_list = list()
+        containers = self.list_input_containers()
+
+        for c in containers:
+            qc_results_list.append(self.parse_qc_text(subject_name=c["patient_secret_name"], ssid=c["ssid"]))
+
+        # Initialize statistics
+        stats = {
+            "passed_rules": 0,
+            "failed_rules": 0,
+            "subjects_passed": 0,
+            "subjects_with_failed": 0,
+            "num_passed_files_distribution": defaultdict(int),  # How many rules have N passed files
+            "file_stats": {"total": 0, "passed": 0, "failed": 0, "pass_percentage": 0.0},
+            "condition_failure_rates": defaultdict(lambda: {"count": 0, "percentage": 0.0}),
+            "rule_success_rates": defaultdict(lambda: {"passed": 0, "failed": 0, "success_rate": 0.0}),
+        }
+
+        total_failures = 0
+
+        # sum subjects with not failed qc message
+        stats["subjects_passed"] = sum([1 for rules in qc_results_list if not rules["failed"]])
+        # sum subjects with some failed qc message
+        stats["subjects_with_failed"] = sum([1 for rules in qc_results_list if rules["failed"]])
+        # sum rules that have passed
+        stats["passed_rules"] = sum([len(rules["passed"]) for rules in qc_results_list if rules["failed"]])
+        # sum rules that have failed
+        stats["failed_rules"] = sum([len(rules["failed"]) for rules in qc_results_list if rules["failed"]])
+
+        for qc_results in qc_results_list:
+
+            # Count passed files distribution
+            for rule in qc_results["passed"]:
+                num_files = len(rule["files"])
+                stats["num_passed_files_distribution"][num_files] += 1
+                stats["file_stats"]["passed"] += len(rule["files"])
+                stats["file_stats"]["total"] += len(rule["files"])
+                rule_name = rule["rule"]
+                stats["rule_success_rates"][rule_name]["passed"] += 1
+
+            for rule in qc_results["failed"]:
+                stats["file_stats"]["total"] += len(rule["files"])
+                stats["file_stats"]["failed"] += len(rule["files"])
+                for condition, count in rule["failed_conditions"].items():
+                    # Extract just the condition text without actual value
+                    clean_condition = re.sub(r"\.\s*Actual value:.*$", "", condition)
+                    stats["condition_failure_rates"][clean_condition]["count"] += count
+                    total_failures += count
+                rule_name = rule["rule"]
+                stats["rule_success_rates"][rule_name]["failed"] += 1
+
+        if stats["file_stats"]["total"] > 0:
+            stats["file_stats"]["pass_percentage"] = round(
+                (stats["file_stats"]["passed"] / stats["file_stats"]["total"]) * 100, 2
+            )
+
+        # Calculate condition failure percentages
+        for condition in stats["condition_failure_rates"]:
+            if total_failures > 0:
+                stats["condition_failure_rates"][condition]["percentage"] = round(
+                    (stats["condition_failure_rates"][condition]["count"] / total_failures) * 100, 2
+                )
+
+        # Calculate rule success rates
+        for rule in stats["rule_success_rates"]:
+            total = stats["rule_success_rates"][rule]["passed"] + stats["rule_success_rates"][rule]["failed"]
+            if total > 0:
+                stats["rule_success_rates"][rule]["success_rate"] = round(
+                    (stats["rule_success_rates"][rule]["passed"] / total) * 100, 2
+                )
+
+        # Convert defaultdict to regular dict for cleaner JSON output
+        stats["num_passed_files_distribution"] = dict(stats["num_passed_files_distribution"])
+        stats["condition_failure_rates"] = dict(stats["condition_failure_rates"])
+        stats["rule_success_rates"] = dict(stats["rule_success_rates"])
+
+        return stats
+
     """ Helper Methods """
 
     def __handle_start_analysis(self, post_data, ignore_warnings=False, ignore_file_selection=True, n_calls=0):
@@ -2143,7 +2369,6 @@ class Project:
                 elif post_data.get("cancel"):
                     continue
 
-                number_of_files_to_select = 1
                 if filter_data["range"][0] != 0:
                     number_of_files_to_select = filter_data["range"][0]
                 elif filter_data["range"][1] != 0:
@@ -2162,7 +2387,7 @@ class Project:
                     logger.warning(
                         f"  · File filter name: '{filter_key}'. Type "
                         f"{number_of_files_to_select} file"
-                        f"{'s (i.e., file1.zip, file2.zip, file3.zip)' if number_of_files_to_select >1 else ''}."
+                        f"{'s (i.e., file1.zip, file2.zip, file3.zip)' if number_of_files_to_select > 1 else ''}."
                     )
                     save_file_ids, select_file_filter = {}, ""
                     for file_ in filter_data["files"]:
@@ -2365,3 +2590,107 @@ class Project:
                     value.replace(d_type + ";", "")
                     file_metadata[d_tag] = {"operation": "in-list", "value": value.replace(d_type + ";", "").split(";")}
         return modality, tags, file_metadata
+
+    def __assert_split_data(self, split_data, ssid, add_to_container_id):
+        """
+        Assert if the split_data parameter is possible to use in regards
+        to the ssid and add_to_container_id parameters during upload.
+        Changes its status to False if needed.
+
+        Parameters
+        ----------
+        split_data : Bool
+            split_data parameter from method 'upload_file'.
+        ssid : str
+            Session ID.
+        add_to_container_id : int or bool
+            Container ID or False
+
+        Returns
+        -------
+        split_data : Bool
+
+        """
+
+        logger = logging.getLogger(logger_name)
+        if ssid and split_data:
+            logger.warning("split-data argument will be ignored because ssid has been specified")
+            split_data = False
+
+        if add_to_container_id and split_data:
+            logger.warning("split-data argument will be ignored because add_to_container_id has been specified")
+            split_data = False
+
+        return split_data
+
+    def __parse_fail_rules(self, failed_rules, result):
+        """
+        Parse fail rules.
+        """
+
+        for rule_text in failed_rules[1:]:  # Skip first empty part
+            rule_name = rule_text.split(" ❌")[0].strip()
+            rule_data = {"rule": rule_name, "files": [], "failed_conditions": {}}
+
+            # Extract all file comparisons for this rule
+            file_comparisons = re.split(r"\t- Comparison with file:", rule_text)
+            for comp in file_comparisons[1:]:  # Skip first part
+                file_name = comp.split("\n")[0].strip()
+                conditions_match = re.search(r"Conditions:(.*?)(?=\n\t- Comparison|\n\n|$)", comp, re.DOTALL)
+                if not conditions_match:
+                    continue
+
+                conditions_text = conditions_match.group(1).strip()
+                # Parse conditions
+                conditions = []
+                for line in conditions_text.split("\n"):
+                    line = line.strip()
+                    if line.startswith("·"):
+                        status = "✔" if "✔" in line else "🚫"
+                        condition = re.sub(r"^· [✔🚫]\s*", "", line)
+                        conditions.append({"status": "passed" if status == "✔" else "failed", "condition": condition})
+
+                # Add to failed conditions summary
+                for cond in conditions:
+                    if cond["status"] == "failed":
+                        cond_text = cond["condition"]
+                        if cond_text not in rule_data["failed_conditions"]:
+                            rule_data["failed_conditions"][cond_text] = 0
+                        rule_data["failed_conditions"][cond_text] += 1
+
+                rule_data["files"].append({"file": file_name, "conditions": conditions})
+
+            result["failed"].append(rule_data)
+        return result
+
+    def __parse_pass_rules(self, passed_rules, result):
+        """
+        Parse pass rules.
+        """
+
+        for rule_text in passed_rules[1:]:  # Skip first empty part
+            rule_name = rule_text.split(" ✅")[0].strip()
+            rule_data = {"rule": rule_name, "sub_rule": None, "files": []}
+
+            # Get sub-rule
+            sub_rule_match = re.search(r"Sub-rule: (.*?)\n", rule_text)
+            if sub_rule_match:
+                rule_data["sub_rule"] = sub_rule_match.group(1).strip()
+
+            # Get files passed
+            files_passed = re.search(r"List of files passed:(.*?)(?=\n\n|\Z)", rule_text, re.DOTALL)
+            if files_passed:
+                for line in files_passed.group(1).split("\n"):
+                    line = line.strip()
+                    if line.startswith("·"):
+                        file_match = re.match(r"· (.*?) \((\d+)/(\d+)\)", line)
+                        if file_match:
+                            rule_data["files"].append(
+                                {
+                                    "file": file_match.group(1).strip(),
+                                    "passed_conditions": int(file_match.group(2)),
+                                }
+                            )
+
+            result["passed"].append(rule_data)
+        return result

{qmenta_client-1.1.dev1492.dist-info → qmenta_client-1.1.dev1507.dist-info}/METADATA

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

{qmenta_client-1.1.dev1492.dist-info → qmenta_client-1.1.dev1507.dist-info}/RECORD

@@ -1,10 +1,10 @@
 qmenta/__init__.py,sha256=ED6jHcYiuYpr_0vjGz0zx2lrrmJT9sDJCzIljoDfmlM,65
 qmenta/client/Account.py,sha256=7BOWHtRbHdfpBYQqv9v2m2Fag13pExZSxFsjDA7UsW0,9500
 qmenta/client/File.py,sha256=iCrzrd7rIfjjW2AgMgUoK-ZF2wf-95wCcPKxKw6PGyg,4816
-qmenta/client/Project.py,sha256=JQZc5BMWSdPEMGBp1gsZFbhjSbFg-0AoBJFXakddojw,86466
+qmenta/client/Project.py,sha256=pV9mW90BzPIMOFauPiAONBIsYJfGsbi_Xabbe9DW32U,100493
 qmenta/client/Subject.py,sha256=b5sg9UFtn11bmPM-xFXP8aehOm_HGxnhgT7IPKbrZnE,8688
 qmenta/client/__init__.py,sha256=Mtqe4zf8n3wuwMXSALENQgp5atQY5VcsyXWs2hjBs28,133
 qmenta/client/utils.py,sha256=vWUAW0r9yDetdlwNo86sdzKn03FNGvwa7D9UtOA3TEc,2419
-qmenta_client-1.1.dev1492.dist-info/METADATA,sha256=SSKZb9aDxY8X5qXEwBYyrDBLpU765M_7Z3zOJWC7UdM,672
-qmenta_client-1.1.dev1492.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-qmenta_client-1.1.dev1492.dist-info/RECORD,,
+qmenta_client-1.1.dev1507.dist-info/METADATA,sha256=hGQLiIggQT0NX8tOF8VIklAu9VdsOSldflacTNBIo9g,672
+qmenta_client-1.1.dev1507.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+qmenta_client-1.1.dev1507.dist-info/RECORD,,