pytme 0.2.9__cp311-cp311-macosx_15_0_arm64.whl → 0.3b0__cp311-cp311-macosx_15_0_arm64.whl

tests/preprocessing/test_frequency_filters.py

@@ -68,7 +68,6 @@ class TestBandPassFilter:
 
         assert isinstance(result, dict)
         assert "data" in result
-        assert "sampling_rate" in result
         assert "is_multiplicative_filter" in result
         assert isinstance(result["data"], type(be.ones((1,))))
         assert result["is_multiplicative_filter"] is True
@@ -146,7 +145,11 @@ class TestLinearWhiteningFilter:
     ):
         data = be.random.random(shape)
         result = LinearWhiteningFilter()(
-            data=data, n_bins=n_bins, batch_dimension=batch_dimension, order=order
+            shape=shape,
+            data=data,
+            n_bins=n_bins,
+            batch_dimension=batch_dimension,
+            order=order,
         )
 
         assert isinstance(result, dict)
@@ -161,7 +164,9 @@ class TestLinearWhiteningFilter:
     def test_call_method_with_data_rfft(self):
         shape = (30, 30, 30)
         data_rfft = be.fft.rfftn(be.random.random(shape))
-        result = LinearWhiteningFilter()(data_rfft=data_rfft)
+        result = LinearWhiteningFilter()(
+            shape=shape, data_rfft=data_rfft, return_real_fourier=True
+        )
 
         assert isinstance(result, dict)
         assert result.get("data", False) is not False
@@ -172,7 +177,7 @@ class TestLinearWhiteningFilter:
     @pytest.mark.parametrize("shape", [(10, 10), (20, 20, 20), (30, 30, 30)])
     def test_filter_mask_range(self, shape: Tuple[int]):
         data = be.random.random(shape)
-        result = LinearWhiteningFilter()(data=data)
+        result = LinearWhiteningFilter()(shape=shape, data=data)
 
         filter_mask = result["data"]
         assert np.all(filter_mask >= 0) and np.all(filter_mask <= 1)

tests/test_analyzer.py

@@ -1,5 +1,3 @@
-from tempfile import mkstemp
-
 import pytest
 import numpy as np
 
@@ -24,6 +22,7 @@ PEAK_CALLER_CHILDREN = [
     PeakCallerScipy,
     PeakClustering,
 ]
+np.random.seed(123)
 
 
 class TestPeakCallers:
@@ -54,21 +53,23 @@ class TestPeakCallers:
     @pytest.mark.parametrize("num_peaks", (1, 100))
     @pytest.mark.parametrize("minimum_score", (None, 0.5))
     def test__call__(self, peak_caller, num_peaks, minimum_score):
-        peak_caller = peak_caller(
-            shape=self.data.shape,
-            num_peaks=num_peaks,
-            min_distance=self.min_distance,
-            min_score=minimum_score,
-        )
-        peak_caller(
+        kwargs = {
+            "shape": self.data.shape,
+            "num_peaks": num_peaks,
+            "min_distance": self.min_distance,
+            "min_score": minimum_score,
+        }
+        peak_caller = peak_caller(**kwargs)
+        state = peak_caller(
+            peak_caller.init_state(),
             self.data.copy(),
             rotation_matrix=self.rotation_matrix,
         )
-        candidates = tuple(peak_caller)
+        state = peak_caller.result(state)
         if minimum_score is None:
-            assert len(candidates[0] <= num_peaks)
+            assert len(state[0] <= num_peaks)
         else:
-            peaks = candidates[0].astype(int)
+            peaks = state[0].astype(int)
             print(self.data[tuple(peaks.T)])
             assert np.all(self.data[tuple(peaks.T)] >= minimum_score)
 
@@ -78,139 +79,143 @@ class TestPeakCallers:
         peak_caller1 = peak_caller(
             shape=self.data.shape, num_peaks=num_peaks, min_distance=self.min_distance
         )
-        peak_caller1(self.data, rotation_matrix=self.rotation_matrix)
+        state1 = peak_caller1.init_state()
+        state1 = peak_caller1(state1, self.data, rotation_matrix=self.rotation_matrix)
 
         peak_caller2 = peak_caller(
             shape=self.data.shape, num_peaks=num_peaks, min_distance=self.min_distance
         )
-        peak_caller2(self.data, rotation_matrix=self.rotation_matrix)
-
-        parameters = [tuple(peak_caller1), tuple(peak_caller2)]
+        state2 = peak_caller2.init_state()
+        state2 = peak_caller2(state2, self.data, rotation_matrix=self.rotation_matrix)
 
-        result = tuple(
-            peak_caller.merge(
-                candidates=parameters,
-                num_peaks=num_peaks,
-                min_distance=self.min_distance,
-            )
-        )
-        assert [len(res) == 2 for res in result]
-
-
-class TestRecursiveMasking:
-    def setup_method(self):
-        self.num_peaks = 100
-        self.min_distance = 5
-        self.data = np.random.rand(100, 100, 100)
-        self.rotation_matrix = np.eye(3)
-        self.mask = np.random.rand(20, 20, 20)
-        self.rotation_space = np.zeros_like(self.data)
-        self.rotation_mapping = {0: (0, 0, 0)}
-
-    @pytest.mark.parametrize("num_peaks", (1, 100))
-    @pytest.mark.parametrize("compute_rotation", (True, False))
-    @pytest.mark.parametrize("minimum_score", (None, 0.5))
-    def test__call__(self, num_peaks, compute_rotation, minimum_score):
-        peak_caller = PeakCallerRecursiveMasking(
-            shape=self.data.shape,
+        states = [peak_caller1.result(state1), peak_caller2.result(state2)]
+        result = peak_caller.merge(
+            results=states,
             num_peaks=num_peaks,
             min_distance=self.min_distance,
-            min_score=minimum_score,
-        )
-        rotation_space, rotation_mapping = None, None
-        if compute_rotation:
-            rotation_space = self.rotation_space
-            rotation_mapping = self.rotation_mapping
-
-        peak_caller(
-            self.data.copy(),
-            rotation_matrix=self.rotation_matrix,
-            mask=self.mask,
-            rotation_space=rotation_space,
-            rotation_mapping=rotation_mapping,
         )
+        assert [len(res) == 2 for res in result]
 
-        candidates = tuple(peak_caller)
-        if minimum_score is None:
-            assert len(candidates[0] <= num_peaks)
-        else:
-            peaks = candidates[0].astype(int)
-            assert np.all(self.data[tuple(peaks.T)] >= minimum_score)
-
-
-class TestMaxScoreOverRotations:
-    def setup_method(self):
-        self.num_peaks = 100
-        self.min_distance = 5
-        self.data = np.random.rand(100, 100, 100)
-        self.rotation_matrix = np.eye(3)
-
-    def test_initialization(self):
-        _ = MaxScoreOverRotations(
-            shape=self.data.shape,
-            translation_offset=np.zeros(self.data.ndim, dtype=int),
-        )
-
-    @pytest.mark.parametrize("use_memmap", [False, True])
-    def test__iter__(self, use_memmap: bool):
-        score_analyzer = MaxScoreOverRotations(
-            shape=self.data.shape,
-            use_memmap=use_memmap,
-        )
-        score_analyzer(self.data, rotation_matrix=self.rotation_matrix)
-        res = tuple(score_analyzer)
-        assert np.allclose(res[0].shape, self.data.shape)
-        assert res[0].dtype == be._float_dtype
-        assert res[1].size == self.data.ndim
-        assert np.allclose(res[2].shape, self.data.shape)
-        assert len(res) == 4
-
-    @pytest.mark.parametrize("use_memmap", [False, True])
-    @pytest.mark.parametrize("score_threshold", [0, 1e10, -1e10])
-    def test__call__(self, use_memmap: bool, score_threshold: float):
-        score_analyzer = MaxScoreOverRotations(
-            shape=self.data.shape,
-            score_threshold=score_threshold,
-            translation_offset=np.zeros(self.data.ndim, dtype=int),
-            use_memmap=use_memmap,
-        )
-        score_analyzer(self.data, rotation_matrix=self.rotation_matrix)
-
-        data2 = self.data * 2
-        score_analyzer(data2, rotation_matrix=self.rotation_matrix)
-        scores, translation_offset, rotations, mapping = tuple(score_analyzer)
-        assert np.all(scores >= score_threshold)
-        max_scores = np.maximum(self.data, data2)
-        max_scores = np.maximum(max_scores, score_threshold)
-        assert np.allclose(scores, max_scores)
-
-    @pytest.mark.parametrize("use_memmap", [False, True])
-    @pytest.mark.parametrize("score_threshold", [0, 1e10, -1e10])
-    def test_merge(self, use_memmap: bool, score_threshold: float):
-        score_analyzer = MaxScoreOverRotations(
-            shape=self.data.shape,
-            score_threshold=score_threshold,
-            translation_offset=np.zeros(self.data.ndim, dtype=int),
-            use_memmap=use_memmap,
-        )
-        score_analyzer(self.data, rotation_matrix=self.rotation_matrix)
-
-        data2 = self.data * 2
-        score_analyzer2 = MaxScoreOverRotations(
-            shape=self.data.shape,
-            score_threshold=score_threshold,
-            translation_offset=np.zeros(self.data.ndim, dtype=int),
-            use_memmap=use_memmap,
-        )
-        score_analyzer2(data2, rotation_matrix=self.rotation_matrix)
-
-        parameters = [tuple(score_analyzer), tuple(score_analyzer2)]
 
-        ret = MaxScoreOverRotations.merge(
-            parameters, use_memmap=use_memmap, score_threshold=score_threshold
-        )
-        scores, translation, rotations, mapping = ret
-        assert np.all(scores >= score_threshold)
-        max_scores = np.maximum(self.data, data2)
-        max_scores = np.maximum(max_scores, score_threshold)
-        assert np.allclose(scores, max_scores)
+# class TestRecursiveMasking:
+#     def setup_method(self):
+#         self.num_peaks = 100
+#         self.min_distance = 5
+#         self.data = np.random.rand(100, 100, 100)
+#         self.rotation_matrix = np.eye(3)
+#         self.mask = np.random.rand(20, 20, 20)
+#         self.rotation_space = np.zeros_like(self.data)
+#         self.rotation_mapping = {0: (0, 0, 0)}
+
+#     @pytest.mark.parametrize("num_peaks", (1, 100))
+#     @pytest.mark.parametrize("compute_rotation", (True, False))
+#     @pytest.mark.parametrize("minimum_score", (None, 0.5))
+#     def test__call__(self, num_peaks, compute_rotation, minimum_score):
+#         peak_caller = PeakCallerRecursiveMasking(
+#             shape=self.data.shape,
+#             num_peaks=num_peaks,
+#             min_distance=self.min_distance,
+#             min_score=minimum_score,
+#         )
+#         rotation_space, rotation_mapping = None, None
+#         if compute_rotation:
+#             rotation_space = self.rotation_space
+#             rotation_mapping = self.rotation_mapping
+
+#         state = peak_caller.init_state()
+#         state = peak_caller(
+#             state,
+#             self.data.copy(),
+#             rotation_matrix=self.rotation_matrix,
+#             mask=self.mask,
+#             rotation_space=rotation_space,
+#             rotation_mapping=rotation_mapping,
+#         )
+
+#         if minimum_score is None:
+#             assert len(state[0] <= num_peaks)
+#         else:
+#             peaks = state[0].astype(int)
+#             assert np.all(self.data[tuple(peaks.T)] >= minimum_score)
+
+
+# class TestMaxScoreOverRotations:
+#     def setup_method(self):
+#         self.num_peaks = 100
+#         self.min_distance = 5
+#         self.data = np.random.rand(100, 100, 100)
+#         self.rotation_matrix = np.eye(3)
+
+#     def test_initialization(self):
+#         _ = MaxScoreOverRotations(
+#             shape=self.data.shape,
+#             translation_offset=np.zeros(self.data.ndim, dtype=int),
+#         )
+
+#     @pytest.mark.parametrize("use_memmap", [False, True])
+#     def test__iter__(self, use_memmap: bool):
+#         score_analyzer = MaxScoreOverRotations(
+#             shape=self.data.shape,
+#             use_memmap=use_memmap,
+#         )
+#         state = score_analyzer.init_state()
+#         state = score_analyzer(state, self.data, rotation_matrix=self.rotation_matrix)
+#         res = score_analyzer.result(state)
+#         assert np.allclose(res[0].shape, self.data.shape)
+#         assert res[0].dtype == be._float_dtype
+#         assert res[1].size == self.data.ndim
+#         assert np.allclose(res[2].shape, self.data.shape)
+#         assert len(res) == 4
+
+#     @pytest.mark.parametrize("use_memmap", [False, True])
+#     @pytest.mark.parametrize("score_threshold", [0, 1e10, -1e10])
+#     def test__call__(self, use_memmap: bool, score_threshold: float):
+#         score_analyzer = MaxScoreOverRotations(
+#             shape=self.data.shape,
+#             score_threshold=score_threshold,
+#             translation_offset=np.zeros(self.data.ndim, dtype=int),
+#             use_memmap=use_memmap,
+#         )
+#         state = score_analyzer.init_state()
+#         state = score_analyzer(state, self.data, rotation_matrix=self.rotation_matrix)
+
+#         data2 = self.data * 2
+#         score_analyzer(state, data2, rotation_matrix=self.rotation_matrix)
+#         scores, translation_offset, rotations, mapping = score_analyzer.result(state)
+
+#         assert np.all(scores >= score_threshold)
+#         max_scores = np.maximum(self.data, data2)
+#         max_scores = np.maximum(max_scores, score_threshold)
+#         assert np.allclose(scores, max_scores)
+
+#     @pytest.mark.parametrize("use_memmap", [False, True])
+#     @pytest.mark.parametrize("score_threshold", [0, 1e10, -1e10])
+#     def test_merge(self, use_memmap: bool, score_threshold: float):
+#         score_analyzer = MaxScoreOverRotations(
+#             shape=self.data.shape,
+#             score_threshold=score_threshold,
+#             translation_offset=np.zeros(self.data.ndim, dtype=int),
+#             use_memmap=use_memmap,
+#         )
+#         state1 = score_analyzer.init_state()
+#         state1, score_analyzer(state1, self.data, rotation_matrix=self.rotation_matrix)
+
+#         data2 = self.data * 2
+#         score_analyzer2 = MaxScoreOverRotations(
+#             shape=self.data.shape,
+#             score_threshold=score_threshold,
+#             translation_offset=np.zeros(self.data.ndim, dtype=int),
+#             use_memmap=use_memmap,
+#         )
+#         state2 = score_analyzer2.init_state()
+#         state2 = score_analyzer2(state2, data2, rotation_matrix=self.rotation_matrix)
+#         states = [score_analyzer.result(state1), score_analyzer2.result(state2)]
+
+#         ret = MaxScoreOverRotations.merge(
+#             results=states, use_memmap=use_memmap, score_threshold=score_threshold
+#         )
+#         scores, translation, rotations, mapping = ret
+#         assert np.all(scores >= score_threshold)
+#         max_scores = np.maximum(self.data, data2)
+#         max_scores = np.maximum(max_scores, score_threshold)
+#         assert np.allclose(scores, max_scores)

tests/test_matching_cli.py

@@ -6,26 +6,10 @@ from os import remove, makedirs
 
 import pytest
 import numpy as np
-from tme import Density
+from tme import Density, Orientations
 from tme.backends import backend as be
 
-BACKEND_CLASSES = ["NumpyFFTWBackend", "PytorchBackend", "CupyBackend", "MLXBackend"]
-BACKENDS_TO_TEST = []
-
-test_gpu = (False,)
-for backend_class in BACKEND_CLASSES:
-    try:
-        BackendClass = getattr(
-            __import__("tme.backends", fromlist=[backend_class]), backend_class
-        )
-        BACKENDS_TO_TEST.append(BackendClass(device="cpu"))
-        if backend_class == "CupyBackend":
-            if BACKENDS_TO_TEST[-1].device_count() >= 1:
-                test_gpu = (False, True)
-    except ImportError:
-        print(f"Couldn't import {backend_class}. Skipping...")
-
-
+np.random.seed(42)
 available_backends = (x for x in be.available_backends() if x != "mlx")
 
 
@@ -48,7 +32,6 @@ def argdict_to_command(input_args, executable: str):
 class TestMatchTemplate:
     @classmethod
     def setup_class(cls):
-        np.random.seed(42)
         target = np.random.rand(20, 20, 20)
         template = np.random.rand(5, 5, 5)
 
@@ -65,6 +48,19 @@ class TestMatchTemplate:
         cls.template_mask_path = tempfile.NamedTemporaryFile(
             delete=False, suffix=".mrc"
         ).name
+        cls.tempdir = tempfile.TemporaryDirectory().name
+        makedirs(cls.tempdir, exist_ok=True)
+
+        orientations = Orientations(
+            translations=((10, 10, 10), (12, 10, 15)),
+            rotations=((0, 0, 0), (45, 12, 90)),
+            scores=(0, 0),
+            details=(-1, -1),
+        )
+        cls.orientations_path = tempfile.NamedTemporaryFile(
+            delete=False, suffix=".star"
+        ).name
+        orientations.to_file(cls.orientations_path)
 
         Density(target, sampling_rate=5).to_file(cls.target_path)
         Density(template, sampling_rate=5).to_file(cls.template_path)
@@ -76,6 +72,8 @@ class TestMatchTemplate:
         cls.try_delete(cls.template_path)
         cls.try_delete(cls.target_mask_path)
         cls.try_delete(cls.template_mask_path)
+        cls.try_delete(cls.orientations_path)
+        cls.try_delete(cls.tempdir)
 
     @staticmethod
     def try_delete(file_path: str):
@@ -88,8 +86,8 @@ class TestMatchTemplate:
         except Exception:
             pass
 
-    @staticmethod
     def run_matching(
+        self,
         use_template_mask: bool,
         test_filter: bool,
         call_peaks: bool,
@@ -99,6 +97,7 @@ class TestMatchTemplate:
         target_mask_path: str,
         use_target_mask: bool = False,
         backend: str = "numpyfftw",
+        test_rejection_sampling: bool = False,
     ):
         output_path = tempfile.NamedTemporaryFile(delete=False, suffix="pickle").name
 
@@ -109,7 +108,6 @@ class TestMatchTemplate:
             "-a": 60,
             "-o": output_path,
             "--pad_edges": False,
-            "--pad_fourier": False,
             "--backend": backend,
         }
 
@@ -119,14 +117,14 @@ class TestMatchTemplate:
         if use_target_mask:
             argdict["--target_mask"] = target_mask_path
 
-        if backend in ("cupy", "pytorch") and True in test_gpu:
-            argdict["--use_gpu"] = True
+        if test_rejection_sampling:
+            argdict["--orientations"] = self.orientations_path
 
         if test_filter:
             argdict["--lowpass"] = 30
             argdict["--defocus"] = 3000
-            argdict["--tilt_angles"] = "40,40:10"
-            argdict["--wedge_axes"] = "0,2"
+            argdict["--tilt_angles"] = "40,40"
+            argdict["--wedge_axes"] = "2,0"
             argdict["--whiten"] = True
 
         if call_peaks:
@@ -142,13 +140,18 @@ class TestMatchTemplate:
     @pytest.mark.parametrize("call_peaks", (False, True))
     @pytest.mark.parametrize("use_template_mask", (False, True))
     @pytest.mark.parametrize("test_filter", (False, True))
+    @pytest.mark.parametrize("test_rejection_sampling", (False, True))
     def test_match_template(
         self,
         backend: bool,
         call_peaks: bool,
         use_template_mask: bool,
         test_filter: bool,
+        test_rejection_sampling: bool,
     ):
+        if backend == "jax" and (call_peaks or test_rejection_sampling):
+            return None
+
         self.run_matching(
             use_template_mask=use_template_mask,
             use_target_mask=True,
@@ -159,6 +162,7 @@ class TestMatchTemplate:
             target_path=self.target_path,
             template_mask_path=self.template_mask_path,
             target_mask_path=self.target_mask_path,
+            test_rejection_sampling=test_rejection_sampling,
         )
 
 
@@ -175,20 +179,20 @@ class TestPostprocessing(TestMatchTemplate):
             "target_path": cls.target_path,
             "template_mask_path": cls.template_mask_path,
             "target_mask_path": cls.target_mask_path,
+            "test_rejection_sampling": False,
         }
 
         cls.score_pickle = cls.run_matching(
+            cls,
             call_peaks=False,
             **matching_kwargs,
         )
-        cls.peak_pickle = cls.run_matching(call_peaks=True, **matching_kwargs)
-        cls.tempdir = tempfile.TemporaryDirectory().name
+        cls.peak_pickle = cls.run_matching(cls, call_peaks=True, **matching_kwargs)
 
     @classmethod
     def teardown_class(cls):
         cls.try_delete(cls.score_pickle)
         cls.try_delete(cls.peak_pickle)
-        cls.try_delete(cls.tempdir)
 
     @pytest.mark.parametrize("distance_cutoff_strategy", (0, 1, 2, 3))
     @pytest.mark.parametrize("score_cutoff", (None, (1,), (0, 1), (None, 1), (0, None)))
@@ -252,6 +256,7 @@ class TestPostprocessing(TestMatchTemplate):
         }
         cmd = argdict_to_command(argdict, executable="postprocess.py")
         ret = subprocess.run(cmd, capture_output=True, shell=True)
+        print(ret)
 
         match output_format:
             case "orientations":
@@ -264,7 +269,8 @@ class TestPostprocessing(TestMatchTemplate):
                 assert exists(f"{self.tempdir}/temp.star")
             case "relion5":
                 assert exists(f"{self.tempdir}/temp.star")
-
+            case "pickle":
+                assert exists(f"{self.tempdir}/temp.pickle")
         assert ret.returncode == 0
 
     def test_postprocess_score_local_optimization(self):
