pyFOCI 0.1.2__py3-none-any.whl

pyFOCI/__init__.py

@@ -0,0 +1,10 @@
+# Authors: scikit-learn-contrib developers
+# License: BSD 3 clause
+
+from ._template import TemplateTransformer
+from ._version import __version__
+
+__all__ = [
+    "TemplateTransformer",
+    "__version__",
+]

pyFOCI/_template.py

@@ -0,0 +1,97 @@
+"""
+This is a module to be used as a reference for building other modules
+"""
+
+# Authors: scikit-learn-contrib developers
+# License: BSD 3 clause
+
+import numpy as np
+from sklearn.base import BaseEstimator, TransformerMixin, _fit_context
+
+# from sklearn.utils.validation import check_is_fitted
+
+
+# Note that the mixin class should always be on the left of `BaseEstimator` to ensure
+# the MRO works as expected.
+class TemplateTransformer(TransformerMixin, BaseEstimator):
+    """An example transformer that returns the element-wise square root.
+
+    For more information regarding how to build your own transformer, read more
+    in the :ref:`User Guide <user_guide>`.
+
+    Parameters
+    ----------
+    demo_param : str, default='demo'
+        A parameter used for demonstation of how to pass and store paramters.
+
+    Attributes
+    ----------
+    n_features_in_ : int
+        Number of features seen during :term:`fit`.
+
+    feature_names_in_ : ndarray of shape (`n_features_in_`,)
+        Names of features seen during :term:`fit`. Defined only when `X`
+        has feature names that are all strings.
+    """
+
+    # This is a dictionary allowing to define the type of parameters.
+    # It used to validate parameter within the `_fit_context` decorator.
+    _parameter_constraints = {
+        "demo_param": [str],
+    }
+
+    def __init__(self, demo_param="demo"):
+        self.demo_param = demo_param
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(self, X, y=None):
+        """A reference implementation of a fitting function for a transformer.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix}, shape (n_samples, n_features)
+            The training input samples.
+
+        y : None
+            There is no need of a target in a transformer, yet the pipeline API
+            requires this parameter.
+
+        Returns
+        -------
+        self : object
+            Returns self.
+        """
+        X = self._validate_data(X, accept_sparse=True)
+
+        # Return the transformer
+        return self
+
+    def transform(self, X):
+        """A reference implementation of a transform function.
+
+        Parameters
+        ----------
+        X : {array-like, sparse-matrix}, shape (n_samples, n_features)
+            The input samples.
+
+        Returns
+        -------
+        X_transformed : array, shape (n_samples, n_features)
+            The array containing the element-wise square roots of the values
+            in ``X``.
+        """
+        # Since this is a stateless transformer, we should not call `check_is_fitted`.
+        # Common test will check for this particularly.
+
+        # Input validation
+        # We need to set reset=False because we don't want to overwrite `n_features_in_`
+        # `feature_names_in_` but only check that the shape is consistent.
+        X = self._validate_data(X, accept_sparse=True, reset=False)
+        return np.sqrt(X)
+
+    def _more_tags(self):
+        # This is a quick example to show the tags API:\
+        # https://scikit-learn.org/dev/developers/develop.html#estimator-tags
+        # Here, our transformer does not do any operation in `fit` and only validate
+        # the parameters. Thus, it is stateless.
+        return {"stateless": True}

pyFOCI/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.2'
+__version_tuple__ = version_tuple = (0, 1, 2)
+
+__commit_id__ = commit_id = None

pyFOCI/tests/__init__.py

@@ -0,0 +1,2 @@
+# Authors: scikit-learn-contrib developers
+# License: BSD 3 clause

pyFOCI/tests/test_common.py

@@ -0,0 +1,16 @@
+"""This file shows how to write test based on the scikit-learn common tests."""
+
+# Authors: scikit-learn-contrib developers
+# License: BSD 3 clause
+
+from sklearn.utils.estimator_checks import parametrize_with_checks
+
+from pyFOCI.utils.discovery import all_estimators
+
+
+# parametrize_with_checks allows to get a generator of check that is more fine-grained
+# than check_estimator
+@parametrize_with_checks([est() for _, est in all_estimators()])
+def test_estimators(estimator, check, request):
+    """Check the compatibility with scikit-learn API"""
+    check(estimator)

pyFOCI/tests/test_template.py

