aisp 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

aisp/__init__.py

@@ -1,4 +1,4 @@
 """Artificial Immune Systems Package."""
 
 __author__ = "João Paulo da Silva Barros"
-__version__ = "0.1.42"
+__version__ = "0.3.0"

aisp/base/__init__.py

@@ -1,5 +1,7 @@
 """Base class modules."""
 
 from ._classifier import BaseClassifier
+from ._clusterer import BaseClusterer
+from ._base import set_seed_numba
 
-__all__ = ['BaseClassifier']
+__all__ = ['BaseClassifier', 'BaseClusterer', 'set_seed_numba']

aisp/base/_base.py

@@ -0,0 +1,65 @@
+"""Base class for parameter introspection compatible with the scikit-learn API."""
+import random
+
+import numpy as np
+from numba import njit
+
+
+class Base:
+    """
+    Generic base class for models with a common interface.
+
+    Provides the ``get_params`` and ``set_params`` method for compatibility with
+    the scikit-learn API, allowing access to the model's public parameters.
+    """
+
+    def set_params(self, **params):
+        """
+        Set the parameters of the instance.
+
+        This method is required to ensure compatibility with scikit-learn functions
+
+        Parameters
+        ----------
+        **params
+            set as attributes on the instance.
+
+        Returns
+        -------
+        self
+        """
+        for key, value in params.items():
+            if not key.startswith("_") and hasattr(self, key):
+                setattr(self, key, value)
+        return self
+
+    def get_params(self, deep: bool = True) -> dict:  # pylint: disable=W0613
+        """
+        Return a dictionary with the object's main parameters.
+
+        This method is required to ensure compatibility with scikit-learn functions.
+
+        Returns
+        -------
+        dict
+            Dictionary containing the object's attributes that do not start with "_".
+        """
+        return {
+            key: value
+            for key, value in self.__dict__.items()
+            if not key.startswith("_")
+        }
+
+
+@njit(cache=True)
+def set_seed_numba(seed: int):
+    """
+    Set the seed for random numbers used by functions compiled with Numba.
+
+    Parameters
+    ----------
+    seed : int
+        Integer value used to initialize Numba's random number generator.
+    """
+    np.random.seed(seed)
+    random.seed(seed)

aisp/base/_classifier.py

@@ -5,15 +5,15 @@ from typing import Optional, Union
 
 import numpy.typing as npt
 
+from ._base import Base
 from ..utils import slice_index_list_by_class
 from ..utils.metrics import accuracy_score
 
 
-class BaseClassifier(ABC):
+class BaseClassifier(ABC, Base):
     """Base class for classification algorithms.
 
-    Defines the abstract methods ``fit`` and ``predict``, and implements the ``score``,
-    ``get_params`` method.
+    Defines the abstract methods ``fit`` and ``predict``, and implements the ``score`` method.
     """
 
     classes: Union[npt.NDArray, list] = []
@@ -106,15 +106,3 @@ class BaseClassifier(ABC):
             A dictionary with the list of array positions(``y``), with the classes as key.
         """
         return slice_index_list_by_class(self.classes, y)
-
-    def get_params(self, deep: bool = True) -> dict:  # pylint: disable=W0613
-        """
-        Return a dictionary with the object's main parameters.
-
-        This method is required to ensure compatibility with scikit-learn functions.
-        """
-        return {
-            key: value
-            for key, value in self.__dict__.items()
-            if not key.startswith("_")
-        }

aisp/base/_clusterer.py

@@ -0,0 +1,76 @@
+"""Base class for clustering algorithms."""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+import numpy.typing as npt
+
+from ._base import Base
+
+
+class BaseClusterer(ABC, Base):
+    """Abstract base class for clustering algorithms.
+
+    This class defines the core interface for clustering models. It enforces
+    the implementation of the `fit` and `predict` methods in all derived classes,
+    and provides a default implementation for `fit_predict` and `get_params`.
+    """
+
+    @abstractmethod
+    def fit(self, X: npt.NDArray, verbose: bool = True) -> "BaseClusterer":
+        """
+        Train the model using the input data X.
+
+        This abstract method is implemented by the class that inherits it.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Input data used for training the model.
+        verbose : bool, default=True
+            Flag to enable or disable detailed output during training.
+
+        Returns
+        -------
+        self : BaseClusterer
+            Returns the instance of the class that implements this method.
+        """
+
+    @abstractmethod
+    def predict(self, X: npt.NDArray) -> Optional[npt.NDArray]:
+        """
+        Generate predictions based on the input data X.
+
+        This abstract method is implemented by the class that inherits it.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Input data for which predictions will be generated.
+
+        Returns
+        -------
+        predictions : Optional[npt.NDArray]
+            Predicted cluster labels for each input sample, or None if prediction is not possible.
+        """
+
+    def fit_predict(self, X, verbose: bool = True):
+        """Fit the clustering model to the data and return cluster labels.
+
+        This is a convenience method that combines `fit` and `predict`
+        into a single call.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Input data for which predictions will be generated.
+        verbose : bool, default=True
+            Flag to enable or disable detailed output during training.
+
+        Returns
+        -------
+        predictions : Optional[npt.NDArray]
+            Predicted cluster labels for each input sample, or None if prediction is not possible.
+        """
+        self.fit(X, verbose)
+        return self.predict(X)

aisp/csa/__init__.py

@@ -3,7 +3,7 @@
 CSAs are inspired by the process of antibody proliferation upon detecting an antigen, during which
 the generated antibodies undergo mutations in an attempt to enhance pathogen recognition.
 """
-from ._ai_immune_recognition_sys import AIRS
+from ._ai_recognition_sys import AIRS
 
 __author__ = 'João Paulo da Silva Barros'
 __all__ = ['AIRS']

aisp/csa/{_ai_immune_recognition_sys.py → _ai_recognition_sys.py}

@@ -11,7 +11,7 @@ import numpy.typing as npt
 from scipy.spatial.distance import pdist
 from tqdm import tqdm
 
-
+from ..base import set_seed_numba
 from ._cell import Cell
 from ..utils.sanitizers import sanitize_param, sanitize_seed, sanitize_choice
 from ..utils.distance import hamming, compute_metric_distance, get_metric_code
@@ -178,6 +178,7 @@ class AIRS(BaseAIRS):
         self.seed: Optional[int] = sanitize_seed(seed)
         if self.seed is not None:
             np.random.seed(self.seed)
