typ: remove Experiment type

mitosis/__init__.py

@@ -220,16 +220,16 @@ def _verify_variant_name(trial_db: Path, step: str, param: Parameter) -> None:
     eng = create_engine("sqlite:///" + str(trial_db))
     md = MetaData()
     tb = Table(f"{step}_variant_{param.arg_name}", md, *variant_types())
-    vals: Collection[Any]
+    vals: Collection
     if isinstance(param.vals, Mapping):
         vals = StrictlyReproduceableDict({k: v for k, v in sorted(param.vals.items())})
     elif isinstance(param.vals, Collection) and not isinstance(param.vals, str):
         try:
             vals = StrictlyReproduceableList(sorted(param.vals))
         except (ValueError, TypeError):
-            vals = param.vals
+            vals = str(param.vals)
     else:
-        vals = param.vals
+        vals = str(param.vals)
     df = pd.read_sql(select(tb), eng)
     ind_equal = df.loc[:, "name"] == param.var_name
     if ind_equal.sum() == 0:

mitosis/_typing.py

@@ -1,23 +1,18 @@
-from abc import ABCMeta
+from collections.abc import Mapping
 from dataclasses import dataclass
 from dataclasses import field
-from types import ModuleType
-from typing import Any
 from typing import Callable
 from typing import NamedTuple
 from typing import ParamSpec
+from typing import TypedDict
 
 
-P = ParamSpec("P")
-ExpRun = Callable[P, dict]
+class ExpResults(TypedDict):
+    main: object
 
 
-class Experiment(ModuleType, metaclass=ABCMeta):
-    __name__: str
-    __file__: str
-    name: str
-    lookup_dict: dict[str, dict[str, Any]]
-    run: ExpRun
+P = ParamSpec("P")
+ExpRun = Callable[P, ExpResults]
 
 
 @dataclass
@@ -33,7 +28,7 @@ class Parameter:
 
     var_name: str
     arg_name: str
-    vals: Any
+    vals: object
     # > 3.10 only: https://stackoverflow.com/a/49911616/534674
     evaluate: bool = field(default=False, kw_only=True)
 
@@ -42,7 +37,7 @@ class ExpStep(NamedTuple):
     name: str
     action: ExpRun
     action_ref: str
-    lookup: dict[str, Any]
+    lookup: Mapping[str, Mapping[str, object]]
     lookup_ref: str
     group: str | None
     args: list[Parameter]

mitosis/tests/mock_paper.py

@@ -5,4 +5,6 @@
 meth_config = {"metric": {"test": "len"}}
 
 # lookup any parameter, any variant: always none
-lookup_default = defaultdict(lambda: defaultdict(lambda: None))
+lookup_default: dict[str, dict[str, None]] = defaultdict(
+    lambda: defaultdict(lambda: None)
+)

mitosis/tests/mock_part1.py

@@ -1,21 +1,23 @@
 from logging import getLogger
 
 import numpy as np
-from numpy.typing import NBitBase
-from numpy.typing import NDArray
+
+from mitosis._typing import ExpResults
 
 
 class Klass:
     @staticmethod
-    def gen_data(
-        length: int, extra: bool = False
-    ) -> dict[str, NDArray[np.floating[NBitBase]] | bool]:
+    def gen_data(length: int, extra: bool = False) -> ExpResults:
         getLogger(__name__).info("This is run every time")
         getLogger(__name__).debug("This is run in debug mode only")
 
-        return {"data": np.ones(length, dtype=np.float_), "extra": extra}
+        return {
+            "data": np.ones(length, dtype=np.float_),
+            "extra": extra,
+            "main": None,
+        }  # type: ignore
 
 
-def do_nothing(*args, **kwargs) -> dict[str, None]:
+def do_nothing(*args, **kwargs) -> ExpResults:
     """An experiment step that accepts anything and produces nothing"""
     return {"main": None}

mitosis/tests/mock_part2.py

@@ -5,15 +5,17 @@
 from numpy.typing import NBitBase
 from numpy.typing import NDArray
 
+from mitosis._typing import ExpResults
+
 
 def fit_and_score(
     data: NDArray[np.floating[NBitBase]], metric: Literal["len"] | Literal["zero"]
-) -> dict[str, float]:
+) -> ExpResults:
     if metric == "len":
         return {"main": len(data)}
     elif metric == "zero":
         return {"main": 0}
 
 
-def bad_runnable(*args: Any, **kwargs: Any):
+def bad_runnable(*args: Any, **kwargs: Any) -> int:
     return 1  # not a dict with key "main"