experiment_server 0.3.7__tar.gz → 0.3.8__tar.gz

{experiment_server-0.3.7 → experiment_server-0.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: experiment_server
-Version: 0.3.7
+Version: 0.3.8
 Summary: Server for experiments to get configuarations from
 License: MIT
 Keywords: experiment,study-design
@@ -77,7 +77,7 @@ $ poetry add experiment-server
 
 A terminal-based user interface is provided for interactive management and monitoring of an experiment. It is useful when you want a lightweight, keyboard-driven interface to load configs, inspect/generate per‑participant configs, edit files, and control participant flow without using the web UI.
 
-Launch the TUI with:
+### Launch the TUI with:
 
 ```sh
 # Start TUI (optionally provide a config file)
@@ -88,35 +88,77 @@ $ experiment-server ui -c sample_config.toml
 $ experiment-server ui -c sample_config.toml -i 1 -h 127.0.0.1 -p 5000
 ```
 
-Options:
+### Options:
+
 - -c, --config-file : path to a .toml config to load on start (optional).
-- -i, --default-participant-index : default participant index to use when no explicit participant id is provided (default 1).
-- -h, --host : host/interface for the server (default 127.0.0.1).
-- -p, --port : port for the server (default 5000).
 
-Behavior and features
+- -i, --default-participant-index : default participant index to use when no explicit participant id is provided (default 1). (optional)
+
+- -h, --host : host/interface for the server (default 127.0.0.1). (optional)
+
+- -p, --port : port for the server (default 5000). (optional)
+
+- --editor-only : Launch the editor only. "-i", "-h", and "-p" will be ignored. When launching ui with "--editor-only", the config file ("-c") must be passed as well. (optional)
+
+### Behavior and features
+
+- Startup config validation - When launching the full TUI (without --editor-only), if a config file is provided it is validated at startup. If validation fails, the TUI will refuse to start the full UI/server and will exit with an error message suggesting use of verify-config-file or the editor-only mode to edit the file.
+
 - Can be started without a config file; load a config later from the built-in file browser (filters to directories and .toml files).
+
 - When a config is loaded the package starts the server in the same event loop, exposing the same REST API described elsewhere in this README.
+
 - Participant management:
+
   - View all participants and their status, block id and block name.
+
   - Create new participants (auto id or a specific id).
+
   - Move the default or a specific participant to the next block or to a specific block id.
+
   - Move all active participants to a block.
+
   - Reset a participant.
+
   - Choose a monitored participant to view its current config and status.
+
 - Config management:
+
   - View the currently loaded .toml contents in a code editor pane.
+
   - Edit the config in place and save; saving writes the file and the app will attempt to reload the config.
+
   - Generate new config files using simple or advanced helpers (write a minimal example or build from JSON-specified order/blocks/parameters).
+
   - Generate expanded JSON configs for a range of participant indices (write output to a directory).
+
 - Live logging pane shows application logs for actions and errors.
-- A simple edit UI is available to tweak the in-memory per-participant config (submit or cancel edits).
 
-Notes
+- A simple edit UI is available to tweak the in-memory per-participant config (submit or cancel edits). The embedded editor provides:
+  - An "Edit config" flow (Edit / Insert snippet / Save / Cancel).
+
+  - "Insert snippet" to add common TOML fragments (blocks, strategy lines, init/final blocks, new variables).
+
+  - Save-time validation: when you save from the TUI, the editor runs verification (same checks used by [verify-config-file](#verify-config)). If verification fails the UI shows the failure reason and asks you to confirm whether to write the file anyway.
+
+- editor-only TUI - A compact editor-only TUI is available via --editor-only. This launches a simple code editor for editing a config file without starting the HTTP server. Example:
+
+```sh
+# editor-only mode (requires a config file)
+$ experiment-server ui --editor-only -c sample_config.toml
+```
+
+  - Note: --editor-only requires -c/--config-file and will not start the server.
+
+
+### Notes
+
 - Editing and saving the config file from the TUI writes to the same config path the server is using; the TUI will attempt to reload the new configuration but will preserve participant state (see server behavior note in the [Loading experiment through server](#loading-experiment-through-server) section).
+
 - The TUI requires the textual/Rich environment provided by the package (normally installed with the package). Use `Ctrl+q` to exit or the TUI's quit action.
 
 This TUI is intended as a compact, interactive alternative to the web interface for quick testing, config edits, and participant control.
+
 <p style="display:flex; gap:8px; align-items:flex-start;">
   <img src="https://raw.githubusercontent.com/ahmed-shariff/experiment_server/master/media/screenshot_tui1.png" alt="web UI screenshot 1" style="width:49%;">
   <img src="https://raw.githubusercontent.com/ahmed-shariff/experiment_server/master/media/screenshot_tui2.png" alt="web UI screenshot 2" style="width:49%;">
@@ -368,7 +410,13 @@ A config file can be validated by running:
 ```sh
 $ experiment-server verify-config-file sample_config.toml
 ```
-This will show how the expanded config looks like for the first 5 participants.
+This will show how the expanded config looks like for the first 5 participants and will return a clear failure reason if the config is invalid.
+
+You can launch the editor-only [TUI](#textual-ui-tui) to edit the file in-place. This editor also has save time validation which can be used to verify the config before saving.
+
+```sh
+$ experiment-server ui --editor-only -c sample_config.toml
+```
 
 See also [verify_config][experiment_server._process_config.verify_config]
 
@@ -438,9 +486,13 @@ See also [_generate_config_json][experiment_server._api._generate_config_json]
 
 ## Function calls in config
 A function call in the config is represented by a table, with the following keys 
+
 - `function_name`: This should be one of the names in the supported functions list below.
+
 - `args`: The arguments to be passed to the function represented by `function_name`. This can be a list or a table/dict. They should unpack with `*` or `**` respectively when called with the corresponding function.
+
 - (optional) `params`: function-specific configurations to apply with the function calls.
+
 - (optional) `id`: A unique identifier to group function calls.
 
 A table that has keys other than the above keys would not be treated as a function call. Any function calls in different places of the config with the same `id` would be treated as a single group. Tables without an `id` are grouped based on their key-value pairs. Groups are used to identify how some parameters affect the results (e.g., `unique` for `choices`). Function calls can also be in `configurations.variabels`. Note that all function calls are made after the `extends` are resolved and variables from `configurations.variabels` are replaced.

{experiment_server-0.3.7 → experiment_server-0.3.8}/README.md

@@ -38,7 +38,7 @@ $ poetry add experiment-server
 
 A terminal-based user interface is provided for interactive management and monitoring of an experiment. It is useful when you want a lightweight, keyboard-driven interface to load configs, inspect/generate per‑participant configs, edit files, and control participant flow without using the web UI.
 
-Launch the TUI with:
+### Launch the TUI with:
 
 ```sh
 # Start TUI (optionally provide a config file)
@@ -49,35 +49,77 @@ $ experiment-server ui -c sample_config.toml
 $ experiment-server ui -c sample_config.toml -i 1 -h 127.0.0.1 -p 5000
 ```
 
-Options:
+### Options:
+
 - -c, --config-file : path to a .toml config to load on start (optional).
-- -i, --default-participant-index : default participant index to use when no explicit participant id is provided (default 1).
-- -h, --host : host/interface for the server (default 127.0.0.1).
-- -p, --port : port for the server (default 5000).
 
-Behavior and features
+- -i, --default-participant-index : default participant index to use when no explicit participant id is provided (default 1). (optional)
+
+- -h, --host : host/interface for the server (default 127.0.0.1). (optional)
+
+- -p, --port : port for the server (default 5000). (optional)
+
+- --editor-only : Launch the editor only. "-i", "-h", and "-p" will be ignored. When launching ui with "--editor-only", the config file ("-c") must be passed as well. (optional)
+
+### Behavior and features
+
+- Startup config validation - When launching the full TUI (without --editor-only), if a config file is provided it is validated at startup. If validation fails, the TUI will refuse to start the full UI/server and will exit with an error message suggesting use of verify-config-file or the editor-only mode to edit the file.
+
 - Can be started without a config file; load a config later from the built-in file browser (filters to directories and .toml files).
+
 - When a config is loaded the package starts the server in the same event loop, exposing the same REST API described elsewhere in this README.
+
 - Participant management:
+
   - View all participants and their status, block id and block name.
+
   - Create new participants (auto id or a specific id).
+
   - Move the default or a specific participant to the next block or to a specific block id.
+
   - Move all active participants to a block.
+
   - Reset a participant.
+
   - Choose a monitored participant to view its current config and status.
+
 - Config management:
+
   - View the currently loaded .toml contents in a code editor pane.
+
   - Edit the config in place and save; saving writes the file and the app will attempt to reload the config.
+
   - Generate new config files using simple or advanced helpers (write a minimal example or build from JSON-specified order/blocks/parameters).
+
   - Generate expanded JSON configs for a range of participant indices (write output to a directory).
+
 - Live logging pane shows application logs for actions and errors.
-- A simple edit UI is available to tweak the in-memory per-participant config (submit or cancel edits).
 
-Notes
+- A simple edit UI is available to tweak the in-memory per-participant config (submit or cancel edits). The embedded editor provides:
+  - An "Edit config" flow (Edit / Insert snippet / Save / Cancel).
+
+  - "Insert snippet" to add common TOML fragments (blocks, strategy lines, init/final blocks, new variables).
+
+  - Save-time validation: when you save from the TUI, the editor runs verification (same checks used by [verify-config-file](#verify-config)). If verification fails the UI shows the failure reason and asks you to confirm whether to write the file anyway.
+
+- editor-only TUI - A compact editor-only TUI is available via --editor-only. This launches a simple code editor for editing a config file without starting the HTTP server. Example:
+
+```sh
+# editor-only mode (requires a config file)
+$ experiment-server ui --editor-only -c sample_config.toml
+```
+
+  - Note: --editor-only requires -c/--config-file and will not start the server.
+
+
+### Notes
+
 - Editing and saving the config file from the TUI writes to the same config path the server is using; the TUI will attempt to reload the new configuration but will preserve participant state (see server behavior note in the [Loading experiment through server](#loading-experiment-through-server) section).
+
 - The TUI requires the textual/Rich environment provided by the package (normally installed with the package). Use `Ctrl+q` to exit or the TUI's quit action.
 
 This TUI is intended as a compact, interactive alternative to the web interface for quick testing, config edits, and participant control.
+
 <p style="display:flex; gap:8px; align-items:flex-start;">
   <img src="https://raw.githubusercontent.com/ahmed-shariff/experiment_server/master/media/screenshot_tui1.png" alt="web UI screenshot 1" style="width:49%;">
   <img src="https://raw.githubusercontent.com/ahmed-shariff/experiment_server/master/media/screenshot_tui2.png" alt="web UI screenshot 2" style="width:49%;">
@@ -329,7 +371,13 @@ A config file can be validated by running:
 ```sh
 $ experiment-server verify-config-file sample_config.toml
 ```
-This will show how the expanded config looks like for the first 5 participants.
+This will show how the expanded config looks like for the first 5 participants and will return a clear failure reason if the config is invalid.
+
+You can launch the editor-only [TUI](#textual-ui-tui) to edit the file in-place. This editor also has save time validation which can be used to verify the config before saving.
+
+```sh
+$ experiment-server ui --editor-only -c sample_config.toml
+```
 
 See also [verify_config][experiment_server._process_config.verify_config]
 
@@ -399,9 +447,13 @@ See also [_generate_config_json][experiment_server._api._generate_config_json]
 
 ## Function calls in config
 A function call in the config is represented by a table, with the following keys 
+
 - `function_name`: This should be one of the names in the supported functions list below.
+
 - `args`: The arguments to be passed to the function represented by `function_name`. This can be a list or a table/dict. They should unpack with `*` or `**` respectively when called with the corresponding function.
+
 - (optional) `params`: function-specific configurations to apply with the function calls.
+
 - (optional) `id`: A unique identifier to group function calls.
 
 A table that has keys other than the above keys would not be treated as a function call. Any function calls in different places of the config with the same `id` would be treated as a single group. Tables without an `id` are grouped based on their key-value pairs. Groups are used to identify how some parameters affect the results (e.g., `unique` for `choices`). Function calls can also be in `configurations.variabels`. Note that all function calls are made after the `extends` are resolved and variables from `configurations.variabels` are replaced.

{experiment_server-0.3.7 → experiment_server-0.3.8}/experiment_server/_api.py

@@ -6,7 +6,7 @@ from experiment_server._process_config import process_config_file
 from pathlib import Path
 import json
 
-from experiment_server.utils import ExperimentServerExcetion, FileModifiedWatcher
+from experiment_server.utils import ExperimentServerException, FileModifiedWatcher
 
 
 class ParticipantState:
@@ -199,7 +199,7 @@ class Experiment:
         if participant_index is None:
             participant_index = self.default_participant_index
         if participant_index not in self.global_state:
-            raise ExperimentServerExcetion(f"participant with index {participant_index} is not set. Consider using `add_participant_index`")
+            raise ExperimentServerException(f"participant with index {participant_index} is not set. Consider using `add_participant_index`")
         return self.global_state[participant_index]
 
     def get_state(self, participant_index:int|None=None) -> bool:
@@ -286,11 +286,11 @@ def _generate_config_json(config_file: Union[str, Path], participant_indices: It
             logger.info(f"Creating direcotry {out_dir}")
             out_dir.mkdir(parents=True)
         elif not out_dir.is_dir():
-            raise ExperimentServerExcetion(f"`out_file_location` should be a directory. Got {out_dir}")
+            raise ExperimentServerException(f"`out_file_location` should be a directory. Got {out_dir}")
 
     out_files = []
     for participant_index in participant_indices:
-        config = process_config_file(config_file, participant_index, supress_message=True)
+        config = process_config_file(config_file, participant_index, suppress_message=True)
         if out_dir is not None:
             out_file = Path(out_dir) / f"{Path(config_file).stem}-participant_{participant_index}.json"
             out_files.append(out_file)

{experiment_server-0.3.7 → experiment_server-0.3.8}/experiment_server/_client.py

@@ -2,7 +2,7 @@ import json
 from typing import Tuple, Union
 import requests
 
-from experiment_server.utils import ExperimentServerExcetion
+from experiment_server.utils import ExperimentServerException
 
 
 class Client:
@@ -49,7 +49,7 @@ class Client:
         elif verb == "PUT":
             r = requests.put(url)
         else:
-            raise ExperimentServerExcetion("huh?")
+            raise ExperimentServerException("huh?")
 
         if r.status_code != 200:
             return False, {"message": f"status {r.status_code} with text: {r.text}"}

{experiment_server-0.3.7 → experiment_server-0.3.8}/experiment_server/_participant_ordering.py

@@ -3,7 +3,7 @@ import itertools
 from typing import Dict, List, Union
 from easydict import EasyDict as edict
 
-from experiment_server.utils import ExperimentServerConfigurationExcetion, balanced_latin_square
+from experiment_server.utils import ExperimentServerConfigurationException, balanced_latin_square
 
 
 ORDERING_STRATEGY = edict({v:v for v in ["randomize", "latin_square", "as_is"]})
@@ -122,29 +122,29 @@ def construct_participant_condition(config: List[Dict],
     if within_groups_strategy is None:
         within_groups_strategy = ORDERING_STRATEGY.as_is
     elif within_groups_strategy not in list(ORDERING_STRATEGY.values()):
-        raise ExperimentServerConfigurationExcetion(f"Allowed values for `within_groups` are {ORDERING_STRATEGY.values()}, for {within_groups_strategy}")
+        raise ExperimentServerConfigurationException(f"Allowed values for `within_groups` are {ORDERING_STRATEGY.values()}, for {within_groups_strategy}")
 
     if groups_strategy is None:
         groups_strategy = ORDERING_STRATEGY.as_is
     elif groups_strategy not in list(ORDERING_STRATEGY.values()):
-        raise ExperimentServerConfigurationExcetion(f"Allowed values for `groups` are {ORDERING_STRATEGY.values()}, for {groups_strategy}")
+        raise ExperimentServerConfigurationException(f"Allowed values for `groups` are {ORDERING_STRATEGY.values()}, for {groups_strategy}")
 
     if init_blocks_strategy is None:
         init_blocks_strategy = INIT_FINAL_ORDERING_STRATEGY.as_is
     elif init_blocks_strategy not in list(INIT_FINAL_ORDERING_STRATEGY.values()):
-        raise ExperimentServerConfigurationExcetion(f"Allowed values for `init_blocks_strategy` are {INIT_FINAL_ORDERING_STRATEGY.values()}, for {init_blocks_strategy}")
+        raise ExperimentServerConfigurationException(f"Allowed values for `init_blocks_strategy` are {INIT_FINAL_ORDERING_STRATEGY.values()}, for {init_blocks_strategy}")
 
     if final_blocks_strategy is None:
         final_blocks_strategy = INIT_FINAL_ORDERING_STRATEGY.as_is
     elif final_blocks_strategy not in list(INIT_FINAL_ORDERING_STRATEGY.values()):
-        raise ExperimentServerConfigurationExcetion(f"Allowed values for `final_blocks_strategy` are {INIT_FINAL_ORDERING_STRATEGY.values()}, for {final_blocks_strategy}")
+        raise ExperimentServerConfigurationException(f"Allowed values for `final_blocks_strategy` are {INIT_FINAL_ORDERING_STRATEGY.values()}, for {final_blocks_strategy}")
 
     name_to_config_mapping = {}
 
     for c in config:
         name = c["name"] = str(c["name"])
         if name in name_to_config_mapping:
-            raise ExperimentServerConfigurationExcetion(f"Duplicate block name: {name}")
+            raise ExperimentServerConfigurationException(f"Duplicate block name: {name}")
         name_to_config_mapping[c["name"]] = c
 
     if isinstance(order, list):
@@ -153,7 +153,7 @@ def construct_participant_condition(config: List[Dict],
             # Making sure the stratergy set for groups is used for within groups
             within_groups_strategy = groups_strategy
         if not all([isinstance(g, str) for group in order for g in group]):
-            raise ExperimentServerConfigurationExcetion(f"All conditions in order were expected to be strings, got {order}")
+            raise ExperimentServerConfigurationException(f"All conditions in order were expected to be strings, got {order}")
         
         _filtered_order = order
         
@@ -175,7 +175,7 @@ def construct_participant_condition(config: List[Dict],
     elif within_groups_strategy == ORDERING_STRATEGY.latin_square:
         elements_in_group = set([len(_g) for _g  in _filtered_order])
         if len(elements_in_group) != 1:
-            raise ExperimentServerConfigurationExcetion(f"Currently {ORDERING_STRATEGY.latin_square} not supported for `within_groups` when the number of elements in all groups are not the same")
+            raise ExperimentServerConfigurationException(f"Currently {ORDERING_STRATEGY.latin_square} not supported for `within_groups` when the number of elements in all groups are not the same")
         else:
             _elements_count = elements_in_group.pop()
             _latin_square = [el for l in balanced_latin_square(_elements_count) for el in [l,] * len(_filtered_order)]
@@ -205,7 +205,7 @@ def _process_init_final_block(participant_index:int, block_names: Union[list, di
     _filtered_block_names = block_names
     if isinstance(block_names, list):
         if not all([isinstance(n, str) for n in block_names]):
-            raise ExperimentServerConfigurationExcetion(f"All conditions in order were expected to be strings, got {block_names}")
+            raise ExperimentServerConfigurationException(f"All conditions in order were expected to be strings, got {block_names}")
 
     elif isinstance(block_names, dict):
         _filtered_block_names = _process_dict_orders(participant_index, block_names, blocks_strategy, var_name, strategy_enum)
@@ -218,15 +218,15 @@ def _process_dict_orders(participant_index:int, block_names: dict, blocks_strate
     """Helper to process dictionary patterns. See `construct_participant_condition` for more details."""
     block_names = {int(k):v for k, v in block_names.items()}
     if not all([isinstance(_order, list) for _order in block_names.values()]):
-        raise ExperimentServerConfigurationExcetion(f"Each group in {var_name} for all participants needs to be list, got {block_names}")
+        raise ExperimentServerConfigurationException(f"Each group in {var_name} for all participants needs to be list, got {block_names}")
     if not all([isinstance(val, str) for _order in block_names.values() for val in _order]):
-        raise ExperimentServerConfigurationExcetion(f"All conditions in {var_name} for all participants needs to be a strings, got {block_names}")
+        raise ExperimentServerConfigurationException(f"All conditions in {var_name} for all participants needs to be a strings, got {block_names}")
 
     if not all([idx+1 in block_names.keys() for idx in range(len(block_names))]):
-        raise ExperimentServerConfigurationExcetion(f"Keys order in {var_name} should match the consecutive indices starting from 1. Got keys {list(block_names.keys())}, expected keys {[idx + 1 for idx in list(range(len(block_names)))]}")
+        raise ExperimentServerConfigurationException(f"Keys order in {var_name} should match the consecutive indices starting from 1. Got keys {list(block_names.keys())}, expected keys {[idx + 1 for idx in list(range(len(block_names)))]}")
 
     if blocks_strategy != strategy_enum.as_is:
-        raise ExperimentServerConfigurationExcetion(f"Ordering strategy for {var_name} should be {strategy_enum.as_is} when {var_name} is a dictionary. Got {blocks_strategy}")
+        raise ExperimentServerConfigurationException(f"Ordering strategy for {var_name} should be {strategy_enum.as_is} when {var_name} is a dictionary. Got {blocks_strategy}")
     _key = ((participant_index - 1) % len(block_names)) + 1
     _filtered_block_names = block_names[_key]
 

{experiment_server-0.3.7 → experiment_server-0.3.8}/experiment_server/_process_config.py

@@ -1,14 +1,15 @@
 from pathlib import Path
 import random
 import warnings
-from typing import Any, Callable, Dict, List, Tuple, Union
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 from experiment_server._participant_ordering import construct_participant_condition, ORDERING_STRATEGY
-from experiment_server.utils import ExperimentServerConfigurationExcetion, ExperimentServerExcetion, merge_dicts
+from experiment_server.utils import ExperimentServerConfigurationException, ExperimentServerException, merge_dicts
 from loguru import logger
 from tabulate import tabulate
 import json
 import toml
+from traceback import format_exception_only
 
 
 TOP_LEVEL_RESERVED_KEYS = ["name", "config", "extends"]
@@ -16,7 +17,7 @@ SECTIONS = ["main_configuration", "init_configuration", "final_configuration", "
 ALLOWED_SETTINGS = ["randomize_within_groups", "randomize_groups"]
 
 
-def process_config_file(f: Union[str, Path], participant_index: int, supress_message:bool=False) -> List[Dict[str, Any]]:
+def process_config_file(f: Union[str, Path], participant_index: int, suppress_message:bool=False) -> List[Dict[str, Any]]:
     """
     Load and resolve an experiment configuration file for a single participant.
 
@@ -35,7 +36,7 @@ def process_config_file(f: Union[str, Path], participant_index: int, supress_mes
             This index is used where deterministic rotations (e.g. latin-square or per-participant
             assignment) are requested and is added to any configured random seed to provide
             reproducible per-participant randomness.
-        supress_message (bool, optional):
+        suppress_message (bool, optional):
             If False (default), a JSON summary of the resolved configuration for the participant
             is logged. If True, the info log is suppressed.
 
@@ -65,21 +66,24 @@ def process_config_file(f: Union[str, Path], participant_index: int, supress_mes
     See also `experiment_server._participant_ordering.construct_participant_condition`.
     """
     if participant_index < 1:
-        raise ExperimentServerConfigurationExcetion(f"Participant index needs to be greater than 0, got {participant_index}")
+        raise ExperimentServerConfigurationException(f"Participant index needs to be greater than 0, got {participant_index}")
 
     if Path(f).suffix == ".toml":
-        return _process_toml(f, participant_index, supress_message)
+        return _process_toml(f, participant_index, suppress_message)
     else:
-        raise ExperimentServerExcetion("Invalid file type. Expected `.toml`")
+        raise ExperimentServerException("Invalid file type. Expected `.toml`")
 
 
-def _process_toml(f: Union[str, Path], participant_index:int, supress_message:bool=False) -> List[Dict[str, Any]]:
+def _process_toml(f: Union[str, Path], participant_index:int, suppress_message:bool=False) -> List[Dict[str, Any]]:
     loaded_configuration = toml.load(f)
-    return _process_config(loaded_configuration, participant_index, supress_message)
+    return _process_config(loaded_configuration, participant_index, suppress_message)
 
 
-def _process_config(configuration: dict[Any, Any], participant_index:int, supress_message:bool=False) -> List[Dict[str, Any]]:
-    configurations = configuration.get("configuration", {})
+def _process_config(configuration: dict[Any, Any], participant_index:int, suppress_message:bool=False) -> List[Dict[str, Any]]:
+    try:
+        configurations = configuration["configuration"]
+    except KeyError:
+        raise ExperimentServerConfigurationException("Missing `configuration` section.")
     variables = configurations.get("variables", {})
 
     order_groups_strategy = ORDERING_STRATEGY.as_is
@@ -113,11 +117,19 @@ def _process_config(configuration: dict[Any, Any], participant_index:int, supres
     random.seed(random_seed + participant_index)
 
     all_blocks = _replace_variables(configuration["blocks"], variables)
-    assert isinstance(all_blocks, list)
+    if not isinstance(all_blocks, list):
+        raise ExperimentServerConfigurationException(f"`blocks` is not a list.")
 
-    order = configurations.get("order", [str(i) for i in list(range(len(all_blocks)))])
+    try:
+        order = configurations["order"]
+    except KeyError:
+        raise ExperimentServerConfigurationException(f"Missing `order` under `configuration`.")
 
     for c in all_blocks:
+        if "name" not in c:
+            raise ExperimentServerConfigurationException(f"One or more block(s) missing `name`.")
+        if "config" not in c and "extends" not in c:
+            raise ExperimentServerConfigurationException(f"One or more block(s) missing `config`.")
         c["name"] = str(c["name"])
 
     blocks = construct_participant_condition(all_blocks, participant_index, order=order,
@@ -142,7 +154,7 @@ def _process_config(configuration: dict[Any, Any], participant_index:int, supres
         c["config"]["name"] = c["name"]
         c["config"]["block_id"] = idx
     
-    if not supress_message:
+    if not suppress_message:
         logger.info("Configuration loaded: \n" + json.dumps(blocks, indent=2))
     return blocks
 
@@ -159,7 +171,7 @@ def _resolve_extends(c, configs, seen_configs):
     try:
         dict_b = [_c for _c in configs if _c["name"] == c["extends"]][0]
     except IndexError:
-        raise ExperimentServerConfigurationExcetion("`{}` is not a valid name. It must be a `name`.".format(c["extends"]))
+        raise ExperimentServerConfigurationException("`{}` is not a valid name. It must be a `name`.".format(c["extends"]))
 
     dict_b, configs, seen_configs = _resolve_extends(dict_b, configs, seen_configs + [dict_b["name"]])
     configs[dict_a["block_idx"]] = merge_dicts(dict_a, dict_b)
@@ -221,7 +233,7 @@ def _replace_variables(config: Union[Dict[str, Any], List[Any]], variabels: Dict
                 try:
                     resolved_config[k] = variabels[v[1:]]
                 except KeyError:
-                    raise ExperimentServerConfigurationExcetion(f"The variable `{v}` does not exsist in `configuration.variables`")
+                    raise ExperimentServerConfigurationException(f"The variable `{v}` does not exsist in `configuration.variables`")
             elif isinstance(v, dict):
                 resolved_config[k] = _replace_variables(v, variabels)
             else:
@@ -233,7 +245,7 @@ def _replace_variables(config: Union[Dict[str, Any], List[Any]], variabels: Dict
                 try:
                     resolved_config.append(variabels[v[1:]])
                 except KeyError:
-                    raise ExperimentServerConfigurationExcetion(f"The variable `{v}` does not exsist in `configuration.variables`")
+                    raise ExperimentServerConfigurationException(f"The variable `{v}` does not exsist in `configuration.variables`")
             elif isinstance(v, dict):
                 resolved_config.append(_replace_variables(v, variabels))
             else:
@@ -269,7 +281,7 @@ def _unpack_args(args) -> Tuple[list, dict]:
     elif isinstance(args, dict):
         kwargs = args
     else:
-        raise ExperimentServerConfigurationExcetion(f"`args` should be a list or a dict. Got {args}")
+        raise ExperimentServerConfigurationException(f"`args` should be a list or a dict. Got {args}")
     return largs, kwargs
 
 
@@ -287,7 +299,7 @@ def _resolve_function(function_name:str, args: Union[List,Dict], function_calls:
             function_call_group = function_calls[call_signature] = ChoicesFunction(args, params)
         return function_call_group(args, params)
     else:
-        raise ExperimentServerConfigurationExcetion(f"Unknown function {function_name}")
+        raise ExperimentServerConfigurationException(f"Unknown function {function_name}")
 
 
 class ChoicesFunction:
@@ -301,11 +313,11 @@ class ChoicesFunction:
         self.params = params
         if params is not None:
             if not isinstance(params, dict):
-                raise ExperimentServerConfigurationExcetion(f"`params` for `choices` should be a dict.")
+                raise ExperimentServerConfigurationException(f"`params` for `choices` should be a dict.")
             if len(params) not in (0, 1):
-                raise ExperimentServerConfigurationExcetion(f"Function `choices` expected 0 or 1 keys in params, got {len(params)}")
+                raise ExperimentServerConfigurationException(f"Function `choices` expected 0 or 1 keys in params, got {len(params)}")
             if len(params) == 1 and "unique" not in params:
-                raise ExperimentServerConfigurationExcetion(f"Unexpected key in `params` of `choices`. Allowed keys: [`unique`]")
+                raise ExperimentServerConfigurationException(f"Unexpected key in `params` of `choices`. Allowed keys: [`unique`]")
             if "unique" in params:
                 self.unique = params.get("unique")
         self.previous_choices = []
@@ -329,11 +341,11 @@ class ChoicesFunction:
 
             # Check if it is possible to get unique values.
             if len(self.previous_choices) != len(set(self.previous_choices)):
-                raise ExperimentServerConfigurationExcetion("There are more calls to `choices` than number of elements in `args`")
+                raise ExperimentServerConfigurationException("There are more calls to `choices` than number of elements in `args`")
         return choice
 
 
-def verify_config(f: Union[str, Path], test_func:Callable[[List[Dict[str, Any]]], Tuple[bool, str]]=None) -> bool:
+def verify_config(f: Union[str, Path], test_func:Optional[Callable[[List[Dict[str, Any]]], Tuple[bool, str]]]=None, raise_on_error:bool=False) -> Tuple[bool, Optional[str]]:
     """
     Verify an experiment TOML config by constructing participant orders for participants 1–5.
 
@@ -346,23 +358,33 @@ def verify_config(f: Union[str, Path], test_func:Callable[[List[Dict[str, Any]]]
         f: Path or filename of the TOML configuration file.
         test_func: Optional callable receiving the resolved blocks and returning
             a (bool, str) tuple indicating success and an optional reason.
+        raise_on_error: If True, will raise the exception that caused the verification to fail.
 
     Returns:
-        True if verification completed successfully for all checked participants.
+        Tuple (bool success, str reason):
+          `success` will be True if verification completed successfully for all checked
+          participants.  If verification failed, success will be false, and the reason will
+          be the message from the resulting exception.
     """
-    with logger.catch(reraise=False, message="Config verification failed"):
+    # with logger.catch(reraise=raise_on_error, message="Config verification failed"):
+
+    try:
         df = _get_table_for_participants(f, test_func)
         logger.info(f"Ordering for 5 participants: \n\n{tabulate(df, headers='firstrow', tablefmt='fancy_grid')}\n")
         logger.info(f"Config file verification successful for {f}")
-        return True
-    return False
+        return (True, None)
+    except Exception as e:
+        logger.exception(e)
+        if raise_on_error:
+            raise
+        return (False, "\n".join(format_exception_only(e)))
 
 
-def _get_table_for_participants(f: Union[str, Path], test_func:Callable[[List[Dict[str, Any]]], Tuple[bool, str]]=None) -> list[list[Any]]:
+def _get_table_for_participants(f: Union[str, Path], test_func:Optional[Callable[[List[Dict[str, Any]]], Tuple[bool, str]]]=None) -> list[list[Any]]:
     config_blocks: Dict[int, Dict[str, Any]] = {}
     # collect configs for participants 1..5 (same range as original)
     for participant_index in range(1, 6):
-        config = process_config_file(f, participant_index=participant_index)
+        config = process_config_file(f, participant_index=participant_index, suppress_message=True)
         config_blocks[participant_index] = {f"block_{idx + 1}": c["name"] for idx, c in enumerate(config)}
         if test_func is not None:
             test_result, reason = test_func(config)

{experiment_server-0.3.7 → experiment_server-0.3.8}/experiment_server/_server.py

@@ -12,7 +12,7 @@ import asyncio
 import json
 
 from experiment_server._api import Experiment
-from experiment_server.utils import ExperimentServerConfigurationExcetion, ExperimentServerExcetion
+from experiment_server.utils import ExperimentServerConfigurationException, ExperimentServerException
 
 
 def _create_app(experiment:Experiment):
@@ -397,9 +397,9 @@ class ExperimentHandler(RequestHandler):
                     if not added_participant:
                         self.set_status(406)
                     self.write(json.dumps(added_participant))
-                except ExperimentServerConfigurationExcetion as e:
+                except ExperimentServerConfigurationException as e:
                     self.set_status(406)
-                    self.write(e.args[0][0])
+                    self.write(e.message if e.message is not None else str(e.args))
 
     def _get_int_from_param(self, param):
         try: