adaptivetesting 1.1.5__tar.gz → 1.2b1__tar.gz

{adaptivetesting-1.1.5 → adaptivetesting-1.2b1}/PKG-INFO

@@ -1,28 +1,27 @@
 Metadata-Version: 2.4
 Name: adaptivetesting
-Version: 1.1.5
+Version: 1.2b1
 Summary: adaptivetesting is a Python package that can be used to simulate and evaluate custom CAT scenarios as well as implement them in real-world testing scenarios from a single codebase
+Author-email: Jonas Engicht <dev@condecon.de>
 Project-URL: Homepage, https://github.com/condecon/adaptivetesting
-Project-URL: Documentation, https://github.com/condecon/adaptivetesting/tree/main/docs
+Project-URL: Documentation, https://github.com/condecon/adaptivetesting/wiki
 Project-URL: Repository, https://github.com/condecon/adaptivetesting.git
 Project-URL: Issues, https://github.com/condecon/adaptivetesting/issues
-Author-email: Jonas Engicht <dev@condecon.de>
-License-File: LICENSE
-Keywords: computerized-adaptive-testing,item-response-theory,psychology,statistics
+Keywords: statistics,psychology,item-response-theory,computerized-adaptive-testing
 Requires-Python: >=3.12
-Requires-Dist: matplotlib>=3.9.0
-Requires-Dist: numpy>=2.0.0
-Requires-Dist: pandas>=2.2.0
-Requires-Dist: scipy>=1.12.0
-Requires-Dist: tqdm>=4.66.0
 Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.1.0
+Requires-Dist: pandas>=2.3.0
+Requires-Dist: scipy>=1.15.0
+Requires-Dist: tqdm>=4.66.0
+Requires-Dist: matplotlib>=3.10.0
+Requires-Dist: numdifftools>=0.9.42
+Dynamic: license-file
 
 # adaptivetesting
-[![SPEC 0 — Minimum Supported Dependencies](docs/source/_static/SPEC-0.svg)](https://scientific-python.org/specs/spec-0000/)
-
-
 
-<img src="/docs/source/_static/logo.svg" style="width: 100%">
+<img src="/docs/_static/logo.svg" style="width: 100%">
 </img>
 
 **An open-source Python package for simplified, customizable Computerized Adaptive Testing (CAT) using Bayesian methods.**
@@ -37,7 +36,7 @@ Description-Content-Type: text/markdown
   - Maximum Likelihood Estimation (MLE)
   - Bayesian Modal Estimation (BM)
   - Expected A Posteriori (EAP)
-- **Item Selection Strategies**: Kaximum information criterion and Urry's rule
+- **Item Selection Strategies**: Maximum information criterion and Urry's rule
 - **Simulation Framework**: Comprehensive tools for CAT simulation and evaluation
 - **Real-world Application**: Direct transition from simulation to production testing
 - **Stopping Criteria**: Support for standard error and test length criteria

{adaptivetesting-1.1.5 → adaptivetesting-1.2b1}/README.md

@@ -1,9 +1,6 @@
 # adaptivetesting
-[![SPEC 0 — Minimum Supported Dependencies](docs/source/_static/SPEC-0.svg)](https://scientific-python.org/specs/spec-0000/)
 
-
-
-<img src="/docs/source/_static/logo.svg" style="width: 100%">
+<img src="/docs/_static/logo.svg" style="width: 100%">
 </img>
 
 **An open-source Python package for simplified, customizable Computerized Adaptive Testing (CAT) using Bayesian methods.**
@@ -18,7 +15,7 @@
   - Maximum Likelihood Estimation (MLE)
   - Bayesian Modal Estimation (BM)
   - Expected A Posteriori (EAP)
-- **Item Selection Strategies**: Kaximum information criterion and Urry's rule
+- **Item Selection Strategies**: Maximum information criterion and Urry's rule
 - **Simulation Framework**: Comprehensive tools for CAT simulation and evaluation
 - **Real-world Application**: Direct transition from simulation to production testing
 - **Stopping Criteria**: Support for standard error and test length criteria

{adaptivetesting-1.1.5 → adaptivetesting-1.2b1}/adaptivetesting/__init__.py

@@ -12,18 +12,21 @@ from .data.__pickle_context import PickleContext
 from .implementations.__default_implementation import DefaultImplementation
 from .implementations.__pre_test import PreTest
 from .implementations.__semi_implementation import SemiAdaptiveImplementation
-from .implementations.__test_assembler import TestAssembler
+from .implementations.__test_assembler import TestAssembler, ContentBalancingArgs, ExposureControlArgs
 
 from .math.__gen_response_pattern import generate_response_pattern
 from .math.estimators.__ml_estimation import MLEstimator
 from .math.estimators.__bayes_modal_estimation import BayesModal
 from .math.estimators.__expect_a_posteriori import ExpectedAPosteriori
-from .math.estimators.__prior import Prior, NormalPrior, CustomPrior, CustomPriorException
+from .math.estimators.__prior import Prior, NormalPrior, CustomPrior, CustomPriorException, SkewNormalPrior, EmpiricalPrior
 from .math.estimators.__functions.__estimators import probability_y0, probability_y1, maximize_likelihood_function, likelihood
 from .math.estimators.__functions.__bayes import maximize_posterior
 from .math.estimators.__test_information import test_information_function, item_information_function, prior_information_function
 from .math.item_selection.__maximum_information_criterion import maximum_information_criterion
 from .math.item_selection.__urrys_rule import urrys_rule
+from .math.content_balancing.__weighted_penalty_model import WeightedPenaltyModel
+from .math.content_balancing.__constraint import *
+from .math.content_balancing.__functions import *
 
 from .models.__adaptive_test import AdaptiveTest
 from .models.__algorithm_exception import AlgorithmException

{adaptivetesting-1.1.5 → adaptivetesting-1.2b1}/adaptivetesting/data/__csv_context.py

@@ -3,7 +3,8 @@ import csv
 import pathlib
 from ..models.__test_result import TestResult
 from ..services.__test_results_interface import ITestResults
-from dataclasses import fields
+import json
+import ast
 
 
 class CSVContext(ITestResults):
@@ -47,22 +48,34 @@ class CSVContext(ITestResults):
             file.close()
 
     def load(self) -> List[TestResult]:
-        """Loads test results from a CSV file for a specific participant and simulation.
-        Reads the CSV file located at `data/{simulation_id}/{participant_id}.csv`,
-        parses each row into a `TestResult` object,
-        and returns a list of these objects.
-        
-        Returns:
-            List[TestResult]: A list of `TestResult` objects loaded from the CSV file.
+        """Loads results from the database.
+        The implementation of this method is required
+        by the interface. However, it does not have
+        any implemented functionality and will throw an error
+        if used.
+
+        Returns: List[TestResult]
         """
         foldername = f"data/{self.simulation_id}"
         
-        fieldnames = list(fields(TestResult))
         test_results: list[TestResult] = []
         with open(f"{foldername}/{self.participant_id}.csv", "r", encoding="utf-8") as file:
-            reader = csv.DictReader(file, fieldnames=fieldnames)
+            reader = csv.DictReader(file)
+            next(reader, None) # skip header row
             for row in reader:
                 test_result = TestResult.from_dict(row)
+                # showed_item is read as a string representation of a Python
+                # literal (e.g. a dict). Use ast.literal_eval to safely parse
+                # it back into a dict. Fallback to a JSON-style conversion
+                # if literal_eval fails.
+                try:
+                    test_result.showed_item = ast.literal_eval(str(test_result.showed_item))
+                except Exception:
+                    json_string = str(test_result.showed_item).replace("'", '"').replace("None", "null")
+                    try:
+                        test_result.showed_item = json.loads(json_string)
+                    except Exception:
+                        test_result.showed_item = {}
                 test_results.append(test_result)
             file.close()
         return test_results

adaptivetesting-1.2b1/adaptivetesting/data/__read_prev_items_exp_cont.py

@@ -0,0 +1,35 @@
+from typing import Literal
+from warnings import deprecated
+from ..models.__test_item import TestItem
+from ..models.__test_result import TestResult
+from .__csv_context import CSVContext
+from .__pickle_context import PickleContext
+
+
+def read_prev_items(format: Literal["CSV", "PICKLE"],
+                    test_id: str,
+                    participant_ids: list[str]) -> list[TestItem]:
+    """Read previously administered items
+    to perform exposure control
+    """
+    all_shown_test_items = []
+    
+    for part_id in participant_ids:
+        test_results = read_single_participant(test_id, part_id, format)
+        items = [TestItem.from_dict(res.showed_item) for res in test_results]
+        
+        all_shown_test_items += items
+
+    return all_shown_test_items
+
+
+@deprecated("This function should be replaced after merging"
+            " with revision branch")
+def read_single_participant(test_id: str, participant_id: str, format: Literal["CSV", "PICKLE"]) -> list[TestResult]:
+    context: CSVContext | PickleContext
+    if format == "CSV":
+        context = CSVContext(test_id, participant_id)
+        return context.load()
+    if format == "PICKLE":
+        context = PickleContext(test_id, participant_id)
+        return context.load()

{adaptivetesting-1.1.5 → adaptivetesting-1.2b1}/adaptivetesting/implementations/__pre_test.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, cast
 import numpy as np
 from ..models.__test_item import TestItem
 import random
@@ -10,6 +10,7 @@ class PreTest:
         The pretest class can be used to draw items randomly from
         difficulty quantiles
         of the item pool.
+        This pretest can only be used with dichotomous IRT models and items.
 
         Args:
             items: Item pool
@@ -18,15 +19,21 @@ class PreTest:
                 If not, the item selection will be drawn randomly, and you will not be able
                 to reproduce the results.
 
+        Raises:
+            ValueError: Raised if the items are specified for polytomous IRT models.
+
         """
         self.items = items
         self.seed = seed
 
+        if any([isinstance(item.b, list) for item in items]):
+            raise ValueError("The pretest can only be used with dichotomous IRT models and items.")
+
     def calculate_quantiles(self) -> np.ndarray:
         """Calculates quantiles 0.25, 0.5, 0.75
         """
         # get difficulties
-        difficulties: List[float] = [item.b for item in self.items]
+        difficulties: List[float] = [cast(float, item.b) for item in self.items]
 
         quantiles = np.array([])
         # calculate quantiles
@@ -50,7 +57,7 @@ class PreTest:
         """
         # select only items with difficulty in interval
         items_in_interval: List[TestItem] = [item for item in list(self.items)
-                                             if lower < item.b <= upper]
+                                             if lower < cast(float, item.b) <= upper]
         # draw one item randomly
         if self.seed is not None:
             random.seed(self.seed)

adaptivetesting-1.2b1/adaptivetesting/implementations/__test_assembler.py

@@ -0,0 +1,418 @@
+from ..models.__item_selection_exception import ItemSelectionException
+from ..math.content_balancing.__constraint import Constraint
+from ..models.__adaptive_test import AdaptiveTest
+from ..models.__test_item import TestItem
+from ..services.__estimator_interface import IEstimator
+from typing import Any, Type, TypedDict, Callable, Literal
+from ..math.item_selection.__maximum_information_criterion import maximum_information_criterion
+from ..models.__algorithm_exception import AlgorithmException
+from ..implementations.__pre_test import PreTest
+from ..models.__test_result import TestResult
+from ..models.__misc import ResultOutputFormat
+from ..services.__item_selection_protocol import ItemSelectionStrategy
+from ..math.content_balancing.__content_balancing import CONTENT_BALANCING
+from ..math.content_balancing.__weighted_penalty_model import WeightedPenaltyModel
+from ..math.content_balancing.__maximum_priority_index import MaximumPriorityIndex
+from ..math.estimators.__prior import Prior
+from ..math.exposure_control.__exposure_control import EXPOSURE_CONTROL
+from ..math.exposure_control.__randomesque import Randomesque
+from ..math.exposure_control.__mpi_exposure_control import MaximumPriorityIndexExposureControl
+import inspect
+
+
+class EstimatorArgs(TypedDict):
+    prior: Prior | None
+    optimization_interval: tuple[float, float]
+    model: Literal["GRM", "GPCM"] | None
+
+
+class ContentBalancingArgs(TypedDict):
+    constraints: list[Constraint] | None
+    """constraints that are applied to the item selection"""
+    constraint_weight: float | Callable[[AdaptiveTest], float] | None
+    """weight of the constraints
+    This can also be a function taking adaptive test as an input argument.
+    This allows the user to specify custom weight values depending
+    on the specific states and progress of the test."""
+    information_weight: float | Callable[[AdaptiveTest], float] | None
+    """weight of the item information
+    This can also be a function taking adaptive test as an input argument.
+    This allows the user to specify custom weight values depending
+    on the specific states and progress of the test."""
+
+
+class ExposureControlArgs(TypedDict):
+    constraints: list[Constraint] | None
+    """Constraints applied for Maximum Priority Index exposure control."""
+    participant_ids: list[str] | None
+    """Participant ids to read the previously administered test in order to
+    perform exposure control (MPI only).
+    """
+    output_format: ResultOutputFormat | None
+    """Format in which the previous tests have been saved (MPI only)."""
+    n_items: int | None
+    """number of items to select for Randomesque items selection"""
+    seed: int | None
+    """random seed for the final item selection during Randomesque item selection"""
+
+
+class TestAssembler(AdaptiveTest):
+    """
+    TestAssembler is a subclass of AdaptiveTest designed to assemble and administer adaptive tests,
+    optionally including a pretest phase. It supports customizable ability estimation and item selection strategies.
+
+    Methods:
+        estimate_ability_level():
+            Estimates the current ability level using the specified estimator and handles exceptions
+            for specific response patterns (all correct or all incorrect).
+
+        get_next_item() -> TestItem:
+            Selects the next item to administer using the specified item selection strategy.
+
+        run_test_once():
+            Runs a single iteration of the test, including an optional pretest phase. Handles item
+            administration, response collection, ability estimation, and result recording.
+
+    Attributes:
+        __ability_estimator: The estimator class for ability estimation.
+
+        __estimator_args: Arguments for the ability estimator.
+
+        __item_selector: The item selection strategy.
+
+        __item_selector_args: Arguments for the item selector.
+
+        __pretest: Whether to run a pretest phase.
+
+        __pretest_seed: Random seed for pretest item selection.
+    """
+
+    def __init__(self,
+                 item_pool,
+                 simulation_id,
+                 participant_id,
+                 ability_estimator: Type[IEstimator],
+                 estimator_args: EstimatorArgs = {
+                     "prior": None,
+                     "optimization_interval": (-10, 10),
+                     "model": None
+                 },
+                 item_selector: ItemSelectionStrategy = maximum_information_criterion, # type: ignore
+                 item_selector_args: dict[str, Any] = {},
+                 model_type: Literal["GRM", "GPCM"] | None = None,
+                 content_balancing: None | CONTENT_BALANCING = None,
+                 content_balancing_args: ContentBalancingArgs | None = None,
+                 exposure_control: None | EXPOSURE_CONTROL = None,
+                 exposure_control_args: None | ExposureControlArgs = None,
+                 pretest: bool = False,
+                 pretest_seed: int | None = None,
+                 true_ability_level=None,
+                 initial_ability_level=0,
+                 simulation=True,
+                 debug=False,
+                 **kwargs):
+        """
+        Args:
+
+            item_pool: The pool of test items available for selection.
+
+            simulation_id: Identifier for the simulation run.
+
+            participant_id: Identifier for the participant.
+
+            ability_estimator (Type[IEstimator]): The estimator class used for ability estimation.
+
+            estimator_args (EstimatorArgs, optional):
+                Arguments for the ability estimator. Defaults to {"prior": None, "optimization_interval": (-10, 10)}.
+
+            item_selector (ItemSelectionStrategy, optional):
+                Function or strategy for selecting the next item. Defaults to maximum_information_criterion.
+
+            item_selector_args (dict[str, Any], optional): Arguments for the item selector. Defaults to {}.
+
+            content_balancing (CONTENT_BALANCING, optional): Selected content balancing strategy. Defaults to None.
+                If a content balancing strategy is specified, the item selection strategy will be ignored.
+
+            pretest (bool, optional): Whether to run a pretest phase before the main test. Defaults to False.
+
+            pretest_seed (int | None, optional): Random seed for pretest item selection. Defaults to None.
+
+            true_ability_level (optional): The true ability level of the participant (for simulation).
+
+            initial_ability_level (optional): The initial ability estimate. Defaults to 0.
+
+            simulation (bool, optional): Whether the test is run in simulation mode. Defaults to True.
+
+            debug (bool, optional): Whether to enable debug output. Defaults to False.
+
+            **kwargs: Additional keyword arguments passed to the AdaptiveTest superclass.
+        """
+        self.__ability_estimator = ability_estimator
+        self.__estimator_args = estimator_args
+        self.__item_selector = item_selector
+        self.__item_selector_args = item_selector_args
+        self.content_balancing = content_balancing
+        self.content_balancing_args = content_balancing_args
+        self.exposure_control = exposure_control
+        self.exposure_control_args = exposure_control_args
+        self.__pretest = pretest
+        self.__pretest_seed = pretest_seed
+        self.__estimator_args["model"] = model_type
+
+        super().__init__(item_pool,
+                         simulation_id,
+                         participant_id,
+                         true_ability_level,
+                         initial_ability_level,
+                         simulation,
+                         debug,
+                         **kwargs)
+
+    def estimate_ability_level(self):
+        """
+        Estimates the ability level of a test-taker based on their response pattern and answered items.
+        This method uses the configured ability estimator to calculate the ability estimation and its standard error.
+        If an AlgorithmException occurs during estimation,
+        and all responses are identical (all correct or all incorrect),
+        it assigns a default estimation value (-10 for all incorrect, 10 for all correct)
+        and recalculates the standard error.
+        Otherwise, it raises an AlgorithmException with additional context.
+
+        Returns:
+            tuple[float, float]: A tuple containing the estimated ability level (float) and its standard error (float).
+
+        Raises:
+            AlgorithmException: If estimation fails for reasons other than all responses being identical.
+        """
+        # filter estimator args
+        sig = inspect.signature(self.__ability_estimator)
+        allowed = set(sig.parameters.keys())
+        filtered_estimator_args = {k: v for k, v in self.__estimator_args.items() if k in allowed}
+
+        # setup estimator
+        estimator = self.__ability_estimator(
+            self.response_pattern,
+            self.answered_items,
+            **filtered_estimator_args # type: ignore
+        )
+
+        try:
+            estimation = estimator.get_estimation()
+            standard_error = estimator.get_standard_error(estimation)
+        except AlgorithmException as exception:
+            # check if all responses are the same
+            if len(set(self.response_pattern)) == 1:
+                if self.response_pattern[0] == 0:
+                    estimation = -10
+                elif self.response_pattern[0] == 1:
+                    estimation = 10
+                standard_error = estimator.get_standard_error(estimation)
+
+            else:
+                raise AlgorithmException(f"""Something
+                when wrong when running {type(estimator)}""") from exception
+
+        return estimation, standard_error
+
+    def get_next_item(self) -> TestItem:
+        """
+        Selects and returns the next test item based on the current ability level and item selector strategy.
+        If a content balancing strategy is specified, the item selection strategy will be ignored.
+        Instead, the item selected by the content balancing strategy will be returned.
+        This also applies to exposure control.
+        However, content balancing and exposure control cannot be specified at the same time
+
+        Returns:
+            TestItem: The next item to be administered in the test, as determined by the item selector.
+
+        Raises:
+            Any exceptions raised by the item selector function.
+        """
+        item: TestItem | None
+        if self.content_balancing is None and self.exposure_control_args is None:
+            # content balancing an exposure control are not specified
+            # filter item selection args
+            sig = inspect.signature(self.__item_selector)
+            allowed = set(sig.parameters.keys())
+            filtered_item_selector_args = {k: v for k, v in self.__item_selector_args.items() if k in allowed}
+
+            item = self.__item_selector(
+                self.item_pool.test_items,
+                self.ability_level,
+                **filtered_item_selector_args
+            )
+            return item
+        elif self.content_balancing and self.exposure_control:
+            raise ValueError("Content balancing and exposure cannot be specified at the same time!")
+        # content balancing only
+        elif self.content_balancing and self.exposure_control is None:
+            if self.content_balancing_args is not None:
+                # which strategy has been selected
+                if self.content_balancing == "WeightedPenaltyModel":
+                    # parse content balancing args
+
+                    # setup wep
+                    adaptive_test = self
+                    wep = WeightedPenaltyModel(
+                        adaptive_test,
+                        constraints=self.check_args_are_not_none(
+                            "constraints",
+                            self.content_balancing_args["constraints"]),
+                        constraint_weight=self.check_args_are_not_none(
+                            "constraint_weights",
+                            self.content_balancing_args["constraint_weight"]),
+                        information_weight=self.check_args_are_not_none(
+                            "information_weight",
+                            self.content_balancing_args["information_weight"]))
+
+                    item = wep.select_item()
+                    if item is None:
+                        raise ItemSelectionException(
+                            f"""Something went wrong when selecting an item using {self.content_balancing}""")
+                    else:
+                        return item
+                elif self.content_balancing == "MaximumPriorityIndex":
+                    adaptive_test = self
+                    mpi = MaximumPriorityIndex(
+                        adaptive_test,
+                        constraints=self.check_args_are_not_none(
+                            "constraints",
+                            self.content_balancing_args["constraints"]))
+
+                    item = mpi.select_item()
+
+                    if item is None:
+                        raise ItemSelectionException(
+                            f"""Something went wrong when selecting an item using {self.content_balancing}""")
+                    else:
+                        return item
+            else:
+                raise ValueError("content_balancing_args cannot be None when using content balancing.")
+        # exposure control only
+        elif self.content_balancing is None and self.exposure_control:
+            if self.exposure_control_args is None:
+                raise ValueError("exposure_control_args cannot be None when using exposure control.")
+            # which strategy has been selected
+            if self.exposure_control == "Randomesque":
+                # Randomesque
+                adaptive_test = self
+                dict_keys = list(self.exposure_control_args.keys())
+                if "seed" not in dict_keys or "n_items" not in dict_keys:
+                    raise ValueError("exposure_control_args are not correctly specified")
+                
+                if self.exposure_control_args["n_items"] is not None:
+                    randomesque = Randomesque(
+                        adaptive_test=adaptive_test,
+                        n_items=self.exposure_control_args["n_items"],
+                        seed=self.exposure_control_args["seed"]
+                    )
+                    return randomesque.select_item()
+                else:
+                    raise ValueError("n_items cannot be None.")
+                
+            if self.exposure_control == "MaximumPriorityIndex":
+                if (self.exposure_control_args["participant_ids"]
+                   is None or self.exposure_control_args["output_format"] is None):
+                    raise ValueError("exposure_control_args are not correctly specified")
+                mpi = MaximumPriorityIndexExposureControl(
+                    self,
+                    constraints=self.exposure_control_args["constraints"],
+                    participant_ids=self.exposure_control_args["participant_ids"],
+                    format=self.exposure_control_args["output_format"]
+                )
+
+                selected_item = mpi.select_item()
+                if selected_item is None:
+                    raise ItemSelectionException("Fatal! Not appropriated item was "
+                                                 "selected using MPI for exposure control")
+                else:
+                    return selected_item
+        raise ValueError(f"Something went wrong when selecting an item using {self.content_balancing}.")
+
+    def run_test_once(self):
+        """
+        Executes a single run of the test, including optional pretest logic.
+        If pretesting is enabled, this method:
+            - Selects a random quantile of items from the item pool using a PreTest instance.
+            - For each selected item:
+                - Obtains a response (either simulated or real).
+                - Appends the response and item to the respective lists.
+                - Removes the item from the item pool.
+            - Estimates the ability level and standard error after pretest responses.
+            - Records test results for each pretest item, with the final item including the first ability estimation.
+
+        Returns:
+            The result of the superclass's run_test_once() method.
+        """
+        # check if to run pretest
+        if self.__pretest is True:
+            pretest = PreTest(
+                self.item_pool.test_items,
+                self.__pretest_seed
+            )
+            # get selected items
+            random_items = pretest.select_random_item_quantile()
+            for item in random_items:
+                if self.simulation is True:
+                    response = self.item_pool.get_item_response(item)
+                else:
+                    # not simulation
+                    response = self.get_response(item)
+
+                if self.DEBUG:
+                    print(f"Response: {response}")
+                # add response to response pattern
+                self.response_pattern.append(response)
+                # add item to answered items list
+                self.answered_items.append(item)
+
+                # remove items
+                self.item_pool.delete_item(item)
+            # estimate ability level
+            estimation, sd_error = self.estimate_ability_level()
+            self.ability_level = estimation
+            self.standard_error = sd_error
+            # create test results for all n-1 random items
+            for i in range(0, len(random_items) - 1):
+                result = TestResult(
+                    ability_estimation=float("nan"),
+                    standard_error=float("nan"),
+                    showed_item=random_items[i].as_dict(),
+                    response=self.response_pattern[i],
+                    test_id=self.simulation_id,
+                    true_ability_level=self.true_ability_level if self.true_ability_level is not None else float("NaN"),
+                )
+                # append to memory
+                self.test_results.append(result)
+
+            # create test result for first ability estimation
+            intermediate_result = TestResult(
+                ability_estimation=self.ability_level,
+                standard_error=self.standard_error,
+                showed_item=random_items[-1].as_dict(),
+                response=self.response_pattern[-1],
+                test_id=self.simulation_id,
+                true_ability_level=self.true_ability_level if self.true_ability_level is not None else float("NaN"),
+            )
+            self.test_results.append(intermediate_result)
+
+        return super().run_test_once()
+
+    def check_args_are_not_none(self, key: str, x: Any | None) -> Any:
+        """This functions checks if an object is none.
+        If not a ValueError is raised.
+
+        Args:
+            key (str): parameter name where the object is typically assigned
+            x (Any | None): object
+
+        Raises:
+            ValueError: raised if the object is None.
+
+        Returns:
+            Any: object
+        """
+        if x is not None:
+            return x
+        else:
+            raise ValueError(f"{key} cannot be None.")