fix: fix test

Author: yuejiaointel

onedal/neighbors/neighbors.py

@@ -70,33 +70,17 @@ def _get_onedal_params(self, X, y=None, n_neighbors=None):
 
             fptype = np.float64
 
-        # Handle _fit_method: use if set by sklearnex, otherwise determine it ourselves
+        # _fit_method should be set by sklearnex level before calling oneDAL
         if not hasattr(self, "_fit_method") or self._fit_method is None:
-            # Direct oneDAL usage - determine method ourselves
-            method = getattr(self, "algorithm", "auto")
-            n_samples, n_features = X.shape
-            
-            if method in ["auto", "ball_tree"]:
-                condition = (
-                    self.n_neighbors is not None and self.n_neighbors >= n_samples // 2
-                )
-                if getattr(self, "metric", "minkowski") == "precomputed" or n_features > 15 or condition:
-                    fit_method = "brute"
-                else:
-                    if getattr(self, "effective_metric_", getattr(self, "metric", "minkowski")) == "euclidean":
-                        fit_method = "kd_tree"
-                    else:
-                        fit_method = "brute"
-            else:
-                fit_method = method
-        else:
-            # Use the method set by sklearnex level
-            fit_method = self._fit_method
+            raise ValueError(
+                "_fit_method must be set by sklearnex level before calling oneDAL. "
+                "This indicates improper usage - oneDAL neighbors should not be called directly."
+            )
 
         return {
             "fptype": fptype,
             "vote_weights": "uniform" if weights == "uniform" else "distance",
-            "method": fit_method,
+            "method": self._fit_method,
             "radius": self.radius,
             "class_count": class_count,
             "neighbor_count": self.n_neighbors if n_neighbors is None else n_neighbors,

onedal/neighbors/tests/test_knn_classification.py

@@ -19,15 +19,15 @@
 from numpy.testing import assert_array_equal
 from sklearn import datasets
 
-from onedal.neighbors import KNeighborsClassifier
+from sklearnex.neighbors import KNeighborsClassifier
 from onedal.tests.utils._device_selection import get_queues
 
 
 @pytest.mark.parametrize("queue", get_queues())
 def test_iris(queue):
     iris = datasets.load_iris()
-    clf = KNeighborsClassifier(2).fit(iris.data, iris.target, queue=queue)
-    assert clf.score(iris.data, iris.target, queue=queue) > 0.9
+    clf = KNeighborsClassifier(2).fit(iris.data, iris.target)
+    assert clf.score(iris.data, iris.target) > 0.9
     assert_array_equal(clf.classes_, np.sort(clf.classes_))
 
 
@@ -36,14 +36,14 @@ def test_pickle(queue):
     if queue and queue.sycl_device.is_gpu:
         pytest.skip("KNN classifier pickling for the GPU sycl_queue is buggy.")
     iris = datasets.load_iris()
-    clf = KNeighborsClassifier(2).fit(iris.data, iris.target, queue=queue)
-    expected = clf.predict(iris.data, queue=queue)
+    clf = KNeighborsClassifier(2).fit(iris.data, iris.target)
+    expected = clf.predict(iris.data)
 
     import pickle
 
     dump = pickle.dumps(clf)
     clf2 = pickle.loads(dump)
 
     assert type(clf2) == clf.__class__
-    result = clf2.predict(iris.data, queue=queue)
+    result = clf2.predict(iris.data)
     assert_array_equal(expected, result)