adaptivetesting 1.0.0__py3-none-any.whl

adaptivetesting/tests/test_adaptive_test.py

@@ -0,0 +1,67 @@
+import unittest
+from adaptivetesting.models import AdaptiveTest, TestItem, ItemPool
+
+item1 = TestItem()
+item1.b = 0.24
+item1.id = 1
+item2 = TestItem()
+item2.b = 0.89
+item2.id = 2
+item3 = TestItem()
+item3.b = -0.6
+item3.id = 3
+
+items = [item1, item2, item3]
+simulated_responses = [1, 0, 1]
+
+item_pool = ItemPool(
+    test_items=items.copy(),
+    simulated_responses=simulated_responses.copy()
+)
+
+
+class TestAdaptiveTest(unittest.TestCase, AdaptiveTest):
+    def __init__(self, methodName='runTest'):
+        AdaptiveTest.__init__(
+            self,
+            item_pool=item_pool,
+            simulation_id="1",
+            true_ability_level=0,
+            participant_id=0
+        )
+        unittest.TestCase.__init__(self, methodName)
+
+    def estimate_ability_level(self) -> float:
+        return 0
+
+    def test_get_difficulties(self):
+        difficulties = self.get_item_difficulties()
+        self.assertEqual(difficulties, [0.24, 0.89, -0.6])
+
+    def test_standard_error(self):
+        """This should calculate a standard error without failing"""
+        self.answered_items = [item1, item2]
+        error = self.get_ability_se()
+
+    def test_get_next_item(self):
+        next_item = self.get_next_item()
+        self.assertEqual(next_item, item1)
+
+    def test_testing_procedure_once(self):
+        self.run_test_once()
+        # test showed item
+        self.assertEqual(self.test_results[0].showed_item,
+                         item1.b)
+
+        # print(self.test_results)
+        # print(simulated_responses)
+        # test response
+        self.assertEqual(
+            self.test_results[0].response,
+            simulated_responses[0]
+        )
+
+        # test item is removed from pool
+        # print(self.item_pool.test_items)
+        self.assertEqual(self.item_pool.test_items, [item2, item3])
+

adaptivetesting/tests/test_bayes_modal.py

@@ -0,0 +1,31 @@
+import unittest
+from adaptivetesting.models import ItemPool, TestItem
+from adaptivetesting.math.estimators import BayesModal, NormalPrior
+import pandas as pd
+
+class TestBayesModal(unittest.TestCase):
+    def __init__(self, methodName = "runTest"):
+        super().__init__(methodName)
+
+    def test_estimation_4pl(self):
+        items = pd.DataFrame({
+            "a": [1.32, 1.07, 0.84],
+            "b": [-0.63, 0.18, -0.84],
+            "c": [0.17, 0.10, 0.19],
+            "d": [0.87, 0.93, 1]
+        })
+        item_pool =  ItemPool.load_from_dataframe(items)
+
+        response_pattern = [0,1,0]
+        estimator = BayesModal(
+            response_pattern=response_pattern,
+            items=item_pool.test_items,
+            prior=NormalPrior(0, 1),
+            optimization_interval=(-4, 4)
+        )
+
+        result = estimator.get_estimation()
+
+        self.assertAlmostEqual(result, -0.4741753, 4)
+
+    

adaptivetesting/tests/test_code_examples.py

@@ -0,0 +1,22 @@
+import unittest
+
+class TestCodeExamples(unittest.TestCase):
+    def __init__(self, methodName = "runTest"):
+        super().__init__(methodName)
+
+    def test_default_example(self):
+        # read file
+        with open("code_examples/example_default.py", "r") as file:
+            content = file.read()
+            file.close()
+
+        exec(content)
+
+    def test_semi_adaptive_example(self):
+        # read file
+        with open("code_examples/example_semi.py", "r") as file:
+            content = file.read()
+            file.close()
+
+        exec(content)
+    

adaptivetesting/tests/test_information_test.py

@@ -0,0 +1,38 @@
+import unittest
+from adaptivetesting.math import test_information_function
+import jax.numpy as np
+import pandas as pd
+import math
+
+class TestInformation(unittest.TestCase):
+    def test_information_calculation_1pl(self):
+        difficulties = np.array([0.7, 0.9, 0.6])
+        ability = np.array([0], dtype="float32")
+
+        result = test_information_function(
+            mu=ability,
+            a=np.array(1),
+            b=difficulties,
+            c=np.array(1),
+            d=np.array(0),
+        )
+
+        self.assertAlmostEqual(result, 0.6559974211, 3)
+
+    def test_information_calculation_4pl(self):
+        items = pd.DataFrame({
+            "a": [1.32, 1.07, 0.84],
+            "b": [-0.63, 0.18, -0.84],
+            "c": [0.17, 0.10, 0.19],
+            "d": [0.87, 0.93, 1]
+        })
+
+        result = test_information_function(np.array(0),
+                                           np.array(items.a.to_numpy()),
+                                           np.array(items.b.to_numpy()),
+                                           np.array(items.c.to_numpy()),
+                                           np.array(items.d.to_numpy()))
+        # convert test information into standard error
+        result = 1 / math.sqrt(result)
+
+        self.assertAlmostEqual(result, 1.444873, 3)

adaptivetesting/tests/test_load_test_items.py

@@ -0,0 +1,112 @@
+from unittest import TestCase
+from adaptivetesting.models import TestItem, ItemPool
+import pandas as pd
+
+class TestLoadTestItems(TestCase):
+    def __init__(self, methodName = "runTest"):
+        super().__init__(methodName)
+        self.item1 = TestItem()
+        self.item1.a = 0.9
+        self.item1.b = 5
+        self.item1.c = 0.9
+
+        self.item2 = TestItem()
+        self.item2.a = 1.9
+        self.item2.b = 3
+        self.item2.c = 1.9
+# List
+
+
+# Dict
+    def test_load_test_items_from_dict_success(self):
+        source_dictionary: dict[str, list[float]] = {
+            "a": [0.9, 1.9],
+            "b": [5, 3],
+            "c": [0.9, 1.9],
+            "d": [1, 1]
+        }
+
+        generated = ItemPool.load_from_dict(source_dictionary)
+
+        self.assertEqual([self.item1.as_dict(), self.item2.as_dict()], [i.as_dict() for i in generated.test_items])
+
+    def test_load_test_items_from_dict_error_none(self):
+        source_dictionary: dict[str, list[float]] = {
+            "a": [0.9, 1.9],
+            "b": [5, 3],
+            "c": [0.9, 1.9],
+        }
+
+        with self.assertRaises(ValueError):
+            ItemPool.load_from_dict(source_dictionary)
+
+    def test_load_test_items_from_dict_error_length(self):
+        source_dictionary: dict[str, list[float]] = {
+            "a": [0.9, 1.9],
+            "b": [5, 3],
+            "c": [0.9, 1.9],
+            "d": [1]
+        }
+
+        with self.assertRaises(ValueError):
+            ItemPool.load_from_dict(source_dictionary)
+
+# Pandas DataFrame
+    def test_load_items_from_pandas_success(self):
+        dictionary = {
+            "a": [0.9, 1.9],
+            "b": [5, 3],
+            "c": [0.9, 1.9],
+            "d": [1, 1],
+            "simulated_responses": [1, 0]
+        }
+        df = pd.DataFrame(dictionary)
+
+        generated = ItemPool.load_from_dataframe(df)
+
+        # check that items are equal
+        self.assertEqual(
+            {
+                "a": 0.9,
+                "b": 5,
+                "c": 0.9,
+                "d": 1
+            },
+            generated.test_items[0].as_dict()
+        )
+
+        self.assertEqual(
+            {
+                "a": 1.9,
+                "b": 3,
+                "c": 1.9,
+                "d": 1
+            },
+            generated.test_items[1].as_dict()
+        )
+
+        self.assertEqual([1, 0], generated.simulated_responses)
+        
+    def test_load_items_pandas_error_missing_column(self):
+        dictionary = {
+            "a": [0.9, 1.9],
+            "b": [5, 3],
+            "c": [0.9, 1.9]
+        }
+        df = pd.DataFrame(dictionary)
+
+        with self.assertRaises(ValueError):
+            ItemPool.load_from_dataframe(df)
+
+    def test_load_pandas_no_responses(self):
+        dictionary = {
+            "a": [0.9, 1.9],
+            "b": [5, 3],
+            "c": [0.9, 1.9],
+            "d": [1, 1]
+        }
+        df = pd.DataFrame(dictionary)
+
+        generated = ItemPool.load_from_dataframe(df)
+
+        self.assertIsNone(generated.simulated_responses)

adaptivetesting/tests/test_mle.py

@@ -0,0 +1,73 @@
+import unittest
+from adaptivetesting.math.estimators import MLEstimator
+from adaptivetesting.models import AlgorithmException, ItemPool
+import pandas as pd
+
+class TestMLE(unittest.TestCase):
+
+    def test_ml_estimation(self):
+        response_pattern = [0, 1, 0]
+        difficulties = [0.7, 0.9, 0.6]
+
+        items = ItemPool.load_from_list(b=difficulties).test_items
+
+        estimator: MLEstimator = MLEstimator(
+            response_pattern,
+            items
+        )
+
+        result = estimator.get_estimation()
+
+        self.assertAlmostEqual(result, 0.0375530712, 2)
+
+    def test_one_item(self):
+        response = [0]
+        dif = [0.9]
+        ability = 0
+
+        items = ItemPool.load_from_list(dif).test_items
+
+        estimator = MLEstimator(response, items)
+
+        with self.assertRaises(AlgorithmException):
+            result = estimator.get_estimation()
+            print(f"Estimation Result {result}")
+
+    def test_eid(self):
+        response_pattern = [1, 0]
+        difficulties = [-1.603, 0.909]
+
+        items = ItemPool.load_from_list(difficulties).test_items
+
+        estimator = MLEstimator(response_pattern, items)
+
+        result = estimator.get_estimation()
+
+        self.assertAlmostEqual(round(result, 3), -0.347, places=5)
+
+    def test_catr_item_1_2(self):
+        response_pattern = [1, 0]
+        difficulties = [-2.1851, -0.2897194]
+
+        items = ItemPool.load_from_list(difficulties).test_items
+        estimator = MLEstimator(response_pattern, items)
+
+        result = estimator.get_estimation()
+
+        self.assertAlmostEqual(result, -1.237413, 3)
+
+    def test_4_pl_model(self):
+        items = pd.DataFrame({
+            "a": [1.32, 1.07, 0.84],
+            "b": [-0.63, 0.18, -0.84],
+            "c": [0.17, 0.10, 0.19],
+            "d": [0.87, 0.93, 1]
+        })
+        item_pool =  ItemPool.load_from_dataframe(items)
+
+        response_pattern = [0,1,0]
+        estimator = MLEstimator(response_pattern, item_pool.test_items)
+
+        result = estimator.get_estimation()
+
+        self.assertAlmostEqual(result, -1.793097, places=2)

adaptivetesting/tests/test_pretest.py

@@ -0,0 +1,39 @@
+import unittest
+from adaptivetesting.implementations import PreTest
+from adaptivetesting.models import TestItem
+import jax.numpy as np
+
+item0 = TestItem()
+item0.b = 0
+
+item1 = TestItem()
+item1.b = 0.2
+
+item2 = TestItem()
+item2.b = 0.4
+
+item3 = TestItem()
+item3.b = 0.6
+
+item4 = TestItem()
+item4.b = 0.8
+
+items = [item0, item1, item2, item3, item4]
+
+test = PreTest(
+    items=items
+)
+# a seed is not set because
+# the random selection should only allow one solution
+
+
+class TestPreTest(unittest.TestCase):
+    def test_quantile_calculation(self):
+        quantiles: np.ndarray = test.calculate_quantiles()
+        quantiles = quantiles.round(decimals=1)
+        self.assertListEqual(list(quantiles), [0.2, 0.4, 0.6])
+    
+    def test_selection_random_item_quantile(self):
+        selected_items = test.select_random_item_quantile()
+        self.assertListEqual(selected_items,
+                             [item1, item2, item3, item4])

adaptivetesting/tests/test_standard_error.py

@@ -0,0 +1,57 @@
+import unittest
+from typing import List
+from adaptivetesting.math import standard_error
+from adaptivetesting.models import ItemPool, TestItem
+import pandas as pd
+
+class TestStandardError(unittest.TestCase):
+    def test_dummy_items(self):
+        items = [0.7, 0.9, 0.6]
+        ability = 0
+
+        item_list: List[TestItem] = ItemPool.load_from_list(items).test_items
+
+        result = standard_error(item_list, ability)
+
+        self.assertAlmostEqual(result, 1.234664423, 3)
+
+    def test_eid_items(self):
+        items = [-1.603, 0.909]
+        ability = -0.347
+
+        item_list = ItemPool.load_from_list(items).test_items
+
+        result = standard_error(item_list, ability)
+
+        self.assertAlmostEqual(result, 1.702372, 3)
+
+    def test_calculation_4pl(self):
+        items = pd.DataFrame({
+            "a": [1.32, 1.07, 0.84],
+            "b": [-0.63, 0.18, -0.84],
+            "c": [0.17, 0.10, 0.19],
+            "d": [0.87, 0.93, 1]
+        })
+
+        item_pool = ItemPool.load_from_dataframe(items)
+
+        result = standard_error(item_pool.test_items, 0)
+
+        self.assertAlmostEqual(result, 1.444873, 3)
+
+    def test_calculation_bm(self):
+        items = pd.DataFrame({
+            "a": [1.32, 1.07, 0.84],
+            "b": [-0.63, 0.18, -0.84],
+            "c": [0.17, 0.10, 0.19],
+            "d": [0.87, 0.93, 1]
+        })
+
+        item_pool = ItemPool.load_from_dataframe(items)
+
+        result = standard_error(item_pool.test_items,
+                                0,
+                                estimator="BM",
+                                sd=1)
+
+        self.assertAlmostEqual(result, 0.8222712, 3)

adaptivetesting/tests/test_urrys_rule.py

@@ -0,0 +1,28 @@
+import unittest
+from adaptivetesting.math.item_selection import urrys_rule
+from adaptivetesting.models import TestItem
+
+
+class TestUrrysRule(unittest.TestCase):
+    item1 = TestItem()
+    item1.b = 0.24
+    item1.id = 1
+
+    item2 = TestItem()
+    item2.b = 0.89
+    item2.id = 2
+
+    item3 = TestItem()
+    item3.b = -0.6
+    item3.id = 3
+
+    items = [item1, item2, item3]
+
+    def test_selection_when_0(self):
+        ability_level = 0
+
+        self.assertEqual(urrys_rule(self.items, ability_level).id, 1)
+
+    def test_selection_when_minus_0_5(self):
+        ability_level = -0.5
+        self.assertEqual(urrys_rule(self.items, ability_level).id, 3)

adaptivetesting-1.0.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: adaptivetesting
+Version: 1.0.0
+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
+Home-page: https://github.com/condecon/adaptivetesting
+Author: Jonas Engicht
+Author-email: jonas.engicht@uni-jena.de
+Maintainer: Jonas Engicht
+Maintainer-email: jonas.engicht@uni-jena.de
+License: Mozilla Public License Version 2.0
+Keywords: statistics,psychology,item-response-theory,computerized-adaptive-testing
+Requires-Python: >3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jax>=0.5.1
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: scipy>=1.15.0
+Requires-Dist: pandas>=2.2.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: maintainer
+Dynamic: maintainer-email
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# adaptivetesting
+[![Unittests](https://github.com/condecon/adaptivetesting/actions/workflows/python-test.yml/badge.svg)](https://github.com/condecon/adaptivetesting/actions/workflows/python-test.yml)
+[![Deploy to PyPi](https://github.com/condecon/adaptivetesting/actions/workflows/publish.yml/badge.svg)](https://github.com/condecon/adaptivetesting/actions/workflows/publish.yml)
+
+<img src="/docs/source/_static/logo.svg" style="width: 100%">
+</img>
+
+_adaptivetesting_ is a Python package for computerized adaptive 
+testing that can be used to simulate and implement custom adaptive tests 
+in real-world testing scenarios.
+
+## Getting Started
+
+Required Python version: >= 3.11 (other versions may work, but they are not officially supported)
+
+``
+pip install adaptivetesting
+``
+
+If you want to install the current development version,
+you can do so by running the following command:
+
+``
+pip install git+https://github.com/condecon/adaptivetesting
+``
+
+## Features
+- IRT-Models: 
+    - 4PL
+    - simplified derivates (e.g., 3PL, Rasch model)
+- Ability estimators: 
+    - Maximum Likelihood Estimation
+    - Bayes Modal
+- Item selection algorithm: 
+    - Urry’s rule
+- Stopping criteria: 
+    - test length
+    - ability estimation standard error
+- Test results output formats
+    - SQLITE
+    - Pickle
+- Functions and wrappers for CAT simulations and application implementations
+
+__Any functionality can be modified and extended.__
+
+
+## Implementations
+The package comes with two CAT implementations that are ready to use.
+### Default implementation
+
+![Schematic overview of the Default implementation](/images/default.svg)
+
+### Semi-Adaptive implementation
+![Schematic overview of the Semi-Adaptive implementation](/images/semi-adaptive.svg)
+
+### Custom testing procedures
+Custom testing procedures can be implemented by implementing
+the abstract class ``AdaptiveTest``.
+Any existing functionality can be overridden while still
+retaining full compatibility with the packages' functionality.
+For more information, please consult the documentation for the ``AdaptiveTest`` class.
+
+## Package structure
+| submodule | description |
+|------------|-------------|
+| data | data management and processing of test results |
+| implementations | concrete implementations of the adaptive process, provides actual |
+| math | mathematical utilities and functions, such as estimators, item selection, test information |
+| models | data model definitions and structures used in the package |
+| services | interfaces that concrete implementations inherit from |
+| simulations | functions and classes used in CAT simulation |
+| tests | Unit test for the entire package |
+
+## Documentation
+Extensive documentation is available in the source code,
+but it can also be compiled to a webpage using sphinx.

adaptivetesting-1.0.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+adaptivetesting/__init__.py,sha256=kPaeNHwRmZWn3Fs7GfbHy5fRiyHLsssdfhuT-niAgww,156
+adaptivetesting/data/__init__.py,sha256=Cix5L1BaXQmKFuWpYOVeseQXOxNa5tVyVYsAoLiu2TA,88
+adaptivetesting/data/__pickle_context.py,sha256=ZBOmOhUs8DmfRe3aeFLdU1iC1hR70x-Z5M8Lsw_rgCg,1800
+adaptivetesting/data/__sqlite_context.py,sha256=9bKy6PEdcX9buGV17nyFJWNZvL8KMUNf9NnIBJrpNC0,2561
+adaptivetesting/implementations/__default_implementation.py,sha256=FRvHPezfnD3ef1gWvthCCNly4aEYbx7WaVYNp8gkDuc,2477
+adaptivetesting/implementations/__init__.py,sha256=9VEeChzufY-tpV0A0aRruhyxKIPpo--W3C5nxE8Y5Vs,154
+adaptivetesting/implementations/__pre_test.py,sha256=W2Byp7UCnzYMg537nK0DeKTBTQb_qV7pbrvsFQ8MWM0,2816
+adaptivetesting/implementations/__semi_implementation.py,sha256=jimHdQ9lfb_jOLv4bk_BOpCEhy_YOVKwuFREvpH83zk,4627
+adaptivetesting/math/__init__.py,sha256=XlYMm5BHbG4JIQdEw85Y6HCnoYQGgVs9RR1z0cmcLVg,103
+adaptivetesting/math/__standard_error.py,sha256=kA-wCRsbQKT26-kazMujDnX91kn0-V0JVixeSLBICCo,2234
+adaptivetesting/math/__test_information.py,sha256=wr0VMisYYhQ2hVnXrHkVLbFHQc03Tbd92Nindhm4Vq0,1175
+adaptivetesting/models/__adaptive_test.py,sha256=iPPlHsdXNH7-U5QrDrvqLYfDJrEhRYCLEWXsrDv1MWA,5646
+adaptivetesting/models/__algorithm_exception.py,sha256=QtgzsLE7nfVJ-SkbASlHohvJ_7dZYPk35WkZCH1CaVc,125
+adaptivetesting/models/__init__.py,sha256=NYJuqxiemQ34NHqsJ0Vscp1gHHUlNcIE4aQdcE8wTZU,267
+adaptivetesting/models/__item_pool.py,sha256=OP90_paKU-euN-csCDi88v6WF-XC4Euit-znr7tQqqU,8157
+adaptivetesting/models/__item_selection_exception.py,sha256=EWlGdfExvV_UV0hVG6W-DsVTY2Q5kDVyODAFcvgh1BQ,103
+adaptivetesting/models/__test_item.py,sha256=fDH-uK7_5AvGwzVudSdsW0cJ9SGNt5SQx61st4CvR84,699
+adaptivetesting/models/__test_result.py,sha256=SAMrh7WwBpY6ASG0RdGmeqvvsK7vP3AZEOFpwg0eDZs,624
+adaptivetesting/services/__estimator_interface.py,sha256=nl2UQUV6nbGYp7vE1tyg0LjZFaRLnnMNxXPMpbyaQns,1375
+adaptivetesting/services/__init__.py,sha256=kAPgNpSYGSIfDWTYZYAkRU4Mox5M63mYnVEI2IpoMqQ,97
+adaptivetesting/services/__test_results_interface.py,sha256=8uLDXCk0VI8YC82XKLJODxsQgtlnTYf6AsvAMPyl_aQ,807
+adaptivetesting/simulation/__init__.py,sha256=gbmEgpLmvPfbFL96wSIQ0RDAr5-pGg46pydp_aH0y1o,27
+adaptivetesting/simulation/__simulation.py,sha256=xvt02auTJvXyzyhEZF5iK-4gJIuu7WNYCUZW1gE6-oI,2544
+adaptivetesting/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+adaptivetesting/tests/test_adaptive_test.py,sha256=GhGr0rAPNH8eBLsHjTwrugPhPiykcG9iM3NzaT_u-RE,1817
+adaptivetesting/tests/test_bayes_modal.py,sha256=0daQlba5-k3qRR5s_j9wQcc_ClDr-a6Cs7elT3YRhw8,915
+adaptivetesting/tests/test_code_examples.py,sha256=ChJSD-ltoHyS6a6787F-l-Rd83RqOSzEzxfm_HUmjmE,566
+adaptivetesting/tests/test_information_test.py,sha256=zahyit9_PU4msmizm_lXAPcVAaaNtL0s1Kte-VfM8Fc,1296
+adaptivetesting/tests/test_load_test_items.py,sha256=3n2egcnisgEfq_qHSgxIPUl5z0DZQTEl6Mog2sbM6uI,3019
+adaptivetesting/tests/test_mle.py,sha256=83y9F9EPZN3d_RkQXuhdCKnXNzNFPnPH_T2DdbUixu0,2089
+adaptivetesting/tests/test_pretest.py,sha256=QTrc4cotGMW7bJuYlGXHL4JE065cwoi24ieLHVWwXEU,935
+adaptivetesting/tests/test_standard_error.py,sha256=IMlQy_howIbBaiwzER_p35xtFIfgX3Un_nH5YotNOAY,1640
+adaptivetesting/tests/test_urrys_rule.py,sha256=09Xf8FW0KXJG6YBInbB62iRa2OwquGfleQ0TcL8zwhA,654
+adaptivetesting-1.0.0.dist-info/licenses/LICENSE,sha256=gCou0u4LSh7afsTTnOlU4HuOLgVCQ1tDpFylelKfxAk,16661
+adaptivetesting-1.0.0.dist-info/METADATA,sha256=OBXM_3tVVYqpS31OBqiRNEWNFx90ej2Te7vC7i-uOls,3825
+adaptivetesting-1.0.0.dist-info/WHEEL,sha256=tTnHoFhvKQHCh4jz3yCn0WPTYIy7wXx3CJtJ7SJGV7c,91
+adaptivetesting-1.0.0.dist-info/top_level.txt,sha256=bUXMybDG9CsmK1_gbtA1AxqHlyy8eLbfcYol1airQ2E,16
+adaptivetesting-1.0.0.dist-info/RECORD,,

adaptivetesting-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (77.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+