smqtk_classifier 0.20.0__tar.gz

smqtk_classifier-0.20.0/LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright 2014-2019 Kitware, Inc.
+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 name of Kitware, Inc. nor the names of any 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 AUTHORS 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.

smqtk_classifier-0.20.0/PKG-INFO

@@ -0,0 +1,55 @@
+Metadata-Version: 2.1
+Name: smqtk_classifier
+Version: 0.20.0
+Summary: Algorithms, data structures and utilities around performing classificationof inputs.
+Home-page: https://github.com/Kitware/SMQTK-Classifier
+License: BSD-3-Clause
+Author: Kitware, Inc.
+Author-email: smqtk-developers@kitware.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Provides-Extra: libsvm
+Provides-Extra: sklearn
+Requires-Dist: libsvm-official (>=3.30,<3.31) ; extra == "libsvm"
+Requires-Dist: numpy (>=1.23.5,<2.0) ; python_version < "3.13"
+Requires-Dist: numpy (>=2.1) ; python_version >= "3.13"
+Requires-Dist: scikit-learn (>=1.6) ; extra == "sklearn"
+Requires-Dist: smqtk-core (>=0.20.0)
+Requires-Dist: smqtk-dataprovider (>=0.19.0)
+Requires-Dist: smqtk-descriptors (>=0.20)
+Project-URL: Documentation, https://smqtk-classifier.readthedocs.io/
+Project-URL: Repository, https://github.com/Kitware/SMQTK-Classifier
+Description-Content-Type: text/markdown
+
+# SMQTK - Classifier
+
+## Intent
+This package provides interfaces and implementations around the classification
+of inputs into some form of labeled probabilistic values.
+Additional data structure abstractions are defined here to standardize this
+behavior into common terms.
+
+## Documentation
+You can build the sphinx documentation locally for the most up-to-date
+reference:
+```bash
+# Install dependencies
+poetry install
+# Navigate to the documentation root.
+cd docs
+# Build the docs.
+poetry run make html
+# Open in your favorite browser!
+firefox _build/html/index.html
+```
+

smqtk_classifier-0.20.0/README.md

@@ -0,0 +1,21 @@
+# SMQTK - Classifier
+
+## Intent
+This package provides interfaces and implementations around the classification
+of inputs into some form of labeled probabilistic values.
+Additional data structure abstractions are defined here to standardize this
+behavior into common terms.
+
+## Documentation
+You can build the sphinx documentation locally for the most up-to-date
+reference:
+```bash
+# Install dependencies
+poetry install
+# Navigate to the documentation root.
+cd docs
+# Build the docs.
+poetry run make html
+# Open in your favorite browser!
+firefox _build/html/index.html
+```

smqtk_classifier-0.20.0/pyproject.toml

@@ -0,0 +1,103 @@
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+###############################################################################
+[tool.poetry]
+name = "smqtk_classifier"
+# REMEMBER: `distutils.version.*Version` types can be used to compare versions
+# from strings like this.
+# SMQTK prefers to use the strict numbering standard when possible.
+version = "0.20.0"
+description = """\
+    Algorithms, data structures and utilities around performing classification\
+    of inputs."""
+license = "BSD-3-Clause"
+authors = ["Kitware, Inc. <smqtk-developers@kitware.com>"]
+readme = "README.md"
+repository = "https://github.com/Kitware/SMQTK-Classifier"
+documentation = "https://smqtk-classifier.readthedocs.io/"
+classifiers = [
+        'Development Status :: 3 - Alpha',
+        'Intended Audience :: Developers',
+        'Intended Audience :: Science/Research',
+        'License :: OSI Approved :: BSD License',
+        'Operating System :: MacOS :: MacOS X',
+        'Operating System :: Unix',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+        'Programming Language :: Python :: 3.12',
+        'Programming Language :: Python :: 3.13',
+]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+numpy = [
+    # Without the hinge, Poetry fails to resolve for py3.13. 2.1 is the first version with py3.13 support.
+    {version = ">=1.23.5,<2.0", python = "<3.13" },
+    {version = ">=2.1", python = ">=3.13" }
+]
+smqtk-core = ">=0.20.0"
+smqtk-dataprovider = ">=0.19.0"
+smqtk-descriptors = ">=0.20"
+libsvm-official = {version = ">=3.30,<3.31", optional = true}
+scikit-learn = {version = ">=1.6", optional = true}
+
+[tool.poetry.extras]
+libsvm = [ "libsvm-official" ]
+sklearn = [ "scikit-learn" ]
+
+[tool.poetry.dev-dependencies]
+# CI
+flake8 = ">=6"
+flake8-mutable = ">=1.2"
+mypy = ">=0.991"
+# Docs
+# - Also see: `docs/readthedocs-reqs.txt` for use by RTD
+Sphinx = ">=5.3"
+sphinx-rtd-theme = ">=1.1.1"
+sphinx-argparse = ">=0.4"
+sphinx-prompt = ">=1.5"
+livereload = ">=2.6.3"
+# Testing
+coverage = ">=6.5"
+pytest = ">=7.2"
+pytest-cov = ">=4"
+# Development
+ipython = ">=8.6.0"
+
+[tool.poetry.plugins."smqtk_plugins"]
+# ClassificationElement
+"smqtk_classifier.impls.classification_element.file" = "smqtk_classifier.impls.classification_element.file"
+"smqtk_classifier.impls.classification_element.memory" = "smqtk_classifier.impls.classification_element.memory"
+"smqtk_classifier.impls.classification_element.postgres" = "smqtk_classifier.impls.classification_element.postgres"
+# Classify Descriptor
+"smqtk_classifier.impls.classify_descriptor.classify_index_label_descriptor" = "smqtk_classifier.impls.classify_descriptor.classify_index_label_descriptor"
+# Supervised
+"smqtk_classifier.impls.classify_descriptor_supervised.libsvm" = "smqtk_classifier.impls.classify_descriptor_supervised.libsvm"
+"smqtk_classifier.impls.classify_descriptor_supervised.sklearn_logistic_regression" = "smqtk_classifier.impls.classify_descriptor_supervised.sklearn_logistic_regression"
+"smqtk_classifier.impls.classify_descriptor_supervised.sklearn_svm" = "smqtk_classifier.impls.classify_descriptor_supervised.sklearn_svm"
+
+###############################################################################
+[tool.pytest.ini_options]
+addopts = [
+    "-lv",                            # Show local in trace-backs.
+    "--doctest-modules",              # Increased verbosity.
+    "--tb=long",                      # Trace-back print mode.
+    "--cov=./smqtk_classifier",       # Cover our package specifically
+    "--cov=./tests",                  # Also cover our tests for dead spots
+    "--cov-report=term",              # Coverage report to terminal
+    "--cov-report=xml:coverage.xml"   # For external tool reporting
+]
+testpaths = [
+    "tests",
+    "smqtk_classifier",
+]
+norecursedirs = [
+    "tests/data"
+]
+doctest_optionflags = [
+    "NORMALIZE_WHITESPACE",
+    "IGNORE_EXCEPTION_DETAIL",
+]

smqtk_classifier-0.20.0/smqtk_classifier/__init__.py

@@ -0,0 +1,9 @@
+from .interfaces.classification_element import ClassificationElement  # noqa: F401
+from .interfaces.classify_descriptor import ClassifyDescriptor  # noqa: F401
+from .interfaces.classify_descriptor_supervised import ClassifyDescriptorSupervised  # noqa: F401
+from .interfaces.classify_image import ClassifyImage  # noqa: F401
+from .interfaces.classify_image_supervised import ClassifyImageSupervised  # noqa: F401
+
+from .classification_element_factory import ClassificationElementFactory  # noqa: F401
+from .classify_descriptor_collection import ClassifyDescriptorCollection  # noqa: F401
+from .classify_descriptor_collection import ClassifierCollection  # noqa: F401

smqtk_classifier-0.20.0/smqtk_classifier/_defaults.py

@@ -0,0 +1,8 @@
+from smqtk_classifier.classification_element_factory import ClassificationElementFactory
+from smqtk_classifier.impls.classification_element.memory import MemoryClassificationElement
+
+
+# Default classifier element factory for interfaces.
+DFLT_CLASSIFIER_FACTORY = ClassificationElementFactory(
+    MemoryClassificationElement, {}
+)

smqtk_classifier-0.20.0/smqtk_classifier/classification_element_factory.py

@@ -0,0 +1,116 @@
+from typing import Any, Dict, Hashable, Type, TypeVar
+
+from smqtk_core import Configurable
+from smqtk_core.configuration import (
+    cls_conf_from_config_dict,
+    cls_conf_to_config_dict,
+    make_default_config
+)
+from smqtk_core.dict import merge_dict
+
+from smqtk_classifier.interfaces.classification_element import ClassificationElement
+
+
+C = TypeVar("C", bound=ClassificationElement)
+
+
+class ClassificationElementFactory (Configurable):
+    """
+    Factory class for producing ClassificationElement instances of a specified
+    type and configuration.
+    """
+
+    # noinspection PyShadowingBuiltins
+    def __init__(self, type: Type[C], type_config: Dict[str, Any]):
+        """
+        Initialize the factory to produce ClassificationElement instances of the
+        given type from the given configuration.
+
+        :param type: Python implementation type of the ClassifierElement to
+            produce
+        :param type_config: Configuration dictionary that will be passed
+            ``from_config`` class method of given ``type``.
+        """
+        self.type = type
+        self.type_config = type_config
+
+    #
+    # Class methods
+    #
+
+    @classmethod
+    def get_default_config(cls) -> Dict[str, Any]:
+        """
+        Generate and return a default configuration dictionary for this class.
+        This will be primarily used for generating what the configuration
+        dictionary would look like for this class without instantiating it.
+
+        It is not be guaranteed that the configuration dictionary returned
+        from this method is valid for construction of an instance of this class.
+
+        :return: Default configuration dictionary for the class.
+        :rtype: dict
+
+        """
+        return make_default_config(ClassificationElement.get_impls())
+
+    # We likely do not expect subclasses for this type base, thus it is OK to
+    # use direct type reference in Type and return annotations.
+    @classmethod
+    def from_config(
+        cls: Type["ClassificationElementFactory"],
+        config_dict: Dict,
+        merge_default: bool = True
+    ) -> "ClassificationElementFactory":
+        """
+        Instantiate a new instance of this class given the configuration
+        JSON-compliant dictionary encapsulating initialization arguments.
+
+        This method should not be called via super unless and instance of the
+        class is desired.
+
+        :param config_dict: JSON compliant dictionary encapsulating
+            a configuration.
+        :param merge_default: Merge the given configuration on top of the
+            default provided by ``get_default_config``.
+
+        :return: Constructed instance from the provided config.
+        """
+        if merge_default:
+            config_dict = merge_dict(cls.get_default_config(), config_dict)
+
+        ce_type, ce_conf = cls_conf_from_config_dict(
+            config_dict,  ClassificationElement.get_impls()
+        )
+        return ClassificationElementFactory(ce_type, ce_conf)
+
+    def get_config(self) -> Dict[str, Any]:
+        return cls_conf_to_config_dict(self.type, self.type_config)
+
+    # noinspection PyShadowingBuiltins
+    def new_classification(self, type: str, uuid: Hashable) -> ClassificationElement:
+        """
+        Create a new ClassificationElement instance of the configured
+        implementation.
+
+        :param type: Type of classifier. This is usually the name of the
+            classifier that generated this result.
+        :param uuid: UUID to associate with the classification.
+
+        :return: New ClassificationElement instance.
+        """
+        return self.type.from_config(self.type_config, type, uuid)
+
+    # noinspection PyShadowingBuiltins
+    def __call__(self, type: str, uuid: Hashable) -> ClassificationElement:
+        """
+        Create a new ClassificationElement instance of the configured
+        implementation.
+
+        :param type: Type of classifier. This is usually the name of the
+            classifier that generated this result.
+        :param uuid: UUID to associate with the classification.
+
+        :return: New ClassificationElement instance.
+        """
+        return self.new_classification(type, uuid)

smqtk_classifier-0.20.0/smqtk_classifier/classify_descriptor_collection.py

@@ -0,0 +1,298 @@
+import threading
+from typing import Any, Dict, Hashable, Iterable, List, Optional, Mapping, Sequence, Set, Type
+from types import TracebackType
+from warnings import warn
+import numpy as np
+
+from smqtk_core.configuration import (
+    Configurable,
+    make_default_config,
+    from_config_dict,
+    to_config_dict
+)
+from smqtk_core.dict import merge_dict
+from smqtk_descriptors import DescriptorElement
+
+from smqtk_classifier.classification_element_factory import ClassificationElementFactory
+from smqtk_classifier.exceptions import MissingLabelError
+from smqtk_classifier.interfaces.classification_element import ClassificationElement
+
+from ._defaults import DFLT_CLASSIFIER_FACTORY
+from .interfaces.classify_descriptor import ClassifyDescriptor
+
+
+class ClassifyDescriptorCollection (Configurable):
+    """
+    A collection of descriptively-labeled classifier instances for the purpose
+    of applying all stored classifiers to one or more input descriptor
+    elements.
+
+    TODO: [optionally?] map a classification element factory per classifier.
+
+    :param classifiers: Optional dictionary of semantic label keys and
+        Classifier instance values.
+    :param labeled_classifiers: Key-word arguments may be provided where
+        the key used is considered the semantic label of the provided
+        Classifier instance.
+    """
+
+    EXAMPLE_KEY = '__example_label__'
+
+    def __init__(
+            self,
+            classifiers: Mapping[str, ClassifyDescriptor] | None = None,
+            **labeled_classifiers: ClassifyDescriptor
+    ):
+        self._label_to_classifier_lock = threading.RLock()
+        self._label_to_classifier = {}
+
+        # Go though classifiers map and key-word arguments, check that values
+        # are actually classifiers.
+        if classifiers is not None:
+            for label, classifier in classifiers.items():
+                if not isinstance(classifier, ClassifyDescriptor):
+                    raise ValueError("Found a non-Classifier instance value "
+                                     "for key '%s'" % label)
+                self._label_to_classifier[label] = classifier
+
+        for label, classifier in labeled_classifiers.items():
+            if not isinstance(classifier, ClassifyDescriptor):
+                raise ValueError("Found a non-Classifier instance value "
+                                 "for key '%s'" % label)
+            elif label in self._label_to_classifier:
+                raise ValueError("Duplicate classifier label '%s' provided "
+                                 "in key-word arguments." % label)
+            self._label_to_classifier[label] = classifier
+
+    @classmethod
+    def get_default_config(cls) -> Dict[str, Any]:
+        c = super(ClassifyDescriptorCollection, cls).get_default_config()
+
+        # We list the label-classifier mapping on one level, so remove the
+        # nested map parameter that can optionally be used in the constructor.
+        del c['classifiers']
+
+        # Add slot of a list of classifier plugin specifications
+        c[cls.EXAMPLE_KEY] = make_default_config(ClassifyDescriptor.get_impls())
+
+        return c
+
+    # We likely do not expect subclasses for this type base, thus it is OK to
+    # use direct type reference in Type and return annotations.
+    @classmethod
+    def from_config(
+        cls,
+        config_dict: Dict,
+        merge_default: bool = True
+    ) -> "ClassifyDescriptorCollection":
+        if merge_default:
+            config_dict = merge_dict(cls.get_default_config(), config_dict)
+
+        classifier_map = {}
+
+        # Copying list of keys so we can update the dictionary as we loop.
+        for label in list(config_dict.keys()):
+            # Skip the example section.
+            if label == cls.EXAMPLE_KEY:
+                continue
+
+            classifier_config = config_dict[label]
+            classifier = from_config_dict(classifier_config,
+                                          ClassifyDescriptor.get_impls())
+            classifier_map[label] = classifier
+
+        return cls(classifiers=classifier_map)
+
+    def get_config(self) -> Dict[str, Any]:
+        with self._label_to_classifier_lock:
+            c = dict((label, to_config_dict(classifier))
+                     for label, classifier
+                     in self._label_to_classifier.items())
+        return c
+
+    def __enter__(self) -> "ClassifyDescriptorCollection":
+        """
+        :rtype: IqrSession
+        """
+        self._label_to_classifier_lock.acquire()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType]
+    ) -> None:
+        self._label_to_classifier_lock.release()
+
+    def size(self) -> int:
+        with self._label_to_classifier_lock:
+            return len(self._label_to_classifier)
+
+    __len__ = size
+
+    def labels(self) -> Set[str]:
+        """
+        :return: Set of labels for currently collected classifiers.
+        """
+        with self._label_to_classifier_lock:
+            return set(self._label_to_classifier.keys())
+
+    def add_classifier(self, label: str, classifier: ClassifyDescriptor) -> "ClassifyDescriptorCollection":
+        """
+        Add a classifier instance with associated descriptive label to this
+        collection.
+
+        :param label: String descriptive label for the classifier.
+        :param classifier: Classifier instance to collect.
+
+        :raises ValueError: Classifier provided is not actually a classifier
+            instance, or if the label provided already exists in this
+            collection.
+
+        :return: Self.
+        """
+        if not isinstance(classifier, ClassifyDescriptor):
+            raise ValueError("Not given a Classifier instance (given type"
+                             " %s)." % type(classifier))
+        with self._label_to_classifier_lock:
+            if label in self._label_to_classifier:
+                raise ValueError("Duplicate label provided: '%s'" % label)
+            self._label_to_classifier[label] = classifier
+        return self
+
+    def get_classifier(self, label: str) -> ClassifyDescriptor:
+        """
+        Get the classifier instance for a given label.
+
+        :param label: Label of the classifier to get.
+
+        :raises KeyError: No classifier for the given label.
+
+        :return: Classifier instance.
+        """
+        with self._label_to_classifier_lock:
+            return self._label_to_classifier[label]
+
+    def remove_classifier(self, label: str) -> "ClassifyDescriptorCollection":
+        """
+        Remove a label-classifier pair from this collection.
+
+        :param label: Label of the classifier to remove.
+
+        :raises KeyError: The given label does not reference a classifier in
+            this collection.
+
+        :return: Self.
+        """
+        with self._label_to_classifier_lock:
+            del self._label_to_classifier[label]
+        return self
+
+    def labels_to_classifiers(self, labels: Optional[Iterable[str]] = None) -> Dict[str, ClassifyDescriptor]:
+        """
+        Get a shallow copy mapping of classifiers for the labels given, or for
+        all classifiers if no labels were explicitly given.
+
+        This method is thread-safe and the returned dictionary is separate from
+        this class's control. However, the classifier instances are still
+        shared.
+
+        :param None | typing.Iterable[str] labels:
+            One or more labels of stored classifiers to retrieve.
+            If None, we will consider all stored classifiers.
+
+        :raises MissingLabelError: Thrown when one or more labels provided do
+            not associate to any currently stored classifiers.
+
+        :return: Dictionary mapping string labels to Classifier instances.
+        """
+        with self._label_to_classifier_lock:
+            if labels is not None:
+                labels = list(labels)
+                # If we're missing some of the requested labels, complain
+                missing_labels = set(labels) - self.labels()
+                if missing_labels:
+                    raise MissingLabelError(missing_labels)
+                label2classifier = {label: self._label_to_classifier[label]
+                                    for label in labels}
+            else:
+                label2classifier = dict(self._label_to_classifier)
+        return label2classifier
+
+    def classify(
+        self,
+        descriptor: DescriptorElement,
+        labels: Optional[Iterable[str]] = None,
+        factory: ClassificationElementFactory = DFLT_CLASSIFIER_FACTORY,
+        overwrite: bool = False
+    ) -> Dict[str, ClassificationElement]:
+        """
+        Apply all stored classifiers to the given descriptor element.
+
+        We return a dictionary mapping the label of a stored classifier to the
+        classifier element result produced by that classifier via the
+        provided classification element factory.
+
+        :param descriptor: Descriptor element to classify.
+        :param labels: One or more labels of stored classifiers to use for
+            classifying the given descriptor.  If None, use all stored
+            classifiers.
+        :param factory: Classification element factory.
+        :param overwrite: Force re-computation of the classification of the
+            input descriptor.
+
+        :raises smqtk.exceptions.MissingLabelError: Some or all of the
+            requested labels are missing.
+
+        :return: Result dictionary of classifier labels to classification
+            elements.
+        """
+        d_classifications = {}
+        label2classifier = self.labels_to_classifiers(labels)
+        for label, classifier in label2classifier.items():
+            d_classifications[label] = classifier.classify_one_element(
+                descriptor, factory=factory, overwrite=overwrite
+            )
+        return d_classifications
+
+    def classify_arrays(
+        self,
+        array_seq: Sequence[np.ndarray],
+        labels: Sequence[str] | None = None
+    ) -> Dict[str, List[Dict[Hashable, float]]]:
+        """
+        Apply all stored classifiers to the given iterable or matrix of numpy
+        arrays.
+
+        We return a dictionary mapping the label of a stored classifier to the
+        class-confidence map result produced by that classifier's
+        `classify_arrays` method.
+
+        :param Sequence[numpy.ndarray] array_seq:
+            Sequence of descriptor vectors, as numpy arrays, to be classified.
+        :param Sequence[str] labels:
+            One or more labels of stored classifiers to use for classifying the
+            given descriptors.  If None (the default), use all stored
+            classifiers.
+
+        :raises MissingLabelError: Thrown when one or more labels provided do
+            not associate to any currently stored classifiers.
+
+        :return: Dictionary of result predictions for each classifier.
+        :rtype: dict[str, list[dict[collections.abc.Hashable, float]]]
+        """
+        label2classifier = self.labels_to_classifiers(labels)
+        label2pred = {}
+        for label, classifier in label2classifier.items():
+            label2pred[label] = list(classifier.classify_arrays(array_seq))
+        return label2pred
+
+
+class ClassifierCollection(ClassifyDescriptorCollection):
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        warn("ClassifierCollection was renamed to "
+             "ClassifyDescriptorCollection", category=DeprecationWarning,
+             stacklevel=2)
+        super().__init__(*args, **kwargs)

smqtk_classifier-0.20.0/smqtk_classifier/exceptions.py

@@ -0,0 +1,29 @@
+from typing import Set
+
+
+class NoClassificationError (Exception):
+    """
+    When a ClassificationElement has no mapping yet set, but an operation
+    required it.
+    """
+
+
+class MissingLabelError(Exception):
+    """
+    Raised by ClassifyDescriptorCollection.classify when requested classifier
+    labels are missing from collection.
+    """
+    def __init__(self, labels: Set[str]):
+        """
+        :param labels: The labels missing from the collection
+        """
+        super(MissingLabelError, self).__init__(labels)
+        self.labels = labels
+
+
+class ExistingModelError(Exception):
+    """
+    Raised by ClassifyDescriptorSupervised and ClassifyImageSupervised when
+    a model already exists in an instance to prevent overwriting and existing
+    model
+    """