@@ -0,0 +1,31 @@
+"""This file will just show how to write tests for the template classes."""
+import numpy as np
+import pytest
+from sklearn.datasets import load_iris
+from sklearn.utils._testing import assert_allclose
+
+from pyFOCI import TemplateTransformer
+
+# Authors: scikit-learn-contrib developers
+# License: BSD 3 clause
+
+
+@pytest.fixture
+def data():
+    return load_iris(return_X_y=True)
+
+
+def test_template_transformer(data):
+    """Check the internals and behaviour of `TemplateTransformer`."""
+    X, y = data
+    trans = TemplateTransformer()
+    assert trans.demo_param == "demo"
+
+    trans.fit(X)
+    assert trans.n_features_in_ == X.shape[1]
+
+    X_trans = trans.transform(X)
+    assert_allclose(X_trans, np.sqrt(X))
+
+    X_trans = trans.fit_transform(X)
+    assert_allclose(X_trans, np.sqrt(X))

pyFOCI/utils/__init__.py

@@ -0,0 +1,2 @@
+# Authors: scikit-learn-contrib developers
+# License: BSD 3 clause

pyFOCI/utils/discovery.py

@@ -0,0 +1,207 @@
+"""
+The :mod:`pyFOCI.utils.discovery` module includes utilities to discover
+objects (i.e. estimators, displays, functions) from the `pyFOCI` package.
+"""
+
+# Adapted from scikit-learn
+# Authors: scikit-learn-contrib developers
+# License: BSD 3 clause
+
+import inspect
+import pkgutil
+from importlib import import_module
+from operator import itemgetter
+from pathlib import Path
+
+from sklearn.base import (
+    BaseEstimator,
+    ClassifierMixin,
+    ClusterMixin,
+    RegressorMixin,
+    TransformerMixin,
+)
+from sklearn.utils._testing import ignore_warnings
+
+_MODULE_TO_IGNORE = {"tests"}
+
+
+def all_estimators(type_filter=None):
+    """Get a list of all estimators from `pyFOCI`.
+
+    This function crawls the module and gets all classes that inherit
+    from `BaseEstimator`. Classes that are defined in test-modules are not
+    included.
+
+    Parameters
+    ----------
+    type_filter : {"classifier", "regressor", "cluster", "transformer"} \
+            or list of such str, default=None
+        Which kind of estimators should be returned. If None, no filter is
+        applied and all estimators are returned.  Possible values are
+        'classifier', 'regressor', 'cluster' and 'transformer' to get
+        estimators only of these specific types, or a list of these to
+        get the estimators that fit at least one of the types.
+
+    Returns
+    -------
+    estimators : list of tuples
+        List of (name, class), where ``name`` is the class name as string
+        and ``class`` is the actual type of the class.
+
+    Examples
+    --------
+    >>> from pyFOCI.utils.discovery import all_estimators
+    >>> estimators = all_estimators()
+    >>> type(estimators)
+    <class 'list'>
+    """
+
+    def is_abstract(c):
+        return hasattr(c, "__abstractmethods__") and len(c.__abstractmethods__)
+
+    all_classes = []
+    root = str(Path(__file__).parent.parent)  # pyFOCI package
+    # Ignore deprecation warnings triggered at import time and from walking
+    # packages
+    with ignore_warnings(category=FutureWarning):
+        for _, module_name, _ in pkgutil.walk_packages(path=[root], prefix="pyFOCI."):
+            module_parts = module_name.split(".")
+            if any(part in _MODULE_TO_IGNORE for part in module_parts):
+                continue
+            module = import_module(module_name)
+            classes = inspect.getmembers(module, inspect.isclass)
+            classes = [
+                (name, est_cls) for name, est_cls in classes if not name.startswith("_")
+            ]
+
+            all_classes.extend(classes)
+
+    all_classes = set(all_classes)
+
+    estimators = [
+        c
+        for c in all_classes
+        if (issubclass(c[1], BaseEstimator) and c[0] != "BaseEstimator")
+    ]
+    # get rid of abstract base classes
+    estimators = [c for c in estimators if not is_abstract(c[1])]
+
+    if type_filter is not None:
+        if not isinstance(type_filter, list):
+            type_filter = [type_filter]
+        else:
+            type_filter = list(type_filter)  # copy
+        filtered_estimators = []
+        filters = {
+            "classifier": ClassifierMixin,
+            "regressor": RegressorMixin,
+            "transformer": TransformerMixin,
+            "cluster": ClusterMixin,
+        }
+        for name, mixin in filters.items():
+            if name in type_filter:
+                type_filter.remove(name)
+                filtered_estimators.extend(
+                    [est for est in estimators if issubclass(est[1], mixin)]
+                )
+        estimators = filtered_estimators
+        if type_filter:
+            raise ValueError(
+                "Parameter type_filter must be 'classifier', "
+                "'regressor', 'transformer', 'cluster' or "
+                "None, got"
+                f" {repr(type_filter)}."
+            )
+
+    # drop duplicates, sort for reproducibility
+    # itemgetter is used to ensure the sort does not extend to the 2nd item of
+    # the tuple
+    return sorted(set(estimators), key=itemgetter(0))
+
+
+def all_displays():
+    """Get a list of all displays from `pyFOCI`.
+
+    Returns
+    -------
+    displays : list of tuples
+        List of (name, class), where ``name`` is the display class name as
+        string and ``class`` is the actual type of the class.
+
+    Examples
+    --------
+    >>> from pyFOCI.utils.discovery import all_displays
+    >>> displays = all_displays()
+    """
+    all_classes = []
+    root = str(Path(__file__).parent.parent)  # pyFOCI package
+    # Ignore deprecation warnings triggered at import time and from walking
+    # packages
+    with ignore_warnings(category=FutureWarning):
+        for _, module_name, _ in pkgutil.walk_packages(path=[root], prefix="pyFOCI."):
+            module_parts = module_name.split(".")
+            if any(part in _MODULE_TO_IGNORE for part in module_parts):
+                continue
+            module = import_module(module_name)
+            classes = inspect.getmembers(module, inspect.isclass)
+            classes = [
+                (name, display_class)
+                for name, display_class in classes
+                if not name.startswith("_") and name.endswith("Display")
+            ]
+            all_classes.extend(classes)
+
+    return sorted(set(all_classes), key=itemgetter(0))
+
+
+def _is_checked_function(item):
+    if not inspect.isfunction(item):
+        return False
+
+    if item.__name__.startswith("_"):
+        return False
+
+    mod = item.__module__
+    if not mod.startswith("pyFOCI.") or mod.endswith("estimator_checks"):
+        return False
+
+    return True
+
+
+def all_functions():
+    """Get a list of all functions from `pyFOCI`.
+
+    Returns
+    -------
+    functions : list of tuples
+        List of (name, function), where ``name`` is the function name as
+        string and ``function`` is the actual function.
+
+    Examples
+    --------
+    >>> from pyFOCI.utils.discovery import all_functions
+    >>> functions = all_functions()
+    """
+    all_functions = []
+    root = str(Path(__file__).parent.parent)  # pyFOCI package
+    # Ignore deprecation warnings triggered at import time and from walking
+    # packages
+    with ignore_warnings(category=FutureWarning):
+        for _, module_name, _ in pkgutil.walk_packages(path=[root], prefix="pyFOCI."):
+            module_parts = module_name.split(".")
+            if any(part in _MODULE_TO_IGNORE for part in module_parts):
+                continue
+
+            module = import_module(module_name)
+            functions = inspect.getmembers(module, _is_checked_function)
+            functions = [
+                (func.__name__, func)
+                for name, func in functions
+                if not name.startswith("_")
+            ]
+            all_functions.extend(functions)
+
+    # drop duplicates, sort for reproducibility
+    # itemgetter is used to ensure the sort does not extend to the 2nd item of
+    # the tuple
+    return sorted(set(all_functions), key=itemgetter(0))