+            set_seed_numba(self.seed)
 
         self._feature_type: FeatureType = "continuous-features"
 
@@ -219,8 +220,6 @@ class AIRS(BaseAIRS):
         AIRS
             Returns the instance itself.
         """
-        progress = None
-
         self._feature_type = detect_vector_data_type(X)
 
         super()._check_and_raise_exceptions_fit(X, y)
@@ -234,18 +233,17 @@ class AIRS(BaseAIRS):
 
         self.classes = np.unique(y)
         sample_index = self._slice_index_list_by_class(y)
-        if verbose:
-            progress = tqdm(
-                total=len(y),
-                postfix="\n",
-                bar_format="{desc} ┇{bar}┇ {n}/{total} memory cells for each aᵢ",
-            )
+        progress = tqdm(
+            total=len(y),
+            postfix="\n",
+            disable=not verbose,
+            bar_format="{desc} ┇{bar}┇ {n}/{total} memory cells for each aᵢ",
+        )
         pool_cells_classes = {}
         for _class_ in self.classes:
-            if verbose and progress is not None:
-                progress.set_description_str(
-                    f"Generating the memory cells for the {_class_} class:"
-                )
+            progress.set_description_str(
+                f"Generating the memory cells for the {_class_} class:"
+            )
 
             x_class = X[sample_index[_class_]]
             # Calculating the similarity threshold between antigens
@@ -294,15 +292,14 @@ class AIRS(BaseAIRS):
                     if self._affinity(c_candidate.vector, c_match.vector) < sufficiently_similar:
                         pool_c.remove(c_match)
 
-                if verbose and progress is not None:
-                    progress.update(1)
+                progress.update(1)
             pool_cells_classes[_class_] = pool_c
 
-        if verbose and progress is not None:
-            progress.set_description(
-                f"\033[92m✔ Set of memory cells for classes ({', '.join(map(str, self.classes))}) "
-                f"successfully generated\033[0m"
-            )
+        progress.set_description(
+            f"\033[92m✔ Set of memory cells for classes ({', '.join(map(str, self.classes))}) "
+            f"successfully generated\033[0m"
+        )
+        progress.close()
         self._cells_memory = pool_cells_classes
         return self
 

aisp/ina/__init__.py

@@ -0,0 +1,14 @@
+"""Module (ina) Immune Network Algorithm.
+
+This module implements algorithms based on Network Theory Algorithms proposed by Jerne.
+
+Classes
+-------
+AiNet
+    Artificial Immune Network implementation for clustering.
+"""
+
+from ._ai_network import AiNet
+
+__author__ = 'João Paulo da Silva Barros'
+__all__ = ['AiNet']

aisp/ina/_ai_network.py

@@ -0,0 +1,553 @@
+"""Artificial Immune Network (AiNet)."""
+
+from collections import Counter
+from heapq import nlargest
+from typing import Optional
+
+import numpy as np
+import numpy.typing as npt
+from scipy.sparse.csgraph import minimum_spanning_tree, connected_components
+from scipy.spatial.distance import squareform, pdist, cdist
+from tqdm import tqdm
+
+from ._base import BaseAiNet
+from ..base import set_seed_numba
+from ..base.mutation import clone_and_mutate_binary, clone_and_mutate_continuous, \
+    clone_and_mutate_ranged
+from ..utils.sanitizers import sanitize_choice, sanitize_param, sanitize_seed
+from ..utils.distance import hamming, compute_metric_distance, get_metric_code
+from ..utils.types import FeatureType, MetricType
+from ..utils.validation import detect_vector_data_type
+
+
+class AiNet(BaseAiNet):
+    """Artificial Immune Network for Compression and Clustering .
+
+    This class implements the aiNet algorithm, an artificial immune network model designed for
+    clustering and data compression tasks. The aiNet algorithm uses principles from immune
+    network theory, clonal selection, and affinity maturation to compress high-dimensional
+    datasets. [1]_
+    For clustering, the class uses SciPy’s implementation of the **Minimum Spanning Tree**
+    (MST) to remove the most distant nodes and separate the groups. [2]_
+
+    Parameters
+    ----------
+    N : int, default=50
+        Number of memory cells (antibodies) in the population.
+    n_clone : int, default=10
+        Number of clones generated for each selected memory cell.
+    top_clonal_memory_size : Optional[int], default=5
+       Number of highest-affinity antibodies selected per antigen for cloning and mutation.
+       If set to None or 0, all antibodies are cloned, following the original aiNet algorithm.
+    n_diversity_injection : int, default=5
+        Number of new random memory cells injected to maintain diversity.
+    affinity_threshold : float, default=0.5
+        Threshold for affinity (similarity) to determine cell suppression or selection.
+    suppression_threshold : float, default=0.5
+        Threshold for suppressing similar memory cells.
+    mst_inconsistency_factor : float, default=2.0
+        Factor used to determine which edges in the **Minimum Spanning Tree (MST)**
+        are considered inconsistent.
+    max_iterations : int, default=10
+        Maximum number of training iterations.
+    k : int, default=3
+        The number of K nearest neighbors that will be used to choose a label in the prediction.
+    metric : Literal["manhattan", "minkowski", "euclidean"], default="euclidean"
+        Way to calculate the distance between the detector and the sample:
+
+        * ``'Euclidean'`` ➜ The calculation of the distance is given by the expression:
+            √( (x₁ – x₂)² + (y₁ – y₂)² + ... + (yn – yn)²).
+
+        * ``'minkowski'`` ➜ The calculation of the distance is given by the expression:
+            ( |X₁ – Y₁|p + |X₂ – Y₂|p + ... + |Xn – Yn|p) ¹/ₚ.
+
+        * ``'manhattan'`` ➜ The calculation of the distance is given by the expression:
+            ( |x₁ – x₂| + |y₁ – y₂| + ... + |yn – yn|).
+
+    seed : Optional[int]
+        Seed for the random generation of detector values. Defaults to None.
+    use_mst_clustering : bool, default=True
+        If ``True``, performs clustering with **Minimum Spanning Tree** (MST). If ``False``,
+        does not perform clustering and predict returns None.
+    **kwargs
+        p : float
+            This parameter stores the value of ``p`` used in the Minkowski distance. The default
+            is ``2``, which represents normalized Euclidean distance.\
+            Different values of p lead to different variants of the Minkowski Distance.
+
+    References
+    ----------
+    .. [1] de Castro, L. N., & Von Zuben, F. J. (2001).
+           *aiNet: An Artificial Immune Network for Data Analysis*.
+           Draft Chapter XII of the book *Data Mining: A Heuristic Approach*.
+           Department of Computer and Automation Engineering, University of Campinas.
+           Available at:
+             https://www.dca.fee.unicamp.br/~vonzuben/research/lnunes_dout/
+             artigos/DMHA.PDF
+    .. [2] SciPy Documentation. *Minimum Spanning Tree*.
+           https://docs.scipy.org/doc/scipy/reference/generated/
+           scipy.sparse.csgraph.minimum_spanning_tree
+    """
+
+    def __init__(
+        self,
+        N: int = 50,
+        n_clone: int = 10,
+        top_clonal_memory_size: int = 5,
+        n_diversity_injection: int = 5,
+        affinity_threshold: float = 0.5,
+        suppression_threshold: float = 0.5,
+        mst_inconsistency_factor: float = 2.0,
+        max_iterations: int = 10,
+        k: int = 3,
+        metric: MetricType = "euclidean",
+        seed: Optional[int] = None,
+        use_mst_clustering: bool = True,
+        **kwargs
+    ):
+        self.N: int = sanitize_param(N, 50, lambda x: x > 0)
+        self.n_clone: int = sanitize_param(n_clone, 10, lambda x: x > 0)
+        if top_clonal_memory_size is None:
+            self.top_clonal_memory_size: Optional[int] = None
+        else:
+            self.top_clonal_memory_size: Optional[int] = sanitize_param(
+                top_clonal_memory_size, 5, lambda x: x > 0
+            )
+
+        self.n_diversity_injection: int = sanitize_param(
+            n_diversity_injection, 5, lambda x: x > 0
+        )
+        self.affinity_threshold: float = sanitize_param(
+            affinity_threshold, 0.5, lambda x: x > 0
+        )
+        self.suppression_threshold: float = sanitize_param(
+            suppression_threshold, 0.5, lambda x: x > 0
+        )
+        self.mst_inconsistency_factor: float = sanitize_param(
+            mst_inconsistency_factor, 2, lambda x: x >= 0
+        )
+        self.max_iterations: int = sanitize_param(max_iterations, 10, lambda x: x > 0)
+        self.k: int = sanitize_param(k, 1, lambda x: x > 0)
+        self.seed: Optional[int] = sanitize_seed(seed)
+        self.use_mst_clustering: bool = use_mst_clustering
+        if self.seed is not None:
+            np.random.seed(self.seed)
+            set_seed_numba(self.seed)
+
+        self._feature_type: FeatureType = "continuous-features"
+        self.metric: str = sanitize_choice(
+            metric, ["euclidean", "manhattan", "minkowski"], "euclidean"
+        )
+        if self._feature_type == "binary-features":
+            self.metric = "hamming"
+
+        self.p: np.float64 = np.float64(kwargs.get("p", 2.0))
+        self._metric_params = {}
+        if self.metric == "minkowski":
+            self._metric_params['p'] = self.p
+        self.classes = []
+        self._memory_network: dict = {}
+        self._population_antibodies: Optional[npt.NDArray] = None
+        self._n_features: int = 0
+        self._bounds: Optional[npt.NDArray[np.float64]] = None
+        self._mst_structure: Optional[npt.NDArray] = None
+        self._mst_mean_distance: Optional[float] = None
+        self._mst_std_distance: Optional[float] = None
+        self._predict_cells = None
+        self._predict_labels = None
+
+    @property
+    def memory_network(self) -> dict:
+        """Return the immune network representing clusters or graph structure."""
+        return self._memory_network
+
+    @property
+    def population_antibodies(self) -> Optional[npt.NDArray]:
+        """Return the set of memory antibodies."""
+        return self._population_antibodies
+
+    @property
+    def mst(self) -> dict:
+        """Returns the Minimum Spanning Tree and its statistics."""
+        return {
+            'graph': self._mst_structure,
+            'mean_distance': self._mst_mean_distance,
+            'std_distance': self._mst_std_distance
+        }
+
+    def fit(self, X: npt.NDArray, verbose: bool = True):
+        """
+        Train the AiNet model on input data.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Input data used for training the model.
+        verbose : bool, default=True
+            Feedback from the progress bar showing current training interaction details.
+
+        Returns
+        -------
+        self : AiNet
+            Returns the instance of the class that implements this method.
+        """
+        self._feature_type = detect_vector_data_type(X)
+
+        super()._check_and_raise_exceptions_fit(X)
+
+        match self._feature_type:
+            case "binary-features":
+                X = X.astype(np.bool_)
+                self.metric = "hamming"
+            case "ranged-features":
+                self._bounds = np.vstack([np.min(X, axis=0), np.max(X, axis=0)])
+
+        self._n_features = X.shape[1]
+
+        progress = tqdm(
+            total=self.max_iterations,
+            postfix="\n",
+            disable=not verbose,
+            bar_format="{desc} ┇{bar}┇ {n}/{total} total training interactions",
+        )
+
+        population_p = self._init_population_antibodies()
+
+        t: int = 1
+        while t <= self.max_iterations:
+            pool_memory = []
+            permutations = np.random.permutation(X.shape[0])
+            for antigen in X[permutations]:
+                clonal_memory = self._select_and_clone_population(antigen, population_p)
+                pool_memory.extend(self._clonal_suppression(antigen, clonal_memory))
+            pool_memory = self._memory_suppression(pool_memory)
+
+            if t < self.max_iterations:
+                pool_memory.extend(self._diversity_introduction())
+            population_p = np.asarray(pool_memory)
+
+            progress.update(1)
+
+            t += 1
+        self._population_antibodies = population_p
+
+        if self.use_mst_clustering:
+            self._build_mst()
+            self.update_clusters()
+        progress.set_description(
+            f"\033[92m✔ Set of memory antibodies for classes "
+            f"({', '.join(map(str, self.classes))}) successfully generated | "
+            f"Clusters: {len(self.classes)} | Population of antibodies size: "
+            f"{len(self._population_antibodies)}\033[0m"
+        )
+        progress.close()
+
+        return self
+
+    def predict(self, X) -> Optional[npt.NDArray]:
+        """
+        Predict cluster labels for input data.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Data to predict.
+
+        Returns
+        -------
+        Predictions : Optional[npt.NDArray]
+            Predicted cluster labels, or None if clustering is disabled.
+        """
+        if not self.use_mst_clustering or self._memory_network is None:
+            return None
+
+        super()._check_and_raise_exceptions_predict(
+            X, self._n_features, self._feature_type
+        )
+
+        c: list = []
+
+        all_cells_memory = [
+            (class_name, cell)
+            for class_name in self.classes
+            for cell in self._memory_network[class_name]
+        ]
+
+        for line in X:
+            label_stim_list = [
+                (class_name, self._affinity(memory, line))
+                for class_name, memory in all_cells_memory
+            ]
+            # Create the list with the k nearest neighbors and select the class with the most votes
+            k_nearest = nlargest(self.k, label_stim_list, key=lambda x: x[1])
+            votes = Counter(label for label, _ in k_nearest)
+            c.append(votes.most_common(1)[0][0])
+        return np.array(c)
+
+    def _init_population_antibodies(self) -> npt.NDArray:
+        """
+        Initialize the antibody set of the network population randomly.
+
+        Returns
+        -------
+        npt.NDArray
+            List of initialized memories.
+        """
+        return self._generate_random_antibodies(
+            self.N,
+            self._n_features,
+            self._feature_type,
+            self._bounds
+        )
+
+    def _select_and_clone_population(
+        self,
+        antigen: npt.NDArray,
+        population: npt.NDArray
+    ) -> list:
+        """
+        Select top antibodies by affinity and generate mutated clones.
+
+        Parameters
+        ----------
+        antigen : npt.NDArray
+            The antigen for which affinities will be calculated.
+        population: list
+            The list of antibodies (solutions) to be evaluated and cloned.
+
+        Returns
+        -------
+        list[npt.NDArray]
+            List of mutated clones.
+        """
+        affinities = self._calculate_affinities(antigen, population)
+
+        if self.top_clonal_memory_size is not None and self.top_clonal_memory_size > 0:
+            selected_idxs = np.argsort(-affinities)[:self.top_clonal_memory_size]
+        else:
+            selected_idxs = np.arange(affinities.shape[0])
+
+        clonal_m = []
+        for i in selected_idxs:
+            clones = self._clone_and_mutate(
+                population[i],
+                int(self.n_clone * affinities[i])
+            )
+            clonal_m.extend(clones)
+
+        return clonal_m
+
+    def _clonal_suppression(self, antigen: npt.NDArray, clones: list):
+        """
+        Suppresses redundant clones based on affinity thresholds.
+
+        This function removes clones whose affinity with the antigen is lower than the defined
+        threshold (affinity_threshold) and eliminates redundant clones whose similarity with the
+        clones already selected exceeds the suppression threshold (suppression_threshold).
+
+        Parameters
+        ----------
+        antigen : npt.NDArray
+            The antigen for which affinities will be calculated.
+        clones : list
+            The list of candidate clones to be suppressed.
+
+        Returns
+        -------
+        list
+            Non-redundant, high-affinity clones.
+        """
+        suppression_affinity = [
+            clone for clone in clones
+            if self._affinity(clone, antigen) > self.affinity_threshold
+        ]
+        return self._memory_suppression(suppression_affinity)
+
+    def _memory_suppression(self, pool_memory: list) -> list:
+        """
+        Remove redundant antibodies from memory pool.
+
+        Calculate the affinity between all memory antibodies and remove redundant antibodies
+        whose similarity exceeds the suppression threshold.
+
+        Parameters
+        ----------
+        pool_memory : list
+            antibodies memory.
+
+        Returns
+        -------
+        list
+            Memory pool without redundant antibodies.
+        """
+        if not pool_memory:
+            return []
+        suppressed_memory = [pool_memory[0]]
+        for candidate in pool_memory[1:]:
+            affinities = self._calculate_affinities(
+                candidate.reshape(1, -1),
+                np.asarray(suppressed_memory)
+            )
+
+            if not np.any(affinities > self.suppression_threshold):
+                suppressed_memory.append(candidate)
+        return suppressed_memory
+
+    def _diversity_introduction(self):
+        """
+        Introduce diversity into the antibody population.
+
+        Returns
+        -------
+        npt.NDArray
+            Array of new random antibodies for diversity introduction.
+        """
+        return self._generate_random_antibodies(
+            self.n_diversity_injection,
+            self._n_features,
+            self._feature_type,
+            self._bounds
+        )
+
+    def _affinity(self, u: npt.NDArray, v: npt.NDArray) -> float:
+        """
+        Calculate the stimulus between two vectors using metrics.
+
+        Parameters
+        ----------
+        u : npt.NDArray
+            Coordinates of the first point.
+        v : npt.NDArray
+            Coordinates of the second point.
+
+        Returns
+        -------
+        float
+            Affinity score in [0, 1], where higher means more similar.
+        """
+        distance: float
+        if self._feature_type == "binary-features":
+            distance = hamming(u, v)
+        else:
+            distance = compute_metric_distance(
+                u, v, get_metric_code(self.metric), self.p
+            )
+
+        return 1 - (distance / (1 + distance))
+
+    def _calculate_affinities(self, u: npt.NDArray, v: npt.NDArray) -> npt.NDArray:
+        """
+        Calculate the affinity matrix between a reference vector and a set of target vectors.
+
+        Parameters
+        ----------
+        u : npt.NDArray
+            An array with shape (n_features).
+        v : npt.NDArray
+            An array of vectors with shape (n_samples, n_features).
+
+
+        Returns
+        -------
+        npt.NDArray
+            One-dimensional array of shape (n_samples,), containing the affinities between `u`
+            and each vector in `v`.
+        """
+        u = np.reshape(u, (1, -1))
+        v = np.atleast_2d(v)
+        distances = cdist(u, v, metric=self.metric, **self._metric_params)[0]
+
+        return 1 - (distances / (1 + distances))
+
+    def _clone_and_mutate(self, antibody: npt.NDArray, n_clone: int) -> npt.NDArray:
+        """
+        Generate mutated clones from an antibody, based on the feature type.
+
+        Parameters
+        ----------
+        antibody : npt.NDArray
+            Original antibody vector to be cloned and mutated.
+        n_clone : int
+            Number of clones to generate.
+
+        Returns
+        -------
+        npt.NDArray
+            Array of shape (n_clone, len(antibody)) containing mutated clones
+        """
+        if self._feature_type == "binary-features":
+            return clone_and_mutate_binary(antibody, n_clone)
+        if self._feature_type == "ranged-features" and self._bounds is not None:
+            return clone_and_mutate_ranged(antibody, n_clone, self._bounds)
+        return clone_and_mutate_continuous(antibody, n_clone)
+
+    def _build_mst(self):
+        """Construct the Minimum Spanning Tree (MST) for the antibody population.
+
+        Computes the pairwise distances between antibodies, builds the MST from
+        these distances, and stores the MST structure along with the mean and
+        standard deviation of its edge weights.
+
+        Raises
+        ------
+        ValueError
+            If the antibody population is empty.
+        """
+        if self._population_antibodies is None or len(self._population_antibodies) == 0:
+            raise ValueError("Population of antibodies is empty")
+
+        antibodies_matrix = squareform(
+            pdist(self._population_antibodies, metric=self.metric, **self._metric_params)
+        )
+        antibodies_mst = minimum_spanning_tree(antibodies_matrix).toarray()
+        self._mst_structure = antibodies_mst
+        nonzero_edges = antibodies_mst[antibodies_mst > 0]
+        self._mst_mean_distance = float(np.mean(nonzero_edges)) if nonzero_edges.size else 0.0
+        self._mst_std_distance = float(np.std(nonzero_edges)) if nonzero_edges.size else 0.0
+
+    def update_clusters(self, mst_inconsistency_factor: Optional[float] = None):
+        """Partition the clusters based on the MST inconsistency factor.
+
+        Uses the precomputed Minimum Spanning Tree (MST) of the antibody population
+        to redefine clusters. Edges whose weights exceed the mean plus the
+        `mst_inconsistency_factor` multiplied by the standard deviation of MST edge
+        weights are removed. Each connected component after pruning is treated as a
+        distinct cluster.
+
+        Parameters
+        ----------
+        mst_inconsistency_factor : float, optional
+            If provided, overrides the current inconsistency factor.
+
+        Raises
+        ------
+        ValueError
+            If the Minimum Spanning Tree (MST) has not yet been created
+
+        Updates
+        -------
+        self._memory_network : dict[int, npt.NDArray]
+            Dictionary mapping cluster labels to antibody arrays.
+        self.classes : list
+            List of cluster labels.
+        """
+        if self._mst_structure is None:
+            raise ValueError("The Minimum Spanning Tree (MST) has not yet been created.")
+
+        if mst_inconsistency_factor is not None:
+            self.mst_inconsistency_factor = mst_inconsistency_factor
+
+        antibodies_mst = self._mst_structure.copy()
+
+        thresholds = antibodies_mst > (
+            self._mst_mean_distance + self.mst_inconsistency_factor * self._mst_std_distance
+        )
+        antibodies_mst[thresholds] = 0
+
+        n_antibodies, labels = connected_components(csgraph=antibodies_mst, directed=False)
+
+        self._memory_network = {
+            label: self._population_antibodies[labels == label]
+            for label in range(n_antibodies)
+        }
+        self.classes = np.array(list(self._memory_network.keys()))

aisp/ina/_base.py

@@ -0,0 +1,124 @@
+"""Base Class for Network Theory Algorithms."""
+
+from abc import ABC
+from typing import Optional
+
+from numpy import typing as npt
+
+import numpy as np
+
+from ..base import BaseClusterer
+from ..exceptions import FeatureDimensionMismatch
+from ..utils.types import FeatureType
+
+
+class BaseAiNet(BaseClusterer, ABC):
+    """Abstract base class for AINet-based clustering algorithms."""
+
+    @staticmethod
+    def _check_and_raise_exceptions_fit(
+        X: npt.NDArray
+    ):
+        """
+        Verify the fit parameters and throw exceptions if the verification is not successful.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Training array, containing the samples and their characteristics,
+            [``N samples`` (rows)][``N features`` (columns)].
+
+        Raises
+        ------
+        TypeError
+            If X is not an ndarray or list.
+        """
+        if not isinstance(X, np.ndarray) and not isinstance(X, list):
+            raise TypeError("X is not an ndarray or list.")
+
+    @staticmethod
+    def _check_and_raise_exceptions_predict(
+        X: npt.NDArray,
+        expected: int = 0,
+        feature_type: FeatureType = "continuous-features"
+    ) -> None:
+        """
+        Verify the predict parameters and throw exceptions if the verification is not successful.
+
+        Parameters
+        ----------
+        X : npt.NDArray
+            Input array for prediction, containing the samples and their characteristics,
+            [``N samples`` (rows)][``N features`` (columns)].
+        expected : int, default=0
+            Expected number of features per sample (columns in X).
+        feature_type : FeatureType, default="continuous-features"
+            Specifies the type of features: "continuous-features", "binary-features",
+            or "ranged-features".
+
+
+        Raises
+        ------
+        TypeError
+            If X is not a ndarray or list.
+        FeatureDimensionMismatch
+            If the number of features in X does not match the expected number.
+        ValueError
+            If feature_type is "binary-features" and X contains values other than 0 and 1.
+        """
+        if not isinstance(X, (np.ndarray, list)):
+            raise TypeError("X is not an ndarray or list")
+        if expected != len(X[0]):
+            raise FeatureDimensionMismatch(
+                expected,
+                len(X[0]),
+                "X"
+            )
+
+        if feature_type != "binary-features":
+            return
+
+        # Checks if matrix X contains only binary samples. Otherwise, raises an exception.
+        if not np.isin(X, [0, 1]).all():
+            raise ValueError(
+                "The array X contains values that are not composed only of 0 and 1."
+            )
+
+    @staticmethod
+    def _generate_random_antibodies(
+        n_samples: int,
+        n_features: int,
+        feature_type: FeatureType = "continuous-features",
+        bounds: Optional[npt.NDArray[np.float64]] = None
+    ) -> npt.NDArray:
+        """
+        Generate a random antibody population.
+
+        Parameters
+        ----------
+        n_samples : int
+            Number of antibodies (samples) to generate.
+        n_features : int
+            Number of features (dimensions) for each antibody.
+        feature_type : FeatureType, default="continuous-features"
+            Specifies the type of features: "continuous-features", "binary-features",
+            or "ranged-features".
+        bounds : np.ndarray
+            Array (n_features, 2) with min and max per dimension.
+
+        Returns
+        -------
+        npt.NDArray
+            Array of shape (n_samples, n_features) containing the generated antibodies.
+            Data type depends on the feature_type type (float for continuous/ranged, bool for
+            binary).
+        """
+        if n_features <= 0:
+            raise ValueError("Number of features must be greater than zero.")
+
+        if feature_type == "binary-features":
+            return np.random.randint(0, 2, size=(n_samples, n_features)).astype(np.bool_)
+        if feature_type == "ranged-features" and bounds is not None:
+            return np.random.uniform(low=bounds[0], high=bounds[1], size=(n_samples, n_features))
+
+        return np.random.random_sample(size=(n_samples, n_features))

aisp/nsa/_negative_selection.py

@@ -6,6 +6,7 @@ from tqdm import tqdm
 import numpy as np
 import numpy.typing as npt
 
+from ..base import set_seed_numba
 from ._ns_core import (
     check_detector_bnsa_validity,
     bnsa_class_prediction,
@@ -98,6 +99,7 @@ class RNSA(BaseNSA):
         self.seed: Optional[int] = sanitize_seed(seed)
         if self.seed is not None:
             np.random.seed(seed)
+            set_seed_numba(self.seed)
         self.k: int = sanitize_param(k, 1, lambda x: x > 1)
         self.N: int = sanitize_param(N, 100, lambda x: x >= 1)
         self.r: float = sanitize_param(r, 0.05, lambda x: x > 0)
@@ -148,7 +150,6 @@ class RNSA(BaseNSA):
         self : RNSA
         Returns the instance itself.
         """
-        progress = None
         super()._check_and_raise_exceptions_fit(X, y)
 
         # Identifying the possible classes within the output array `y`.
@@ -158,22 +159,21 @@ class RNSA(BaseNSA):
         # Separates the classes for training.
         sample_index = self._slice_index_list_by_class(y)
         # Progress bar for generating all detectors.
-        if verbose:
-            progress = tqdm(
-                total=int(self.N * (len(self.classes))),
-                bar_format="{desc} ┇{bar}┇ {n}/{total} detectors",
-                postfix="\n",
-            )
+        progress = tqdm(
+            total=int(self.N * (len(self.classes))),
+            bar_format="{desc} ┇{bar}┇ {n}/{total} detectors",
+            postfix="\n",
+            disable=not verbose
+        )
         for _class_ in self.classes:
             # Initializes the empty set that will contain the valid detectors.
             valid_detectors_set = []
             discard_count = 0
             x_class = X[sample_index[_class_]]
             # Indicating which class the algorithm is currently processing for the progress bar.
-            if verbose and progress is not None:
-                progress.set_description_str(
-                    f"Generating the detectors for the {_class_} class:"
-                )
+            progress.set_description_str(
+                f"Generating the detectors for the {_class_} class:"
+            )
             while len(valid_detectors_set) < self.N:
                 # Generates a candidate detector vector randomly with values between 0 and 1.
                 vector_x = np.random.random_sample(size=X.shape[1])
@@ -188,8 +188,7 @@ class RNSA(BaseNSA):
                     else:
                         radius = None
                     valid_detectors_set.append(Detector(vector_x, radius))
-                    if verbose and progress is not None:
-                        progress.update(1)
+                    progress.update(1)
                 else:
                     discard_count += 1
                     if discard_count == self.max_discards:
@@ -198,11 +197,11 @@ class RNSA(BaseNSA):
             # Add detectors, with classes as keys in the dictionary.
             list_detectors_by_class[_class_] = valid_detectors_set
         # Notify completion of detector generation for the classes.
-        if verbose and progress is not None:
-            progress.set_description(
-                f"\033[92m✔ Non-self detectors for classes ({', '.join(map(str, self.classes))}) "
-                f"successfully generated\033[0m"
-            )
+        progress.set_description(
+            f"\033[92m✔ Non-self detectors for classes ({', '.join(map(str, self.classes))}) "
+            f"successfully generated\033[0m"
+        )
+        progress.close()
         # Saves the found detectors in the attribute for the non-self detectors of the trained model
         self._detectors = list_detectors_by_class
         return self
@@ -347,7 +346,6 @@ class RNSA(BaseNSA):
             knn[self.k - 1] = distance
             knn.sort()
 
-
     def __compare_sample_to_detectors(self, line: npt.NDArray) -> Optional[str]:
         """
         Compare a sample with the detectors, verifying if the sample is proper.
@@ -448,7 +446,7 @@ class RNSA(BaseNSA):
                 if (p - new_detector_r) < 0 or (p + new_detector_r) > 1:
                     return False
 
-        return (True, new_detector_r)
+        return True, new_detector_r
 
 
 class BNSA(BaseNSA):
@@ -534,7 +532,6 @@ class BNSA(BaseNSA):
              Returns the instance it self.
         """
         super()._check_and_raise_exceptions_fit(X, y, "BNSA")
-        progress = None
         # Converts the entire array X to boolean
         X = X.astype(np.bool_)
 
@@ -545,22 +542,22 @@ class BNSA(BaseNSA):
         # Separates the classes for training.
         sample_index: dict = self._slice_index_list_by_class(y)
         # Progress bar for generating all detectors.
-        if verbose:
-            progress = tqdm(
-                total=int(self.N * (len(self.classes))),
-                bar_format="{desc} ┇{bar}┇ {n}/{total} detectors",
-                postfix="\n",
-            )
+
+        progress = tqdm(
+            total=int(self.N * (len(self.classes))),
+            bar_format="{desc} ┇{bar}┇ {n}/{total} detectors",
+            postfix="\n",
+            disable=not verbose
+        )
 
         for _class_ in self.classes:
             # Initializes the empty set that will contain the valid detectors.
             valid_detectors_set: list = []
             discard_count: int = 0
             # Updating the progress bar with the current class the algorithm is processing.
-            if verbose and progress is not None:
-                progress.set_description_str(
-                    f"Generating the detectors for the {_class_} class:"
-                )
+            progress.set_description_str(
+                f"Generating the detectors for the {_class_} class:"
+            )
             x_class = X[sample_index[_class_]]
             while len(valid_detectors_set) < self.N:
                 # Generates a candidate detector vector randomly with values 0 and 1.
@@ -569,8 +566,7 @@ class BNSA(BaseNSA):
                 if check_detector_bnsa_validity(x_class, vector_x, self.aff_thresh):
                     discard_count = 0
                     valid_detectors_set.append(vector_x)
-                    if verbose and progress is not None:
-                        progress.update(1)
+                    progress.update(1)
                 else:
                     discard_count += 1
                     if discard_count == self.max_discards:
@@ -580,11 +576,11 @@ class BNSA(BaseNSA):
             list_detectors_by_class[_class_] = np.array(valid_detectors_set)
 
         # Notify the completion of detector generation for the classes.
-        if verbose and progress is not None:
-            progress.set_description(
-                f"\033[92m✔ Non-self detectors for classes ({', '.join(map(str, self.classes))}) "
-                f"successfully generated\033[0m"
-            )
+        progress.set_description(
+            f"\033[92m✔ Non-self detectors for classes ({', '.join(map(str, self.classes))}) "
+            f"successfully generated\033[0m"
+        )
+        progress.close()
         # Saves the found detectors in the attribute for the class detectors.
         self._detectors = list_detectors_by_class
         self._detectors_stack = np.array(

aisp/utils/distance.py

@@ -5,10 +5,10 @@ import numpy.typing as npt
 from numba import njit, types
 from numpy import float64
 
-EUCLIDEAN = 0
-MANHATTAN = 1
-MINKOWSKI = 2
-HAMMING = 3
+EUCLIDEAN: int = 0
+MANHATTAN: int = 1
+MINKOWSKI: int = 2
+HAMMING: int = 3
 
 
 @njit([(types.boolean[:], types.boolean[:])], cache=True)

aisp/utils/validation.py

@@ -14,9 +14,9 @@ def detect_vector_data_type(
     Detect the type of data in a vector.
 
     The function detects if the vector contains data of type:
-    - "binary": binary data (boolean True/False or integer 0/1)
-    - "continuous": continuous data between 0.0 and 1.0 (float)
-    - "ranged": numerical data with values outside the normalized range (float)
+    - Binary features: boolean values or integers restricted to 0 and 1.
+    - Continuous features: floating-point values in the normalized range [0.0, 1.0].
+    - Ranged features: floating-point values outside the normalized range.
 
     Parameters
     ----------
@@ -25,8 +25,8 @@ def detect_vector_data_type(
 
     Returns
     -------
-    Literal["binary-features", "continuous-features", "ranged-features"]
-        The classified data type of the vector.
+    str
+        The data type of the vector: "binary-features", "continuous-features", or "ranged-features".
 
     Raises
     ------

{aisp-0.2.1.dist-info → aisp-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisp
-Version: 0.2.1
+Version: 0.3.0
 Summary: Package with techniques of artificial immune systems.
 Author-email: João Paulo da Silva Barros <jpsilvabarr@gmail.com>
 Maintainer-email: Alison Zille Lopes <alisonzille@gmail.com>
@@ -84,10 +84,11 @@ Artificial Immune Systems (AIS) are inspired by the vertebrate immune system, cr
 ##### Algorithms implemented:
 
 > - [x] [**Negative Selection.**](https://ais-package.github.io/docs/aisp-techniques/Negative%20Selection/)
-> - [x] **Clonal Selection Algorithms.**
->     * [AIRS - Artificial Immune Recognition System](https://ais-package.github.io/docs/aisp-techniques/Clonal%20Selection%20Algorithms/)
-> - [ ] *Dendritic Cells.*
-> - [ ] *Immune Network Theory.*
+> - [x] [**Clonal Selection Algorithms.**](https://ais-package.github.io/docs/aisp-techniques/Clonal%20Selection%20Algorithms/)
+>     * [AIRS - Artificial Immune Recognition System](https://ais-package.github.io/docs/aisp-techniques/Clonal%20Selection%20Algorithms/airs/)
+> - [ ] *Danger Theory.*
+> - [x] [*Immune Network Theory.*](https://ais-package.github.io/docs/aisp-techniques/Immune%20Network%20Theory)
+>   - [AiNet - Artificial Immune Network para Clustering and Compression](https://ais-package.github.io/docs/aisp-techniques/Immune%20Network%20Theory/ainet)
 
 </section>
 

aisp-0.3.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+aisp/__init__.py,sha256=GUbFSuDKAfnn80xxK4giPZxuAakRl5dHC5gdp_WTJU0,111
+aisp/exceptions.py,sha256=I9JaQx6p8Jo7qjwwcrqnuewQgyBdUnOSSZofPoBeDNE,1954
+aisp/base/__init__.py,sha256=cDDN6YcYqSU080AvEankhUtIALkSTVmm6XTa48htHjU,211
+aisp/base/_base.py,sha256=uTVh__hQJGe8RCOzCet4ZV3vQbwgj5fXAt4Jdf0x1r0,1792
+aisp/base/_classifier.py,sha256=yGxRGhJxN8jIpr6S7_fsaEOCMPFws8rNCF4E-hYs37E,3339
+aisp/base/_clusterer.py,sha256=VKwhX8oHMc7ylsSu2jnbw3uar3GHc2AMSNPMEmwrPo0,2432
+aisp/base/mutation.py,sha256=A_AlGp8S4ooFEMW3Jgv0n0Y6tbhfusaMMWFsoH4HmD8,4762
+aisp/csa/__init__.py,sha256=708jwpqia10bqmh-4-_srwwNuBh7jf2Zix-u8Hfbzmk,348
+aisp/csa/_ai_recognition_sys.py,sha256=_niEark6HNsu9ognXussura16KeCw4mi3xU4Xm18hQo,18760
+aisp/csa/_base.py,sha256=jR1IIhGINn7DLo8V5iJinDn-wW-t6etcE39bAZnQylw,3595
+aisp/csa/_cell.py,sha256=GUxnzvPyIbBm1YYkMhSx0tcV_oyDhJ7wAo5gtr_1CoY,1845
+aisp/ina/__init__.py,sha256=cOnxGcxrBdg6lLv2w2sdlToMahKMh_Gw57AfUUPQjMo,329
+aisp/ina/_ai_network.py,sha256=aNXNWdFvgmjqki7-lWApLZWq5w1OVUuZpgxsnluiqNE,21053
+aisp/ina/_base.py,sha256=x9eFUKiAcXSfwqVyBVmS54FDeIcApEtFPGruZvwQOwQ,4404
+aisp/nsa/__init__.py,sha256=3cXuBmO-_Dp3-8ZG3Eu8e_bD1JDb-RH4Wu0UDNVD1bs,385
+aisp/nsa/_base.py,sha256=3YKlZzA3yhP2uQHfhyKswbHUutlxkOR4wn6N10nSO-w,4119
+aisp/nsa/_negative_selection.py,sha256=4FA0fwGVHpSsParsUUdNnnv0FYtJS4_olZBWWiPODk8,28153
+aisp/nsa/_ns_core.py,sha256=SXkZL-p2VQygU4Pf6J5AP_yPzU4cR6aU6wx-e_vlm-c,5021
+aisp/utils/__init__.py,sha256=RzpKhkg8nCZi4G0C4il97f3ESYs7Bbxq6EjTeOQQUGk,195
+aisp/utils/_multiclass.py,sha256=nWd58ayVfxgdopBQc9b_xywkolJ2fGW3AN-JoD2A9Fw,1134
+aisp/utils/distance.py,sha256=pY23YGZpu6qVCCkZfhaEpRazUULfVUy2piyzYuAryN0,6576
+aisp/utils/metrics.py,sha256=zDAScDbHRnfu24alRcZ6fEIUaWNoCD-QCtOCFBWPPo8,1277
+aisp/utils/sanitizers.py,sha256=u1GizdJ-RKfPWJLnuFiM09lpItZMhDR_EvK8YdVHwDk,1858
+aisp/utils/types.py,sha256=KELzr1kSBT7hHdsABoIS1xmEBGj6gRSH5A5YNG36I_c,1324
+aisp/utils/validation.py,sha256=RqcS2VdFXkNcOH_7Y3yPi7FBoGWR_ReLBPDBx0UMCqI,1431
+aisp-0.3.0.dist-info/licenses/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+aisp-0.3.0.dist-info/METADATA,sha256=hYtREi4OT36M5B0LgIKnnrzdQ1SZKwzYNdpIT-O7Hwg,5173
+aisp-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aisp-0.3.0.dist-info/top_level.txt,sha256=Q5aJi_rAVT5UNS1As0ZafoyS5dwNibnoyOYV7RWUB9s,5
+aisp-0.3.0.dist-info/RECORD,,

aisp-0.2.1.dist-info/RECORD

@@ -1,25 +0,0 @@
-aisp/__init__.py,sha256=N5aAyup46_tqU9cXfYfGuR3bdfAjcvaPc1xwFdGdD7A,112
-aisp/exceptions.py,sha256=I9JaQx6p8Jo7qjwwcrqnuewQgyBdUnOSSZofPoBeDNE,1954
-aisp/base/__init__.py,sha256=k2Ww9hej_32ekYhhCiYGEMLgOmDKwRt261HZ8rEurwA,102
-aisp/base/_classifier.py,sha256=Ud8VLE7vNh1ddpNNg0RVET2RXCd7kvzvfvNKHKNn_GM,3734
-aisp/base/mutation.py,sha256=A_AlGp8S4ooFEMW3Jgv0n0Y6tbhfusaMMWFsoH4HmD8,4762
-aisp/csa/__init__.py,sha256=cJSKkbvNTpR_CKCL--h99fNPiMf3fJ73gFnZRq7uyVM,355
-aisp/csa/_ai_immune_recognition_sys.py,sha256=_XqTHjqEO6sGZiIRlNNLe6Lz2PDFfDCtsbpucClvYmA,18878
-aisp/csa/_base.py,sha256=jR1IIhGINn7DLo8V5iJinDn-wW-t6etcE39bAZnQylw,3595
-aisp/csa/_cell.py,sha256=GUxnzvPyIbBm1YYkMhSx0tcV_oyDhJ7wAo5gtr_1CoY,1845
-aisp/nsa/__init__.py,sha256=3cXuBmO-_Dp3-8ZG3Eu8e_bD1JDb-RH4Wu0UDNVD1bs,385
-aisp/nsa/_base.py,sha256=3YKlZzA3yhP2uQHfhyKswbHUutlxkOR4wn6N10nSO-w,4119
-aisp/nsa/_negative_selection.py,sha256=aMdbIrd4TdPxaAkHHY-HbbM5kd5f81HbE3DyB73ttX4,28467
-aisp/nsa/_ns_core.py,sha256=SXkZL-p2VQygU4Pf6J5AP_yPzU4cR6aU6wx-e_vlm-c,5021
-aisp/utils/__init__.py,sha256=RzpKhkg8nCZi4G0C4il97f3ESYs7Bbxq6EjTeOQQUGk,195
-aisp/utils/_multiclass.py,sha256=nWd58ayVfxgdopBQc9b_xywkolJ2fGW3AN-JoD2A9Fw,1134
-aisp/utils/distance.py,sha256=pIt76OUiwCry6eNEuWLYvUiW4KkeU6egjjnnmroFet8,6556
-aisp/utils/metrics.py,sha256=zDAScDbHRnfu24alRcZ6fEIUaWNoCD-QCtOCFBWPPo8,1277
-aisp/utils/sanitizers.py,sha256=u1GizdJ-RKfPWJLnuFiM09lpItZMhDR_EvK8YdVHwDk,1858
-aisp/utils/types.py,sha256=KELzr1kSBT7hHdsABoIS1xmEBGj6gRSH5A5YNG36I_c,1324
-aisp/utils/validation.py,sha256=ya7Y_6Lv7L6LAHC11EAfZRqqneCsOqrjG8i2EQFZcpA,1418
-aisp-0.2.1.dist-info/licenses/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
-aisp-0.2.1.dist-info/METADATA,sha256=bhd0eOBVOuNN8gZ-jN3L4QWV17Qa0R2Kb-syKX5PK1U,4844
-aisp-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-aisp-0.2.1.dist-info/top_level.txt,sha256=Q5aJi_rAVT5UNS1As0ZafoyS5dwNibnoyOYV7RWUB9s,5
-aisp-0.2.1.dist-info/RECORD,,