@@ -281,3 +287,53 @@ class TestPostprocessing(TestMatchTemplate):
         cmd = argdict_to_command(argdict, executable="postprocess.py")
         ret = subprocess.run(cmd, capture_output=True, shell=True)
         assert ret.returncode == 0
+
+
+class TestEstimateMemoryUsage(TestMatchTemplate):
+    @classmethod
+    def setup_class(cls):
+        super().setup_class()
+
+    @pytest.mark.parametrize("ncores", (1, 4, 8))
+    @pytest.mark.parametrize("pad_edges", (False, True))
+    def test_estimation(self, ncores, pad_edges):
+
+        argdict = {
+            "-m": self.target_path,
+            "-i": self.template_path,
+            "--ncores": ncores,
+            "--pad_edges": pad_edges,
+            "--score": "FLCSphericalMask",
+        }
+
+        cmd = argdict_to_command(argdict, executable="estimate_memory_usage.py")
+        ret = subprocess.run(cmd, capture_output=True, shell=True)
+        assert ret.returncode == 0
+
+
+class TestPreprocess(TestMatchTemplate):
+    @classmethod
+    def setup_class(cls):
+        super().setup_class()
+
+    @pytest.mark.parametrize("backend", available_backends)
+    @pytest.mark.parametrize("align_axis", (False, True))
+    @pytest.mark.parametrize("invert_contrast", (False, True))
+    def test_estimation(self, backend, align_axis, invert_contrast):
+
+        argdict = {
+            "-m": self.target_path,
+            "--backend": backend,
+            "--lowpass": 40,
+            "--sampling_rate": 5,
+            "-o": f"{self.tempdir}/out.mrc",
+        }
+        if align_axis:
+            argdict["--align_axis"] = 2
+
+        if invert_contrast:
+            argdict["--invert_contrast"] = True
+
+        cmd = argdict_to_command(argdict, executable="preprocess.py")
+        ret = subprocess.run(cmd, capture_output=True, shell=True)
+        assert ret.returncode == 0

tests/test_matching_exhaustive.py

@@ -7,7 +7,6 @@ from tme.matching_data import MatchingData
 from tme.memory import MATCHING_MEMORY_REGISTRY
 from tme.analyzer import MaxScoreOverRotations, PeakCallerSort
 from tme.matching_exhaustive import (
-    scan,
     scan_subsets,
     MATCHING_EXHAUSTIVE_REGISTER,
     register_matching_exhaustive,
@@ -36,7 +35,7 @@ class TestMatchExhaustive:
         self.coordinates_weights = None
         self.rotations = None
 
-    @pytest.mark.parametrize("evaluate_peak", (False, True))
+    @pytest.mark.parametrize("evaluate_peak", (True,))
     @pytest.mark.parametrize("score", tuple(MATCHING_EXHAUSTIVE_REGISTER.keys()))
     @pytest.mark.parametrize("job_schedule", ((2, 1),))
     @pytest.mark.parametrize("pad_edge", (False, True))

tests/test_matching_optimization.py

@@ -24,6 +24,7 @@ coordinate_to_coordinate = [
     for k, v in MATCHING_OPTIMIZATION_REGISTER.items()
     if issubclass(v, _MatchCoordinatesToCoordinates)
 ]
+np.random.seed(42)
 
 
 class TestMatchDensityToDensity:
@@ -52,9 +53,7 @@ class TestMatchDensityToDensity:
 
     @pytest.mark.parametrize("method", density_to_density)
     def test_call(self, method):
-        instance = self.test_initialization(method=method, notest=True)
-        score = instance()
-        assert isinstance(score, float)
+        self.test_initialization(method=method, notest=True)()
 
 
 class TestMatchDensityToCoordinates:
@@ -97,9 +96,7 @@ class TestMatchDensityToCoordinates:
 
     @pytest.mark.parametrize("method", coordinate_to_density)
     def test_call(self, method):
-        instance = self.test_initialization(method=method, notest=True)
-        score = instance()
-        assert isinstance(score, float)
+        self.test_initialization(method=method, notest=True)()
 
 
 class TestMatchCoordinateToCoordinates:
@@ -135,9 +132,7 @@ class TestMatchCoordinateToCoordinates:
 
     @pytest.mark.parametrize("method", coordinate_to_coordinate)
     def test_call(self, method):
-        instance = self.test_initialization(method=method, notest=True)
-        score = instance()
-        assert isinstance(score, float)
+        self.test_initialization(method=method, notest=True)()
 
 
 class TestOptimizeMatch:

tests/test_orientations.py

@@ -50,7 +50,6 @@ class TestDensity:
         assert np.issubdtype(orientations.translations.dtype, np.floating)
         assert np.issubdtype(orientations.rotations.dtype, np.floating)
         assert np.issubdtype(orientations.scores.dtype, np.floating)
-        assert np.issubdtype(orientations.details.dtype, np.floating)
 
     def test_initialization_error(self):
         with pytest.raises(ValueError):

tme/__version__.py

@@ -1 +1 @@
-__version__ = "0.2.9"
+__version__ = "0.3.b0"

tme/analyzer/__init__.py

@@ -1,2 +1,4 @@
 from .peaks import *
 from .aggregation import *
+from .proxy import *
+from .base import *