qmenta-client 1.1.dev1492__py3-none-any.whl → 1.1.dev1504__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
@@ -228,7 +231,7 @@ class Project:
         name="",
         input_data_type="qmenta_medical_image_data:3.10",
         add_to_container_id=0,
-        chunk_size=2**9,
+        chunk_size=2 ** 9,
         split_data=False,
     ):
         """
@@ -474,7 +477,7 @@ class Project:
             self._account.auth, "file_manager/download_file", data=params, stream=True
         ) as response, open(local_filename, "wb") as f:
 
-            for chunk in response.iter_content(chunk_size=2**9 * 1024):
+            for chunk in response.iter_content(chunk_size=2 ** 9 * 1024):
                 f.write(chunk)
             f.flush()
 
@@ -520,7 +523,7 @@ class Project:
             self._account.auth, "file_manager/download_file", data=params, stream=True
         ) as response, open(zip_name, "wb") as f:
 
-            for chunk in response.iter_content(chunk_size=2**9 * 1024):
+            for chunk in response.iter_content(chunk_size=2 ** 9 * 1024):
                 f.write(chunk)
             f.flush()
 
@@ -2038,6 +2041,312 @@ 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 (typically from medical imaging quality checks)
+        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)
+        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)
+
+        # Parse passed rules
+        passed_rules = re.split(r'\n ✅ ', passed_section)
+        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
+
+    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 +2452,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 +2470,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"]:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qmenta-client
-Version: 1.1.dev1492
+Version: 1.1.dev1504
 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.dev1504.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=vx1GabCiVG7gYqnkNmqhqRyzy7ml7eT4jjnUciBq_Gw,99565
 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.dev1504.dist-info/METADATA,sha256=iZHBMCXur-LBBJuvAnmSpRVX4Q0vkq7U32VcH4TGy_g,672
+qmenta_client-1.1.dev1504.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+qmenta_client-1.1.dev1504.dist-info/RECORD,,