pyFOCI/utils/tests/__init__.py

@@ -0,0 +1,2 @@
+# Authors: scikit-learn-contrib developers
+# License: BSD 3 clause

pyFOCI/utils/tests/test_discovery.py

@@ -0,0 +1,31 @@
+# Authors: scikit-learn-contrib developers
+# License: BSD 3 clause
+
+import pytest
+
+from pyFOCI.utils.discovery import all_displays, all_estimators, all_functions
+
+
+def test_all_estimators():
+    estimators = all_estimators()
+    assert len(estimators) == 1
+
+    estimators = all_estimators(type_filter="classifier")
+    assert len(estimators) == 0
+
+    estimators = all_estimators(type_filter=["classifier", "transformer"])
+    assert len(estimators) == 1
+
+    err_msg = "Parameter type_filter must be"
+    with pytest.raises(ValueError, match=err_msg):
+        all_estimators(type_filter="xxxx")
+
+
+def test_all_displays():
+    displays = all_displays()
+    assert len(displays) == 0
+
+
+def test_all_functions():
+    functions = all_functions()
+    assert len(functions) == 3

pyfoci-0.1.2.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: pyFOCI
+Version: 0.1.2
+Summary: A template for scikit-learn compatible packages.
+Author-email: Robert Pollak <robert.pollak@jku.at>
+Project-URL: Homepage, https://github.com/scikit-learn-contrib/pyFOCI
+Project-URL: Issues, https://github.com/scikit-learn-contrib/pyFOCI/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: scikit-learn>=1.4.2
+Requires-Dist: numpy
+Dynamic: license-file
+
+pyFOCI - A template for scikit-learn contributions
+============================================================
+
+![tests](https://github.com/m3dm-jku/pyFOCI/actions/workflows/python-app.yml/badge.svg)
+[![codecov](https://codecov.io/gh/m3dm-jku/pyFOCI/graph/badge.svg?token=L0XPWwoPLw)](https://codecov.io/gh/m3dm-jku/pyFOCI)
+![doc](https://github.com/m3dm-jku/pyFOCI/actions/workflows/deploy-gh-pages.yml/badge.svg)
+
+**pyFOCI** is a template project for [scikit-learn](https://scikit-learn.org)
+compatible extensions.
+
+It aids development of estimators that can be used in scikit-learn pipelines and
+(hyper)parameter search, while facilitating testing (including some API compliance),
+documentation, open source development, packaging, and continuous integration.
+
+Refer to the documentation to modify the template for your own scikit-learn
+contribution: https://m3dm-jku.github.io/pyFOCI/
+
+*Thank you for cleanly contributing to the scikit-learn ecosystem!*

pyfoci-0.1.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+pyFOCI/__init__.py,sha256=LYC65o81QAJLGG-tg4_nBBMoibYPceEvHc-sf3FWybY,206
+pyFOCI/_template.py,sha256=DWW6uFD35drYsfg3peBR5ITHcxhH-IoiL2DrymP_LQ4,3252
+pyFOCI/_version.py,sha256=Q6ScJXlkBsUI-cazSvpYPMyIVUB-Vd0R3pq3_rM1wmI,520
+pyFOCI/tests/__init__.py,sha256=OLs978IP7BWkfydS9GzMQg4oPPAsQl9dEfxS2iQD9nI,67
+pyFOCI/tests/test_common.py,sha256=495dtSmqcMcDf_sKVPa3daaaQbOhSXoOlApxNfkqwcM,569
+pyFOCI/tests/test_template.py,sha256=axZXhXw6xhWchUK7AJNiSEpNSN-J8gW5oqRc36HxCqI,790
+pyFOCI/utils/__init__.py,sha256=OLs978IP7BWkfydS9GzMQg4oPPAsQl9dEfxS2iQD9nI,67
+pyFOCI/utils/discovery.py,sha256=pvuOT4FsEgJyb17GaMt0_YeLgNBbUdWrNB3p3DI9XDU,6925
+pyFOCI/utils/tests/__init__.py,sha256=OLs978IP7BWkfydS9GzMQg4oPPAsQl9dEfxS2iQD9nI,67
+pyFOCI/utils/tests/test_discovery.py,sha256=fUYuWf_7mQin3r-AB3IQUhkeDDcLQ6FA7UvOC_rWha4,775
+pyfoci-0.1.2.dist-info/licenses/LICENSE,sha256=HNmyx4jx1L81VhLt28JSV5MVbHVpb8xXOqx475vPl2I,1495
+pyfoci-0.1.2.dist-info/METADATA,sha256=dh4cPUILRyBxEWY5Zsxlys5zMwEMZNtNMdLQgbkMJCE,1895
+pyfoci-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+pyfoci-0.1.2.dist-info/top_level.txt,sha256=PuXEIncLIBHOETKKrnkjvF8s30Rr-6iywGsxBlUF08E,7
+pyfoci-0.1.2.dist-info/RECORD,,

pyfoci-0.1.2.dist-info/WHEEL

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

pyfoci-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2026, Johannes Kepler University Linz
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of pyFOCI nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

pyfoci-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyFOCI