scikit-learn-intelex 2025.4.0__py39-none-win_amd64.whl → 2025.5.0__py39-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/linear_model/logistic_path.py

@@ -34,6 +34,7 @@ import daal4py as d4p
 
 from .._n_jobs_support import control_n_jobs
 from .._utils import PatchingConditionsChain, getFPType, sklearn_check_version
+from ..utils.validation import check_feature_names
 from .logistic_loss import (
     _daal4py_cross_entropy_loss_extra_args,
     _daal4py_grad_,
@@ -793,8 +794,7 @@ def daal4py_fit(self, X, y, sample_weight=None):
 
 def daal4py_predict(self, X, resultsToEvaluate):
     check_is_fitted(self)
-    if sklearn_check_version("1.0"):
-        self._check_feature_names(X, reset=False)
+    check_feature_names(self, X, reset=False)
     X = check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
     try:
         fptype = getFPType(X)
@@ -1005,8 +1005,7 @@ class LogisticRegression(LogisticRegression_original):
         self.l1_ratio = l1_ratio
 
     def fit(self, X, y, sample_weight=None):
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
+        check_feature_names(self, X, reset=True)
         if sklearn_check_version("1.2"):
             self._validate_params()
         return daal4py_fit(self, X, y, sample_weight)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/manifold/_t_sne.py

@@ -37,6 +37,7 @@ from daal4py.sklearn._utils import (
 
 from .._n_jobs_support import control_n_jobs
 from ..neighbors import NearestNeighbors
+from ..utils.validation import validate_data
 
 
 @control_n_jobs(decorated_methods=["fit"])
@@ -183,15 +184,19 @@ class TSNE(BaseTSNE):
                     )
 
         if self.method == "barnes_hut":
-            X = self._validate_data(
+            X = validate_data(
+                self,
                 X,
                 accept_sparse=["csr"],
                 ensure_min_samples=2,
                 dtype=[np.float32, np.float64],
             )
         else:
-            X = self._validate_data(
-                X, accept_sparse=["csr", "csc", "coo"], dtype=[np.float32, np.float64]
+            X = validate_data(
+                self,
+                X,
+                accept_sparse=["csr", "csc", "coo"],
+                dtype=[np.float32, np.float64],
             )
 
         if self.metric == "precomputed":

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/metrics/_pairwise.py

@@ -107,9 +107,14 @@ def _pairwise_distances(
             return _daal4py_correlation_distance_dense(X)
         raise ValueError(f"'{metric}' distance is wrong for daal4py.")
     if metric == "precomputed":
-        X, _ = check_pairwise_arrays(
-            X, Y, precomputed=True, force_all_finite=force_all_finite
-        )
+        if sklearn_check_version("1.6"):
+            X, _ = check_pairwise_arrays(
+                X, Y, precomputed=True, ensure_all_finite=force_all_finite
+            )
+        else:
+            X, _ = check_pairwise_arrays(
+                X, Y, precomputed=True, force_all_finite=force_all_finite
+            )
         whom = (
             "`pairwise_distances`. Precomputed distance "
             " need to have non-negative values."
@@ -119,9 +124,20 @@ def _pairwise_distances(
     if metric in PAIRWISE_DISTANCE_FUNCTIONS:
         func = PAIRWISE_DISTANCE_FUNCTIONS[metric]
     elif callable(metric):
-        func = partial(
-            _pairwise_callable, metric=metric, force_all_finite=force_all_finite, **kwds
-        )
+        if sklearn_check_version("1.6"):
+            func = partial(
+                _pairwise_callable,
+                metric=metric,
+                ensure_all_finite=force_all_finite,
+                **kwds,
+            )
+        else:
+            func = partial(
+                _pairwise_callable,
+                metric=metric,
+                force_all_finite=force_all_finite,
+                **kwds,
+            )
     else:
         if issparse(X) or issparse(Y):
             raise TypeError("scipy distance metrics do not" " support sparse matrices.")
@@ -132,7 +148,14 @@ def _pairwise_distances(
             msg = "Data was converted to boolean for metric %s" % metric
             warnings.warn(msg, DataConversionWarning)
 
-        X, Y = check_pairwise_arrays(X, Y, dtype=dtype, force_all_finite=force_all_finite)
+        if sklearn_check_version("1.6"):
+            X, Y = check_pairwise_arrays(
+                X, Y, dtype=dtype, ensure_all_finite=force_all_finite
+            )
+        else:
+            X, Y = check_pairwise_arrays(
+                X, Y, dtype=dtype, force_all_finite=force_all_finite
+            )
 
         # precompute data-derived metric params
         params = _precompute_metric_params(X, Y, metric=metric, **kwds)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/monkeypatch/dispatcher.py

@@ -171,7 +171,7 @@ def enable(name=None, verbose=True, deprecation=True, get_map=_get_map_of_algori
         warnings.warn_explicit(
             "\nScikit-learn patching with daal4py is deprecated "
             "and will be removed in the future.\n"
-            "Use Intel(R) Extension "
+            "Use Extension "
             "for Scikit-learn* module instead "
             "(pip install scikit-learn-intelex).\n"
             "To enable patching, please use one of the "
@@ -187,7 +187,7 @@ def enable(name=None, verbose=True, deprecation=True, get_map=_get_map_of_algori
         )
     if verbose and deprecation and sys.stderr is not None:
         sys.stderr.write(
-            "Intel(R) oneAPI Data Analytics Library solvers for sklearn enabled: "
+            "oneAPI Data Analytics Library solvers for sklearn enabled: "
             "https://intelpython.github.io/daal4py/sklearn.html\n"
         )
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/neighbors/_base.py

@@ -40,6 +40,7 @@ from .._utils import (
     getFPType,
     sklearn_check_version,
 )
+from ..utils.validation import check_feature_names, check_n_features, get_requires_y_tag
 
 if not sklearn_check_version("1.2"):
     from sklearn.neighbors._base import _check_weights
@@ -239,10 +240,7 @@ def validate_data(
     estimator, X, y=None, reset=True, validate_separately=False, **check_params
 ):
     if y is None:
-        try:
-            requires_y = estimator._get_tags()["requires_y"]
-        except KeyError:
-            requires_y = False
+        requires_y = get_requires_y_tag(estimator)
 
         if requires_y:
             raise ValueError(
@@ -265,7 +263,7 @@ def validate_data(
         out = X, y
 
     if check_params.get("ensure_2d", True):
-        estimator._check_n_features(X, reset=reset)
+        check_n_features(estimator, X, reset=reset)
 
     return out
 
@@ -304,15 +302,10 @@ class NeighborsBase(BaseNeighborsBase):
                     stacklevel=2,
                 )
 
-        if (
-            hasattr(self, "weights")
-            and sklearn_check_version("1.0")
-            and not sklearn_check_version("1.2")
-        ):
+        if hasattr(self, "weights") and not sklearn_check_version("1.2"):
             self.weights = _check_weights(self.weights)
 
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=True)
+        check_feature_names(self, X, reset=True)
 
         X_incorrect_type = isinstance(
             X, (KDTree, BallTree, NeighborsBase, BaseNeighborsBase)
@@ -322,10 +315,7 @@ class NeighborsBase(BaseNeighborsBase):
         shape = None
         correct_n_classes = True
 
-        try:
-            requires_y = self._get_tags()["requires_y"]
-        except KeyError:
-            requires_y = False
+        requires_y = get_requires_y_tag(self)
 
         if y is not None or requires_y:
             if not X_incorrect_type or y is None:

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/neighbors/_classification.py

@@ -25,6 +25,7 @@ from sklearn.neighbors._classification import (
 from sklearn.utils.validation import check_array
 
 from .._utils import PatchingConditionsChain, getFPType, sklearn_check_version
+from ..utils.validation import check_feature_names
 from ._base import KNeighborsMixin, NeighborsBase, parse_auto_method, prediction_algorithm
 
 if not sklearn_check_version("1.2"):
@@ -34,8 +35,7 @@ from sklearn.utils.validation import _deprecate_positional_args
 
 
 def daal4py_classifier_predict(estimator, X, base_predict):
-    if sklearn_check_version("1.0"):
-        estimator._check_feature_names(X, reset=False)
+    check_feature_names(estimator, X, reset=False)
     X = check_array(X, accept_sparse="csr", dtype=[np.float64, np.float32])
     daal_model = getattr(estimator, "_daal_model", None)
     n_features = getattr(estimator, "n_features_in_", None)
@@ -119,9 +119,7 @@ class KNeighborsClassifier(KNeighborsMixin, BaseClassifierMixin, NeighborsBase):
             n_jobs=n_jobs,
             **kwargs,
         )
-        self.weights = (
-            weights if sklearn_check_version("1.0") else _check_weights(weights)
-        )
+        self.weights = weights
 
     def fit(self, X, y):
         return NeighborsBase._fit(self, X, y)
@@ -130,8 +128,7 @@ class KNeighborsClassifier(KNeighborsMixin, BaseClassifierMixin, NeighborsBase):
         return daal4py_classifier_predict(self, X, BaseKNeighborsClassifier.predict)
 
     def predict_proba(self, X):
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_feature_names(self, X, reset=False)
         return BaseKNeighborsClassifier.predict_proba(self, X)
 
     fit.__doc__ = BaseKNeighborsClassifier.fit.__doc__

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/neighbors/_regression.py

@@ -20,6 +20,7 @@ from sklearn.base import RegressorMixin
 from sklearn.neighbors._regression import KNeighborsRegressor as BaseKNeighborsRegressor
 
 from .._utils import sklearn_check_version
+from ..utils.validation import check_feature_names
 from ._base import KNeighborsMixin, NeighborsBase
 
 if not sklearn_check_version("1.2"):
@@ -55,9 +56,7 @@ class KNeighborsRegressor(KNeighborsMixin, RegressorMixin, NeighborsBase):
             n_jobs=n_jobs,
             **kwargs,
         )
-        self.weights = (
-            weights if sklearn_check_version("1.0") else _check_weights(weights)
-        )
+        self.weights = weights
 
     def _more_tags(self):
         return BaseKNeighborsRegressor._more_tags(self)
@@ -66,8 +65,7 @@ class KNeighborsRegressor(KNeighborsMixin, RegressorMixin, NeighborsBase):
         return NeighborsBase._fit(self, X, y)
 
     def predict(self, X):
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_feature_names(self, X, reset=False)
         return BaseKNeighborsRegressor.predict(self, X)
 
     fit.__doc__ = BaseKNeighborsRegressor.fit.__doc__

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/svm/svm.py

@@ -35,6 +35,7 @@ from sklearn.utils.validation import (
 import daal4py
 
 from .._utils import PatchingConditionsChain, getFPType, make2d
+from ..utils.validation import validate_data
 
 
 def _get_libsvm_impl():
@@ -421,7 +422,8 @@ def fit(self, X, y, sample_weight=None):
     if callable(self.kernel):
         check_consistent_length(X, y)
     else:
-        X, y = self._validate_data(
+        X, y = validate_data(
+            self,
             X,
             y,
             dtype=np.float64,
@@ -568,7 +570,7 @@ def _daal4py_predict(self, X, is_decision_function=False):
         res = -predictionRes.decisionFunction
 
     if num_classes == 2 and not is_decision_function:
-        # Convert from Intel(R) oneAPI Data Analytics Library format back to
+        # Convert from oneAPI Data Analytics Library format back to
         # original classes
         np.greater(res, 0, out=res)
 

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/utils/base.py

@@ -14,7 +14,12 @@
 # limitations under the License.
 # ==============================================================================
 
-from .validation import _daal_check_array, _daal_check_X_y
+from .validation import (
+    _daal_check_array,
+    _daal_check_X_y,
+    check_n_features,
+    get_requires_y_tag,
+)
 
 
 def _daal_validate_data(
@@ -50,7 +55,7 @@ def _daal_validate_data(
     """
 
     if y is None:
-        if self._get_tags()["requires_y"]:
+        if get_requires_y_tag(self):
             raise ValueError(
                 f"This {self.__class__.__name__} estimator "
                 f"requires y to be passed, but the target y is None."
@@ -71,5 +76,5 @@ def _daal_validate_data(
         out = X, y
 
     if check_params.get("ensure_2d", True):
-        self._check_n_features(X, reset=reset)
+        check_n_features(self, X, reset=reset)
     return out

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/daal4py/sklearn/utils/validation.py

@@ -16,6 +16,7 @@
 
 import warnings
 from contextlib import suppress
+from functools import wraps
 
 import numpy as np
 import scipy.sparse as sp
@@ -49,6 +50,19 @@ from .._utils import (
     sklearn_check_version,
 )
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import (
+        _check_feature_names as _sklearn_check_feature_names,
+    )
+    from sklearn.utils.validation import _check_n_features as _sklearn_check_n_features
+    from sklearn.utils.validation import validate_data as _sklearn_validate_data
+else:
+    from sklearn.base import BaseEstimator
+
+    _sklearn_validate_data = BaseEstimator._validate_data
+    _sklearn_check_feature_names = BaseEstimator._check_feature_names
+    _sklearn_check_n_features = BaseEstimator._check_n_features
+
 
 def _assert_all_finite(
     X, allow_nan=False, msg_dtype=None, estimator_name=None, input_name=""
@@ -394,13 +408,19 @@ def _daal_check_array(
 
     if sp.issparse(array):
         _ensure_no_complex_data(array)
+        kwargs = {
+            "accept_sparse": accept_sparse,
+            "dtype": dtype,
+            "copy": copy,
+            "accept_large_sparse": accept_large_sparse,
+        }
+        if sklearn_check_version("1.6"):
+            kwargs["ensure_all_finite"] = force_all_finite
+        else:
+            kwargs["force_all_finite"] = force_all_finite
         array = _ensure_sparse_format(
             array,
-            accept_sparse=accept_sparse,
-            dtype=dtype,
-            copy=copy,
-            force_all_finite=force_all_finite,
-            accept_large_sparse=accept_large_sparse,
+            **kwargs,
         )
     else:
         # If np.array(..) gives ComplexWarning, then we convert the warning
@@ -694,3 +714,60 @@ def _daal_num_features(X):
         return len(first_sample)
     except Exception as err:
         raise TypeError(message) from err
+
+
+def get_requires_y_tag(estimator):
+    """Gets the value of the 'requires_y' tag from the estimator
+    using correct code path depending on the scikit-learn version."""
+    if sklearn_check_version("1.6"):
+        requires_y = estimator.__sklearn_tags__().target_tags.required
+    else:
+        try:
+            requires_y = estimator._get_tags()["requires_y"]
+        except KeyError:
+            requires_y = False
+    return requires_y
+
+
+def add_dispatcher_docstring(original_function):
+    """Adds a note about the dispatcher function to the docstring of the original function."""
+
+    def wrapper(dispatcher_function):
+        @wraps(
+            original_function,
+            ["__name__", "__doc__", "__annotations__", "__type_params__"],
+        )
+        def new_function(*args, **kwargs):
+            return dispatcher_function(*args, **kwargs)
+
+        new_function.__doc__ = (
+            f"Sklearnex dispatcher for '{original_function.__qualname__}' "
+            f"from '{original_function.__module__}' module supporting "
+            "it's multiple implementations from different scikit-learn versions.\n\n"
+            + original_function.__doc__
+        )
+
+        return new_function
+
+    return wrapper
+
+
+# simplified copy of similar function from sklearnex.utils.validation,
+# ensures that the correct finiteness check argument is used
+@add_dispatcher_docstring(_sklearn_validate_data)
+def validate_data(*args, **kwargs):
+    if not sklearn_check_version("1.6") and "ensure_all_finite" in kwargs:
+        kwargs["force_all_finite"] = kwargs.pop("ensure_all_finite")
+    return _sklearn_validate_data(*args, **kwargs)
+
+
+# dispatcher functions which use correct `check_feature_names`/`check_n_features` import
+# depending on the scikit-learn version
+@add_dispatcher_docstring(_sklearn_check_feature_names)
+def check_feature_names(*args, **kwargs):
+    _sklearn_check_feature_names(*args, **kwargs)
+
+
+@add_dispatcher_docstring(_sklearn_check_n_features)
+def check_n_features(*args, **kwargs):
+    _sklearn_check_n_features(*args, **kwargs)

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/onedal/__init__.py

@@ -1,83 +1,125 @@
-# ==============================================================================
-# Copyright 2021 Intel Corporation
-# Copyright 2024 Fujitsu Limited
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-
-import platform
-
-from daal4py.sklearn._utils import daal_check_version
-
-if "Windows" in platform.system():
-    import os
-    import site
-    import sys
-
-    arch_dir = platform.machine()
-    plt_dict = {"x86_64": "intel64", "AMD64": "intel64", "aarch64": "arm"}
-    arch_dir = plt_dict[arch_dir] if arch_dir in plt_dict else arch_dir
-    path_to_env = site.getsitepackages()[0]
-    path_to_libs = os.path.join(path_to_env, "Library", "bin")
-    if sys.version_info.minor >= 8:
-        if "DALROOT" in os.environ:
-            dal_root_redist = os.path.join(os.environ["DALROOT"], "redist", arch_dir)
-            if os.path.exists(dal_root_redist):
-                os.add_dll_directory(dal_root_redist)
-        try:
-            os.add_dll_directory(path_to_libs)
-        except FileNotFoundError:
-            pass
-    os.environ["PATH"] = path_to_libs + os.pathsep + os.environ["PATH"]
-
-try:
-    import onedal._onedal_py_dpc as _backend
-
-    _is_dpc_backend = True
-except ImportError:
-    import onedal._onedal_py_host as _backend
-
-    _is_dpc_backend = False
-
-_is_spmd_backend = False
-
-if _is_dpc_backend:
-    try:
-        import onedal._onedal_py_spmd_dpc as _spmd_backend
-
-        _is_spmd_backend = True
-    except ImportError:
-        _is_spmd_backend = False
-
-
-__all__ = ["covariance", "decomposition", "ensemble", "neighbors", "primitives", "svm"]
-
-if _is_spmd_backend:
-    __all__.append("spmd")
-
-if daal_check_version((2023, "P", 100)):
-    __all__ += ["basic_statistics", "linear_model"]
-
-    if _is_spmd_backend:
-        __all__ += [
-            "spmd.basic_statistics",
-            "spmd.decomposition",
-            "spmd.linear_model",
-            "spmd.neighbors",
-        ]
-
-if daal_check_version((2023, "P", 200)):
-    __all__ += ["cluster"]
-
-    if _is_spmd_backend:
-        __all__ += ["spmd.cluster"]
+# ==============================================================================
+# Copyright 2021 Intel Corporation
+# Copyright 2024 Fujitsu Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+import platform
+
+from daal4py.sklearn._utils import daal_check_version
+
+
+class Backend:
+    """Encapsulates the oneDAL pybind11 modules and provides a unified interface to it together with additional properties about dpc/spmd policies"""
+
+    def __init__(self, backend_module, is_dpc, is_spmd):
+        self.backend = backend_module
+        self.is_dpc = is_dpc
+        self.is_spmd = is_spmd
+
+    # accessing the instance will return the backend_module
+    def __getattr__(self, name):
+        return getattr(self.backend, name)
+
+    def __repr__(self) -> str:
+        return f"Backend({self.backend}, is_dpc={self.is_dpc}, is_spmd={self.is_spmd})"
+
+
+if "Windows" in platform.system():
+    import os
+    import site
+    import sys
+
+    arch_dir = platform.machine()
+    plt_dict = {"x86_64": "intel64", "AMD64": "intel64", "aarch64": "arm"}
+    arch_dir = plt_dict[arch_dir] if arch_dir in plt_dict else arch_dir
+    path_to_env = site.getsitepackages()[0]
+    path_to_libs = os.path.join(path_to_env, "Library", "bin")
+    if sys.version_info.minor >= 8:
+        if "DALROOT" in os.environ:
+            dal_root_redist = os.path.join(os.environ["DALROOT"], "redist", arch_dir)
+            if os.path.exists(dal_root_redist):
+                os.add_dll_directory(dal_root_redist)
+        try:
+            os.add_dll_directory(path_to_libs)
+        except FileNotFoundError:
+            pass
+    os.environ["PATH"] = path_to_libs + os.pathsep + os.environ["PATH"]
+
+
+try:
+    # use dpc backend if available
+    import onedal._onedal_py_dpc
+
+    _dpc_backend = Backend(onedal._onedal_py_dpc, is_dpc=True, is_spmd=False)
+
+    _host_backend = None
+except ImportError:
+    # fall back to host backend
+    _dpc_backend = None
+
+    import onedal._onedal_py_host
+
+    _host_backend = Backend(onedal._onedal_py_host, is_dpc=False, is_spmd=False)
+
+try:
+    # also load spmd backend if available
+    import onedal._onedal_py_spmd_dpc
+
+    _spmd_backend = Backend(onedal._onedal_py_spmd_dpc, is_dpc=True, is_spmd=True)
+except ImportError:
+    _spmd_backend = None
+
+# if/elif/else layout required for pylint to realize _default_backend cannot be None
+if _dpc_backend is not None:
+    _default_backend = _dpc_backend
+elif _host_backend is not None:
+    _default_backend = _host_backend
+else:
+    raise ImportError("No oneDAL backend available")
+
+# Core modules to export
+__all__ = [
+    "_host_backend",
+    "_default_backend",
+    "_dpc_backend",
+    "_spmd_backend",
+    "covariance",
+    "decomposition",
+    "ensemble",
+    "neighbors",
+    "primitives",
+    "svm",
+]
+
+# Additional features based on version checks
+if daal_check_version((2023, "P", 100)):
+    __all__ += ["basic_statistics", "linear_model"]
+if daal_check_version((2023, "P", 200)):
+    __all__ += ["cluster"]
+
+# Exports if SPMD backend is available
+if _spmd_backend is not None:
+    __all__ += ["spmd"]
+    if daal_check_version((2023, "P", 100)):
+        __all__ += [
+            "spmd.basic_statistics",
+            "spmd.decomposition",
+            "spmd.linear_model",
+            "spmd.neighbors",
+        ]
+    if daal_check_version((2023, "P", 200)):
+        __all__ += ["spmd.cluster"]
+
+__version__ = "2021.6"