tweak llm and add list voice utils

Author: zh1peng

psyflow/LLM.py

@@ -503,26 +503,19 @@ def translate(
         max_tokens: int = 800
     ) -> str:
         """
-        Translate arbitrary text into the target language, preserving formatting.
-
-        :param text:             The text to translate.
-        :param target_language:  Language to translate into (e.g. "Chinese").
-        :param prompt:           Optional custom instruction. If None, a default
-                                 “Translate the following text into X…” prompt is used.
-        :param deterministic:    If True, forces deterministic decoding (temp=0, top_p=1).
-        :param temperature:      Sampling temperature (ignored if deterministic).
-        :param max_tokens:       Maximum tokens to generate in the translation.
-        :return:                 The translated text.
-        """
-        # 1) Build instruction
-        instr = prompt or f"Translate the following text into {target_language}, preserving formatting."
-
-        # 2) Build JSON payload for clarity and structure
-        payload = {
-            "instruction": instr,
-            "text":        text
-        }
-        full_prompt = json.dumps(payload, indent=2, ensure_ascii=False)
+        Translate arbitrary text into the target language, preserving formatting
+        and placeholders. Returns only the translated text—no explanations.
+        """
+        # 1) Build a strict instruction
+        instr = prompt or (
+            f"Translate the following text into {target_language}. "
+            "Output ONLY the translated text, preserving orignal formatting, "
+            "indentation, and placeholder tokens (e.g. {field}). "
+            "Do NOT include any explanations or comments."
+        )
+
+        # 2) Combine instruction and text
+        full_prompt = instr + "\n\n" + text
 
         # 3) Record prompt & token count
         self.last_prompt = full_prompt
@@ -534,14 +527,20 @@ def translate(
             deterministic=deterministic,
             temperature=temperature,
             max_tokens=max_tokens
-        )
+        ) or ""
 
         # 5) Record response & its token count
         self.last_response = result
         self.last_response_token_count = self._count_tokens(result)
 
         return result
 
+    def _str_presenter(dumper, data):
+        # if the string has a newline, use block style;
+        # otherwise fall back to the default
+        style = '|' if '\n' in data else None
+        return dumper.represent_scalar('tag:yaml.org,2002:str', data, style=style)
+
     def translate_config(
         self,
         target_language: str,
@@ -559,21 +558,20 @@ def translate_config(
           - any stimuli entries where type is 'text' or 'textbox'
 
         If `config` is:
-          • a file path (str) → load via load_config()
+          • a file path (str) → loaded via load_config()
           • a dict returned from load_config()
-          • None → will look for "./config/config.yaml" by default
+          • None → defaults to "./config/config.yaml"
 
         If `output_dir` is provided, writes out a translated YAML:
-          • filename is `output_name` if given, else
-            original basename + ".translated.yaml".
+          filename is `output_name` if given, else original basename + ".translated.yaml".
 
-        Returns the final raw YAML dict.
+        Returns the updated raw YAML dict.
         """
         # 1) Determine config source
         if config is None:
             default_path = os.path.join(os.getcwd(), "config", "config.yaml")
             if not os.path.exists(default_path):
-                raise FileNotFoundError(f"No config given and default not found at {default_path}")
+                raise FileNotFoundError(f"No config found at {default_path}")
             config = default_path
 
         # 2) Load or unwrap structured config
