willisapi-client 1.9.4__tar.gz → 1.9.6__tar.gz

{willisapi_client-1.9.4 → willisapi_client-1.9.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: willisapi_client
-Version: 1.9.4
+Version: 1.9.6
 Summary: A Python client for willisapi
 Home-page: https://github.com/bklynhlth/willsiapi_client
 Author: bklynhlth

{willisapi_client-1.9.4 → willisapi_client-1.9.6}/willisapi_client/__version__.py

@@ -1,7 +1,7 @@
 """Version details for willisapi_client"""
 
 __client__ = "willisapi_client"
-__latestVersion__ = "1.9.4"
+__latestVersion__ = "1.9.6"
 __url__ = "https://github.com/bklynhlth/willsiapi_client"
 __short_description__ = "A Python client for willisapi"
 __content_type__ = "text/markdown"

{willisapi_client-1.9.4 → willisapi_client-1.9.6}/willisapi_client/services/metadata/upload.py

@@ -5,6 +5,10 @@ import requests
 import mimetypes
 import os
 
+# Register extensions that Python's default mimetypes table doesn't know about.
+# The server signs presigned URLs with these types, so the client must match.
+mimetypes.add_type("application/vnd.apache.parquet", ".parquet")
+
 from willisapi_client.timer import measure
 from willisapi_client.willisapi_client import WillisapiClient
 from willisapi_client.logging_setup import logger as logger
@@ -16,6 +20,8 @@ from willisapi_client.services.metadata.utils import (
     get_last_n_directories,
 )
 
+VALID_SCORE_TYPES = ["rater", "reviewer"]
+
 
 @measure
 def upload(api_key: str, csv_path: str, **kwargs):
@@ -101,8 +107,17 @@ def upload(api_key: str, csv_path: str, **kwargs):
 @measure
 def processed_upload(api_key: str, csv_path: str, output_path: str, **kwargs):
 
+    score_type = kwargs.get("score_type", "rater")
+    if score_type not in VALID_SCORE_TYPES:
+        logger.error(
+            f"Invalid score_type '{score_type}'. Allowed values: {', '.join(VALID_SCORE_TYPES)}"
+        )
+        return None
+
     force_upload = kwargs.get("force_upload", False)
-    csv = ProcessedMetadataValidation(csv_path=csv_path, force_upload=force_upload)
+    csv = ProcessedMetadataValidation(
+        csv_path=csv_path, force_upload=force_upload, score_type=score_type
+    )
     if csv.load_and_validate():
         logger.info(f'{datetime.now().strftime("%H:%M:%S")}: csv check passed')
         csv.create_final_csv()
@@ -121,28 +136,39 @@ def processed_upload(api_key: str, csv_path: str, output_path: str, **kwargs):
             valid, err = u.validate_processed_data_row()
             result_row = row.to_dict()
             if valid:
-                filename = os.path.basename(row.recording).split(".")[0]
                 files = []
-                for file in find_files_with_pattern(output_path, filename):
-                    key, error = get_last_n_directories(file, n=2)
-                    if error:
-                        continue
-                    checksum = u.calculate_file_checksum(file)
-                    files.append(
-                        {
-                            "index": index,
-                            "recording": file,
-                            "key": key,
-                            "checksum": checksum,
-                        }
+                if score_type != "reviewer":
+                    recording_val = getattr(row, "recording", None)
+                    filename = (
+                        os.path.basename(recording_val).split(".")[0]
+                        if recording_val
+                        else None
                     )
-                payload = u.generate_processed_payload(files)
+                    for file in (
+                        find_files_with_pattern(output_path, filename)
+                        if filename
+                        else []
+                    ):
+                        key, error = get_last_n_directories(file, n=2)
+                        if error:
+                            continue
+                        checksum = u.calculate_file_checksum(file)
+                        files.append(
+                            {
+                                "index": index,
+                                "recording": file,
+                                "key": key,
+                                "checksum": checksum,
+                            }
+                        )
+                payload = u.generate_processed_payload(files, score_type=score_type)
                 res = u.post(api_key, url, headers, payload)
                 if res.get("upload_status") == "Success":
                     result_row["upload_status"] = "Success"
                     result_row["error"] = None
 
                     # Handle S3 upload if presigned URL is provided
+                    s3_errors = []
                     for file_presigned in res.get("response", []):
                         presigned = file_presigned.get("presigned")
                         checksum = file_presigned.get("checksum")
@@ -162,22 +188,15 @@ def processed_upload(api_key: str, csv_path: str, output_path: str, **kwargs):
                                         "Content-Type": content_type,
                                     },
                                 )
-                            if response.status_code == 200:
-                                result_row["upload_status"] = "Success"
-                            else:
-                                result_row["upload_status"] = "Failed"
-                                if result_row["error"] is None:
-                                    result_row["error"] = ""
-                                result_row["error"] = (
-                                    result_row["error"]
-                                    + "\n"
-                                    + f"S3 upload failed with status code {response.status_code} for file {recording}"
+                            if response.status_code != 200:
+                                s3_errors.append(
+                                    f"S3 upload failed with status code {response.status_code} for file {recording}"
                                 )
                         except Exception as ex:
-                            result_row["upload_status"] = "Failed"
-                            if result_row["error"] is None:
-                                result_row["error"] = ""
-                            result_row["error"] = result_row["error"] + "\n" + str(ex)
+                            s3_errors.append(str(ex))
+                    if s3_errors:
+                        result_row["upload_status"] = "Failed"
+                        result_row["error"] = "\n".join(s3_errors)
                 else:
                     result_row["upload_status"] = "Failed"
                     result_row["error"] = res.get("error")

{willisapi_client-1.9.4 → willisapi_client-1.9.6}/willisapi_client/services/metadata/utils.py

@@ -12,9 +12,16 @@ from .language_choices import (
 )
 from dateutil import parser
 
-ALLOWED_COA_NAMES = ["MADRS", "YMRS", "PHQ-9", "GAD-7", "HAM-D17"]
+ALLOWED_COA_NAMES = ["MADRS", "YMRS", "PHQ-9", "GAD-7", "HAM-D17", "HAMD17"]
 
-COA_ITEM_COUNTS = {"MADRS": 10, "YMRS": 10, "PHQ-9": 9, "GAD-7": 7, "HAM-D17": 17}
+COA_ITEM_COUNTS = {
+    "MADRS": 10,
+    "YMRS": 10,
+    "PHQ-9": 9,
+    "GAD-7": 7,
+    "HAM-D17": 17,
+    "HAMD17": 17,
+}
 
 
 class MetadataValidation:
@@ -453,11 +460,14 @@ class UploadUtils:
             "checksum": self.calculate_file_checksum(self.row.file_path),
             "recording_order": int(self.row.recording_order),
             "is_last_recording": self.row.is_last_recording,
-            "timestamp": parser.parse(self.row.timestamp).isoformat(),
+            # "time_collected": parser.parse(self.row.time_collected).isoformat(),
         }
         return payload
 
-    def generate_processed_payload(self, files: List[Dict[str, str]]) -> Dict[str, Any]:
+    def generate_processed_payload(
+        self, files: List[Dict[str, str]], score_type: str = "rater"
+    ) -> Dict[str, Any]:
+        recording_val = getattr(self.row, "recording", None)
         payload = {
             "study_id": self.row.study_id,
             "site_id": self.row.site_id,
@@ -467,12 +477,16 @@ class UploadUtils:
             "visit_id": self.row.visit_id,
             "visit_order": int(self.row.visit_order),
             "coa_id": self.row.coa_id,
-            "filename": os.path.basename(self.row.recording),
+            "filename": os.path.basename(recording_val) if recording_val else "",
             "actual_scores": json.loads(self.row.scores_actual),
             "files": files,
             "force_upload": self.row.force_upload,
             "timestamp": parser.parse(self.row.timestamp).isoformat(),
+            "score_type": score_type,
         }
+        site_country = getattr(self.row, "site_country", None)
+        if site_country:
+            payload["site_country"] = site_country
         return payload
 
     def post(
@@ -500,17 +514,17 @@ class ProcessedMetadataValidation:
         "visit_order",
         "coa_id",
         "timestamp",
-        "recording",
         "recording_order",
         "workflow",
     ]
 
-    OPTIONAL_COLUMNS = ["rater_id", "language"]
+    OPTIONAL_COLUMNS = ["rater_id", "language", "site_country", "age", "sex", "race"]
 
     def __init__(
         self,
         csv_path: str,
         force_upload: bool = False,
+        score_type: str = "rater",
     ):
         """
         Initialize validator with CSV file path.
@@ -523,6 +537,7 @@ class ProcessedMetadataValidation:
         self.errors = []
         self.transformed_df = None
         self.force_upload = force_upload
+        self.score_type = score_type
 
     def validate_columns(self) -> bool:
         """
@@ -540,6 +555,28 @@ class ProcessedMetadataValidation:
             return False
         return True
 
+    def validate_recording_field(self) -> bool:
+        """
+        Validate the recording column based on score_type.
+        - rater:    recording column must be present and non-blank for every row.
+        - reviewer: recording column may be absent or blank.
+        """
+        if self.score_type == "rater":
+            if "recording" not in self.df.columns:
+                self.errors.append(
+                    "Missing required column: recording (required when score_type='rater')"
+                )
+                return False
+            blank_mask = self.df["recording"].isna() | (
+                self.df["recording"].astype(str).str.strip() == ""
+            )
+            if blank_mask.any():
+                self.errors.append(
+                    "recording must not be blank when score_type='rater'"
+                )
+                return False
+        return True
+
     def validate_data_types(self) -> bool:
         """
         Validate data types for key columns.
@@ -607,6 +644,7 @@ class ProcessedMetadataValidation:
 
         validations = [
             self.validate_columns(),
+            self.validate_recording_field(),
             self.validate_data_types(),
             self.validate_coa_names(),
         ]

{willisapi_client-1.9.4 → willisapi_client-1.9.6}/willisapi_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: willisapi-client
-Version: 1.9.4
+Version: 1.9.6
 Summary: A Python client for willisapi
 Home-page: https://github.com/bklynhlth/willsiapi_client
 Author: bklynhlth