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

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

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

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

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

willisapi_client-1.9.8/willisapi_client/services/metadata/archive.py

@@ -0,0 +1,83 @@
+import os
+import requests
+
+from willisapi_client.willisapi_client import WillisapiClient
+from willisapi_client.logging_setup import logger as logger
+
+
+def _archive_headers(api_key):
+    return {
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+        "Authorization": f"token {api_key}",
+    }
+
+
+def archive_metadata_csv(api_key, csv_path, total_rows, upload_type, env=None):
+    """Archive the source metadata CSV alongside the data upload.
+
+    Creates a server-side tracking row, then PUTs the raw CSV to the returned
+    presigned S3 URL. Returns the tracking ``record_id`` on success (so the
+    caller can finalize it with row counts), or ``None`` on failure.
+
+    All failures are logged and swallowed — archiving must never abort the
+    actual data upload.
+    """
+    try:
+        wc = WillisapiClient(env=env)
+        payload = {
+            "filename": os.path.basename(csv_path),
+            "total_rows": total_rows,
+            "upload_type": upload_type,
+        }
+        res = requests.post(
+            wc.get_csv_archive_url(), headers=_archive_headers(api_key), json=payload
+        )
+        if res.status_code != 201:
+            logger.warning(f"CSV archive init failed: {res.status_code} {res.text}")
+            return None
+
+        body = res.json()
+        record_id = body.get("record_id")
+        presigned = body.get("presigned_url")
+        if not presigned:
+            logger.warning("CSV archive: no presigned URL returned")
+            return None
+
+        with open(csv_path, "rb") as f:
+            put_res = requests.put(
+                presigned, data=f, headers={"Content-Type": "text/csv"}
+            )
+        if put_res.status_code not in (200, 204):
+            logger.warning(f"CSV archive S3 upload failed: {put_res.status_code}")
+            finalize_metadata_csv(api_key, record_id, "failed", 0, 0, env=env)
+            return None
+
+        return record_id
+    except Exception as ex:
+        logger.warning(f"CSV archive error: {ex}")
+        return None
+
+
+def finalize_metadata_csv(
+    api_key, record_id, status, successful_rows, failed_rows, env=None
+):
+    """Report the CSV archive outcome and parsed row counts to the server."""
+    if not record_id:
+        return
+    try:
+        wc = WillisapiClient(env=env)
+        payload = {
+            "status": status,
+            "successful_rows": successful_rows,
+            "failed_rows": failed_rows,
+        }
+        res = requests.patch(
+            wc.get_csv_archive_finalize_url(record_id),
+            headers=_archive_headers(api_key),
+            json=payload,
+        )
+        if res.status_code != 200:
+            logger.warning(f"CSV archive finalize failed: {res.status_code} {res.text}")
+    except Exception as ex:
+        logger.warning(f"CSV archive finalize error: {ex}")

willisapi_client-1.9.8/willisapi_client/services/metadata/language_choices.py

@@ -0,0 +1,124 @@
+# https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html
+# (language_code, display_name)
+SUPPORTED_LANGUAGES = [
+    ("en-US", "English (US)"),
+    ("es-US", "Spanish (US)"),
+    ("ab-GE", "Abkhaz"),
+    ("af-ZA", "Afrikaans"),
+    ("sq-AL", "Albanian"),
+    ("am-ET", "Amharic"),
+    ("ar-AE", "Arabic, Gulf"),
+    ("ar-SA", "Arabic, Modern Standard"),
+    ("hy-AM", "Armenian"),
+    ("ast-ES", "Asturian"),
+    ("az-AZ", "Azerbaijani"),
+    ("ba-RU", "Bashkir"),
+    ("eu-ES", "Basque"),
+    ("be-BY", "Belarusian"),
+    ("bn-IN", "Bengali"),
+    ("bs-BA", "Bosnian"),
+    ("my-MM", "Burmese"),
+    ("bg-BG", "Bulgarian"),
+    ("ca-ES", "Catalan"),
+    ("ckb-IR", "Central Kurdish (Iran)"),
+    ("ckb-IQ", "Central Kurdish (Iraq)"),
+    ("zh-HK", "Chinese, Cantonese"),
+    ("zh-CN", "Chinese, Simplified"),
+    ("zh-TW", "Chinese, Traditional"),
+    ("hr-HR", "Croatian"),
+    ("cs-CZ", "Czech"),
+    ("da-DK", "Danish"),
+    ("nl-NL", "Dutch"),
+    ("en-AU", "English, Australian"),
+    ("en-GB", "English, British"),
+    ("en-IN", "English, Indian"),
+    ("en-IE", "English, Irish"),
+    ("en-NZ", "English, New Zealand"),
+    ("en-AB", "English, Scottish"),
+    ("en-ZA", "English, South African"),
+    ("en-WL", "English, Welsh"),
+    ("et-EE", "Estonian"),
+    ("et-ET", "Estonian (et-ET)"),
+    ("fa-IR", "Farsi"),
+    ("fa-AF", "Farsi, Afghan"),
+    ("fi-FI", "Finnish"),
+    ("fr-FR", "French"),
+    ("fr-CA", "French, Canadian"),
+    ("gl-ES", "Galician"),
+    ("ka-GE", "Georgian"),
+    ("de-DE", "German"),
+    ("de-CH", "German, Swiss"),
+    ("el-GR", "Greek"),
+    ("gu-IN", "Gujarati"),
+    ("ht-HT", "Haitian Creole"),
+    ("ha-NG", "Hausa"),
+    ("he-IL", "Hebrew"),
+    ("hi-IN", "Hindi, Indian"),
+    ("hu-HU", "Hungarian"),
+    ("is-IS", "Icelandic"),
+    ("id-ID", "Indonesian"),
+    ("it-IT", "Italian"),
+    ("ja-JP", "Japanese"),
+    ("jv-ID", "Javanese"),
+    ("kab-DZ", "Kabyle"),
+    ("kn-IN", "Kannada"),
+    ("kk-KZ", "Kazakh"),
+    ("km-KH", "Khmer"),
+    ("rw-RW", "Kinyarwanda"),
+    ("ko-KR", "Korean"),
+    ("ky-KG", "Kyrgyz"),
+    ("lv-LV", "Latvian"),
+    ("lt-LT", "Lithuanian"),
+    ("lg-IN", "Luganda"),
+    ("mk-MK", "Macedonian"),
+    ("ms-MY", "Malay"),
+    ("ml-IN", "Malayalam"),
+    ("mt-MT", "Maltese"),
+    ("mr-IN", "Marathi"),
+    ("mhr-RU", "Meadow Mari"),
+    ("mn-MN", "Mongolian"),
+    ("ne-NP", "Nepali"),
+    ("no-NO", "Norwegian Bokmål"),
+    ("or-IN", "Odia/Oriya"),
+    ("ps-AF", "Pashto"),
+    ("pl-PL", "Polish"),
+    ("pt-PT", "Portuguese"),
+    ("pt-BR", "Portuguese, Brazilian"),
+    ("pa-IN", "Punjabi"),
+    ("ro-RO", "Romanian"),
+    ("ru-RU", "Russian"),
+    ("sr-RS", "Serbian"),
+    ("si-LK", "Sinhala"),
+    ("sk-SK", "Slovak"),
+    ("sl-SI", "Slovenian"),
+    ("so-SO", "Somali"),
+    ("es-ES", "Spanish"),
+    ("es-MX", "Spanish, Mexican"),
+    ("su-ID", "Sundanese"),
+    ("sw-KE", "Swahili, Kenya"),
+    ("sw-BI", "Swahili, Burundi"),
+    ("sw-RW", "Swahili, Rwanda"),
+    ("sw-TZ", "Swahili, Tanzania"),
+    ("sw-UG", "Swahili, Uganda"),
+    ("sv-SE", "Swedish"),
+    ("tl-PH", "Tagalog/Filipino"),
+    ("ta-IN", "Tamil"),
+    ("tt-RU", "Tatar"),
+    ("te-IN", "Telugu"),
+    ("th-TH", "Thai"),
+    ("tr-TR", "Turkish"),
+    ("uk-UA", "Ukrainian"),
+    ("ug-CN", "Uyghur"),
+    ("uz-UZ", "Uzbek"),
+    ("vi-VN", "Vietnamese"),
+    ("cy-WL", "Welsh"),
+    ("wo-SN", "Wolof"),
+    ("zu-ZA", "Zulu"),
+]
+
+LANGUAGE_CHOICES = [code for code, _ in SUPPORTED_LANGUAGES]
+
+SEX_CHOICES = [
+    ("Male", "M"),
+    ("Female", "F"),
+]

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

@@ -4,6 +4,8 @@ from datetime import datetime
 import requests
 import mimetypes
 import os
+import time
+from concurrent.futures import ThreadPoolExecutor
 
 # 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.
@@ -16,13 +18,54 @@ from willisapi_client.services.metadata.utils import (
     MetadataValidation,
     ProcessedMetadataValidation,
     UploadUtils,
+    build_retry_session,
     find_files_with_pattern,
     get_last_n_directories,
 )
+from willisapi_client.services.metadata.archive import (
+    archive_metadata_csv,
+    finalize_metadata_csv,
+)
 
 VALID_SCORE_TYPES = ["rater", "reviewer"]
 
 
+def _put_file_to_s3(file_presigned: dict):
+    """Upload a single file to its presigned S3 URL.
+
+    Returns an error string if the upload fails, otherwise None. Presigned
+    URLs from a single recording are all signed at once and share one expiry
+    window, so callers should run these concurrently to fit within it.
+    """
+    presigned = file_presigned.get("presigned")
+    checksum = file_presigned.get("checksum")
+    recording = file_presigned.get("recording")
+    try:
+        content_type, _ = mimetypes.guess_type(recording)
+        if not content_type:
+            content_type = "text/csv"
+        with open(recording, "rb") as f:
+            session = build_retry_session()
+            response = session.put(
+                presigned,
+                data=f,
+                headers={
+                    "x-amz-checksum-sha256": checksum,
+                    "x-amz-sdk-checksum-algorithm": "SHA256",
+                    "Content-Type": content_type,
+                },
+                timeout=(10, 300),
+            )
+        if response.status_code != 200:
+            return (
+                f"S3 upload failed with status code {response.status_code} "
+                f"for file {recording}: {response.text}"
+            )
+    except Exception as ex:
+        return str(ex)
+    return None
+
+
 @measure
 def upload(api_key: str, csv_path: str, **kwargs):
 
@@ -38,6 +81,15 @@ def upload(api_key: str, csv_path: str, **kwargs):
         headers["Authorization"] = f"token {api_key}"
         logger.info(f'{datetime.now().strftime("%H:%M:%S")}: beginning upload')
 
+        # Archive the source metadata CSV and open a tracking record.
+        archive_record_id = archive_metadata_csv(
+            api_key,
+            csv_path,
+            int(csv.transformed_df.shape[0]),
+            upload_type="data",
+            env=kwargs.get("env"),
+        )
+
         results = []
         for index, row in tqdm(
             csv.transformed_df.iterrows(), total=csv.transformed_df.shape[0]
@@ -62,7 +114,8 @@ def upload(api_key: str, csv_path: str, **kwargs):
                             if not content_type:
                                 content_type = "application/octet-stream"
                             with open(row.file_path, "rb") as f:
-                                response = requests.put(
+                                session = build_retry_session()
+                                response = session.put(
                                     presigned,
                                     data=f,
                                     headers={
@@ -72,13 +125,14 @@ def upload(api_key: str, csv_path: str, **kwargs):
                                         "x-amz-sdk-checksum-algorithm": "SHA256",
                                         "Content-Type": content_type,
                                     },
+                                    timeout=(10, 300),
                                 )
                             if response.status_code == 200:
                                 result_row["upload_status"] = "Success"
                             else:
                                 result_row["upload_status"] = "Failed"
                                 result_row["error"] = (
-                                    f"S3 upload failed with status code {response.status_code}"
+                                    f"S3 upload failed with status code {response.status_code}: {response.text}"
                                 )
                         except Exception as ex:
                             result_row["upload_status"] = "Failed"
@@ -96,6 +150,16 @@ def upload(api_key: str, csv_path: str, **kwargs):
                 result_row["error"] = f"{err}"
             results.append(result_row)
 
+        successful_rows = sum(1 for r in results if r.get("upload_status") == "Success")
+        finalize_metadata_csv(
+            api_key,
+            archive_record_id,
+            "successful",
+            successful_rows,
+            len(results) - successful_rows,
+            env=kwargs.get("env"),
+        )
+
         results_df = pd.DataFrame(results)
         return results_df
     else:
@@ -128,7 +192,22 @@ def processed_upload(api_key: str, csv_path: str, output_path: str, **kwargs):
         headers["Authorization"] = f"token {api_key}"
         logger.info(f'{datetime.now().strftime("%H:%M:%S")}: beginning upload')
 
+        # Archive the source processed-data metadata CSV and open a tracking record.
+        archive_record_id = archive_metadata_csv(
+            api_key,
+            csv_path,
+            int(csv.transformed_df.shape[0]),
+            upload_type="processed_data",
+            env=kwargs.get("env"),
+        )
+
         results = []
+        # Throttle S3 uploads: pause 3s each time the running total of files
+        # sent to S3 crosses another 100, to avoid overwhelming the connection.
+        S3_SLEEP_EVERY = 100
+        S3_SLEEP_SECONDS = 3
+        s3_uploaded_total = 0
+        next_sleep_threshold = S3_SLEEP_EVERY
         for index, row in tqdm(
             csv.transformed_df.iterrows(), total=csv.transformed_df.shape[0]
         ):
@@ -167,33 +246,26 @@ def processed_upload(api_key: str, csv_path: str, output_path: str, **kwargs):
                     result_row["upload_status"] = "Success"
                     result_row["error"] = None
 
-                    # Handle S3 upload if presigned URL is provided
+                    # Upload every file for this recording concurrently. All
+                    # presigned URLs in this response share one short expiry
+                    # window, so uploading them sequentially risks the later
+                    # files expiring (403). A thread pool sized to the CPU
+                    # count keeps them within the window (I/O-bound work).
+                    files_to_upload = res.get("response", [])
                     s3_errors = []
-                    for file_presigned in res.get("response", []):
-                        presigned = file_presigned.get("presigned")
-                        checksum = file_presigned.get("checksum")
-                        recording = file_presigned.get("recording")
-                        index = file_presigned.get("index")
-                        try:
-                            content_type, _ = mimetypes.guess_type(recording)
-                            if not content_type:
-                                content_type = "text/csv"
-                            with open(recording, "rb") as f:
-                                response = requests.put(
-                                    presigned,
-                                    data=f,
-                                    headers={
-                                        "x-amz-checksum-sha256": checksum,
-                                        "x-amz-sdk-checksum-algorithm": "SHA256",
-                                        "Content-Type": content_type,
-                                    },
-                                )
-                            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:
-                            s3_errors.append(str(ex))
+                    if files_to_upload:
+                        max_workers = min(len(files_to_upload), os.cpu_count() or 1)
+                        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                            for error in executor.map(
+                                _put_file_to_s3, files_to_upload
+                            ):
+                                if error:
+                                    s3_errors.append(error)
+                        # Pause after every 100 files uploaded to S3.
+                        s3_uploaded_total += len(files_to_upload)
+                        while s3_uploaded_total >= next_sleep_threshold:
+                            time.sleep(S3_SLEEP_SECONDS)
+                            next_sleep_threshold += S3_SLEEP_EVERY
                     if s3_errors:
                         result_row["upload_status"] = "Failed"
                         result_row["error"] = "\n".join(s3_errors)
@@ -205,6 +277,16 @@ def processed_upload(api_key: str, csv_path: str, output_path: str, **kwargs):
                 result_row["error"] = f"{err}"
             results.append(result_row)
 
+        successful_rows = sum(1 for r in results if r.get("upload_status") == "Success")
+        finalize_metadata_csv(
+            api_key,
+            archive_record_id,
+            "successful",
+            successful_rows,
+            len(results) - successful_rows,
+            env=kwargs.get("env"),
+        )
+
         results_df = pd.DataFrame(results)
         return results_df
     else:

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

@@ -6,6 +6,9 @@ import os
 import hashlib
 import base64
 import requests
+from functools import lru_cache
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
 from urllib.parse import urlsplit
 from .language_choices import (
     LANGUAGE_CHOICES,
@@ -14,6 +17,32 @@ from dateutil import parser
 
 ALLOWED_COA_NAMES = ["MADRS", "YMRS", "PHQ-9", "GAD-7", "HAM-D17", "HAMD17"]
 
+@lru_cache(maxsize=None)
+def build_retry_session(total: int = 3, backoff_factor: float = 1) -> requests.Session:
+    """Return a requests Session that retries transient network failures.
+
+    Retries connection errors (e.g. ConnectionResetError / 'Connection reset
+    by peer') and 5xx gateway responses with exponential backoff. Applied to
+    both the metadata POST and the S3 PUT uploads so a momentary blip on a
+    single record no longer fails the whole upload for that row.
+    """
+    retry = Retry(
+        total=total,
+        connect=total,
+        read=total,
+        status=total,
+        backoff_factor=backoff_factor,
+        status_forcelist=[502, 503, 504],
+        allowed_methods=["PUT", "POST"],
+        raise_on_status=False,
+    )
+    # Increased pool size to accommodate concurrent ThreadPoolExecutor uploads
+    adapter = HTTPAdapter(max_retries=retry, pool_connections=100, pool_maxsize=100)
+    session = requests.Session()
+    session.mount("https://", adapter)
+    session.mount("http://", adapter)
+    return session
+
 COA_ITEM_COUNTS = {
     "MADRS": 10,
     "YMRS": 10,
@@ -421,13 +450,15 @@ class UploadUtils:
     def validate_row(self):
         if not os.path.exists(self.row.file_path):
             return (False, "File path does not exist")
-        if self.row.language not in LANGUAGE_CHOICES:
-            return (False, f"Invalid language: {self.row.language}")
+        language = getattr(self.row, "language", None)
+        if language and language not in LANGUAGE_CHOICES:
+            return (False, f"Invalid language: {language}")
         return (True, None)
 
     def validate_processed_data_row(self):
-        if self.row.language not in LANGUAGE_CHOICES:
-            return (False, f"Invalid language: {self.row.language}")
+        language = getattr(self.row, "language", None)
+        if language and language not in LANGUAGE_CHOICES:
+            return (False, f"Invalid language: {language}")
         return (True, None)
 
     def calculate_file_checksum(self, file_path: str) -> str:
@@ -493,7 +524,10 @@ class UploadUtils:
         self, api_key: str, url: str, headers: Dict[str, str], payload: Dict[str, Any]
     ) -> Dict[str, Any]:
         try:
-            response = requests.post(url, headers=headers, json=payload)
+            session = build_retry_session()
+            response = session.post(
+                url, headers=headers, json=payload, timeout=(10, 300)
+            )
             res_json = response.json()
 
         except Exception as ex:

{willisapi_client-1.9.6 → willisapi_client-1.9.8}/willisapi_client/willisapi_client.py

@@ -14,18 +14,19 @@ class WillisapiClient:
     def __init__(self, *args, **kwargs) -> None:
         self.client_version = get_client_version()
         self.api_version = math.floor(self.client_version)
-        self.api_uri = "api.brooklyn.health"
+        self.api_uri = "api.willis.health"
         self.env = kwargs["env"] if "env" in kwargs else None
 
-    def get_base_url(self):
+    def get_api_host(self):
         if self.env:
-            return f"https://{self.env}-{self.api_uri}/v{self.api_version}/"
-        return f"https://{self.api_uri}/v{self.api_version}/"
+            return f"api.{self.env}.willis.health"
+        return self.api_uri
+
+    def get_base_url(self):
+        return f"https://{self.get_api_host()}/v{self.api_version}/"
 
     def get_base_v2_url(self):
-        if self.env:
-            return f"https://{self.env}-{self.api_uri}/api/v2/"
-        return f"https://{self.api_uri}/api/v2/"
+        return f"https://{self.get_api_host()}/api/v2/"
 
     def get_diarize_remaining_calls_url(self):
         return self.get_base_url() + "willis-diarize-call-remaining"
@@ -35,9 +36,15 @@ class WillisapiClient:
 
     def get_upload_url(self):
         return self.get_base_v2_url() + "metadata/upload"
-    
+
     def get_processed_upload_url(self):
         return self.get_base_v2_url() + "metadata/processed-data/upload"
 
+    def get_csv_archive_url(self):
+        return self.get_base_v2_url() + "metadata/csv-archive"
+
+    def get_csv_archive_finalize_url(self, record_id):
+        return self.get_csv_archive_url() + f"/{record_id}"
+
     def get_headers(self):
         return {"Content-Type": "application/json", "Accept": "application/json"}

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

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

{willisapi_client-1.9.6 → willisapi_client-1.9.8}/willisapi_client.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ willisapi_client/services/diarize/diarize_utils.py
 willisapi_client/services/diarize/willisdiarize.py
 willisapi_client/services/diarize/willisdiarize_call_remaining.py
 willisapi_client/services/metadata/__init__.py
+willisapi_client/services/metadata/archive.py
 willisapi_client/services/metadata/language_choices.py
 willisapi_client/services/metadata/upload.py
 willisapi_client/services/metadata/utils.py

willisapi_client-1.9.6/willisapi_client/services/metadata/language_choices.py

@@ -1,86 +0,0 @@
-# https://docs.aws.amazon.com/transcribe/latest/dg/supported-languages.html
-Afrikaans = "af-ZA"
-Arabic_gulf = "ar-AE"
-Arabic_modern_standard = "ar-SA"
-Chinese_simplified = "zh-CN"
-Chinese_traditional = "zh-TW"
-Danish = "da-DK"
-Dutch = "nl-NL"
-English_aus = "en-AU"
-English_birtish = "en-GB"
-English_ind = "en-IN"
-English_irish = "en-IE"
-English_new_zealand = "en-NZ"
-English_scottish = "en-AB"
-English_south_african = "en-ZA"
-English_us = "en-US"
-English_welsh = "en-WL"
-French = "fr-FR"
-French_canadian = "fr-CA"
-Farsi = "fa-IR"
-German = "de-DE"
-German_swiss = "de-CH"
-Hebrew = "he-IL"
-Hindi_ind = "hi-IN"
-Indonesian = "id-ID"
-Italian = "it-IT"
-Japanese = "ja-JP"
-Korean = "ko-KR"
-Malay = "ms-MY"
-Portuguese = "pt-PT"
-Portuguese_brazilian = "pt-BR"
-Russian = "ru-RU"
-Spanish = "es-ES"
-Spanish_us = "es-US"
-Swedish = "sv-SE"
-Tamil = "ta-IN"
-Telugu = "te-IN"
-Thai = "th-TH"
-Turkish = "tr-TR"
-Vietnamese = "vi-VN"
-
-LANGUAGE_CHOICES = [
-    Afrikaans,
-    Arabic_gulf,
-    Arabic_modern_standard,
-    Chinese_simplified,
-    Chinese_traditional,
-    Danish,
-    Dutch,
-    English_aus,
-    English_birtish,
-    English_ind,
-    English_irish,
-    English_new_zealand,
-    English_scottish,
-    English_south_african,
-    English_us,
-    English_welsh,
-    French,
-    French_canadian,
-    Farsi,
-    German,
-    German_swiss,
-    Hebrew,
-    Hindi_ind,
-    Indonesian,
-    Italian,
-    Japanese,
-    Korean,
-    Malay,
-    Portuguese,
-    Portuguese_brazilian,
-    Russian,
-    Spanish,
-    Spanish_us,
-    Swedish,
-    Tamil,
-    Telugu,
-    Thai,
-    Turkish,
-    Vietnamese,
-]
-SEX_CHOICES = [
-    ("Male", "M"),
-    ("Female", "F"),
-]