@@ -595,7 +593,10 @@ def translate_config(
                 mapping[key] = self.translate(
                     text=val,
                     target_language=target_language,
-                    prompt=prompt or f"Translate this label into {target_language}:",
+                    prompt=prompt or (
+                        f"Translate this label into {target_language}. "
+                         "Output ONLY the translated text, preserving original format. No trailing newline"
+                    ),
                     deterministic=deterministic,
                     temperature=temperature,
                     max_tokens=max_tokens
@@ -604,29 +605,67 @@ def translate_config(
         # 4) Translate stimuli text fields
         stim_config = structured['stim_config']
         for name, spec in stim_config.items():
-            stype = spec.get('type')
-            if stype in ('text', 'textbox') and 'text' in spec:
+            if spec.get('type') in ('text', 'textbox') and 'text' in spec:
                 original = spec['text']
                 if isinstance(original, str) and original.strip():
-                    translated = self.translate(
+                    raw_yaml['stimuli'][name]['text'] = self.translate(
                         text=original,
                         target_language=target_language,
-                        prompt=prompt or f"Translate this stimulus text into {target_language}:",
+                        prompt=prompt or (
+                            f"Translate this stimulus text into {target_language}. "
+                            "Output ONLY the translated text, preserving original format. No trailing newline"
+                        ),
                         deterministic=deterministic,
                         temperature=temperature,
                         max_tokens=max_tokens
                     )
-                    raw_yaml['stimuli'][name]['text'] = translated
 
         # 5) Optionally write translated YAML to disk
         if output_dir:
             os.makedirs(output_dir, exist_ok=True)
             filename = output_name or f"{original_name}.translated.yaml"
             out_path = os.path.join(output_dir, filename)
+            
+            LLMDumper = type("LLMDumper", (yaml.SafeDumper,), {})
+            def _str_presenter(dumper, data):
+                style = '|' if '\n' in data else None
+                return dumper.represent_scalar(
+                    'tag:yaml.org,2002:str',
+                    data,
+                    style=style
+                )
+            LLMDumper.add_representer(str, _str_presenter)
+            def _list_presenter(dumper, data):
+            # inline only for lists of scalars length ≤ 10
+                if (
+                    len(data) <= 10 and
+                    all(not isinstance(x, (dict, list)) for x in data)
+                ):
+                    flow = True
+                else:
+                    flow = False
+                return dumper.represent_sequence("tag:yaml.org,2002:seq", data, flow_style=flow)
+            LLMDumper.add_representer(list, _list_presenter)
+
+            # Monkey‐patch it onto SafeDumper:
+            yaml.SafeDumper.add_representer(str, _str_presenter)
             with open(out_path, 'w', encoding='utf-8') as f:
-                yaml.safe_dump(raw_yaml, f, allow_unicode=True)
+                yaml.dump(raw_yaml, f, allow_unicode=True,sort_keys=False, Dumper=LLMDumper)
+        
+        task_keys = ['window', 'task', 'timing']
+        structured_config = {
+            'raw': raw_yaml,
+            'task_config': {k: v for key in task_keys for k, v in raw_yaml.get(key, {}).items()},
+            'stim_config': raw_yaml.get('stimuli', {}),
+            'subform_config': {
+                'subinfo_fields': raw_yaml.get('subinfo_fields', []),
+                'subinfo_mapping': raw_yaml.get('subinfo_mapping', {}),
+            },
+            'trigger_config': raw_yaml.get('triggers', {}),
+            'controller_config': raw_yaml.get('controller', {}),
+        }
 
-        return raw_yaml
+        return structured_config
 
 
     def doc2task(

psyflow/templates/task2doc_prompt.txt

@@ -34,10 +34,10 @@ Extract the full task name and use it as the document’s top-level heading.
   - PsyFlow Version  
   - PsychoPy Version  
 
-## 2. Task Overview  
+## 1. Task Overview  
 • One concise paragraph summarizing the goal and design of the task.
 
-## 3. Task Flow  
+## 2. Task Flow  
 Split into two subtables—**Block-Level Flow** and **Trial-Level Flow**—plus **Controller Logic** and **other logics** if `util.py` exists.  
 • Block-Level Flow comes from `main.py`.  
 • Trial-Level Flow comes from `run_trial.py`.  
@@ -47,7 +47,7 @@ Split into two subtables—**Block-Level Flow** and **Trial-Level Flow**—plus
 Leave a blank line after each table before continuing.  
 Each description must be detailed enough that an LLM could reconstruct the code. Incorporate any timing parameters or stimuli defined in `config.yaml` into the descriptions.
 
-## 4. Configuration Summary  
+## 3. Configuration Summary  
 Note that all settings live in `config/config.yaml`. 
 In this section, summarize each subsection in its own table (with header, separator, blank line):
 
@@ -73,9 +73,9 @@ Example:
 
 **f. Adaptive Controller (if exists)** — a table with columns: Parameter, Value  
 
-## 5. Methods (for academic publication)  
+## 4. Methods (for academic publication)  
 Write this like a Methods section in a paper, with academic tone and clarity.
-Prepare one or two paragraph containing the following:   
+Prepare two or three paragraphs containing the following:   
 - What participants see at each step  
 - Any adaptive algorithms or parameters  
 - The rationale behind major design choices  

psyflow/utils.py

@@ -162,3 +162,47 @@ def initialize_exp(settings, screen_id: int = 1) -> Tuple[Window, keyboard.Keybo
     logging.console.setLevel(logging.INFO)
 
     return win, kb
+
+
+
+import asyncio
+from edge_tts import VoicesManager
+from typing import Optional
+async def _list_supported_voices_async(filter_lang: Optional[str] = None):
+    vm = await VoicesManager.create()
+    voices = vm.voices
+    if filter_lang:
+        voices = [v for v in voices if v["Locale"].startswith(filter_lang)]
+    return voices
+def list_supported_voices(
+    filter_lang: Optional[str] = None,
+    human_readable: bool = False
+):
+    """
+    – Returns raw voice dicts if human_readable=False.
+    – Prints a formatted table (including VoicePersonalities) if human_readable=True.
+    """
+    voices = asyncio.run(_list_supported_voices_async(filter_lang))
+    if not human_readable:
+        return voices
+
+    # Table header including the Personalities column
+    header = (
+        f"{'ShortName':25} {'Locale':10} {'Gender':8} "
+        f"{'Personalities':30} {'FriendlyName'}"
+    )
+    separator = "-" * len(header)
+    print(header)
+    print(separator)
+
+    for v in voices:
+        short = v.get("ShortName", "")[:25]
+        loc   = v.get("Locale", "")[:10]
+        gen   = v.get("Gender", "")[:8]
+        # Extract the personalities list and join with commas
+        pers_list = v.get("VoiceTag", {}).get("VoicePersonalities", [])
+        pers = ", ".join(pers_list)[:30]
+        # Use FriendlyName as the display name
+        disp  = v.get("FriendlyName", v.get("Name", ""))
+
+        print(f"{short:25} {loc:10} {gen:8} {pers:30} {disp}")