explainiverse 0.1.1a1__py3-none-any.whl → 0.2.0__py3-none-any.whl

explainiverse/explainers/rule_based/anchors_wrapper.py

@@ -0,0 +1,350 @@
+# src/explainiverse/explainers/rule_based/anchors_wrapper.py
+"""
+Anchors Explainer - High-precision rule-based explanations.
+
+Anchors are if-then rules that "anchor" a prediction, meaning the prediction
+remains the same regardless of other features' values (with high probability).
+
+Reference:
+    Ribeiro, M.T., Singh, S., & Guestrin, C. (2018). Anchors: High-Precision
+    Model-Agnostic Explanations. AAAI 2018.
+"""
+
+import numpy as np
+from typing import List, Optional, Tuple, Dict, Any
+from itertools import combinations
+from explainiverse.core.explainer import BaseExplainer
+from explainiverse.core.explanation import Explanation
+
+
+class AnchorsExplainer(BaseExplainer):
+    """
+    Anchors explainer for rule-based explanations.
+    
+    Generates if-then rules that explain individual predictions with
+    high precision (the rule holds with high probability). Uses beam search
+    to efficiently explore the space of possible anchors, optimizing for
+    both precision (rule reliability) and coverage (rule generality).
+    
+    The algorithm:
+    1. Discretizes continuous features into interpretable bins
+    2. Uses beam search to find minimal feature subsets (anchors)
+    3. Evaluates precision via perturbation sampling
+    4. Returns the shortest anchor meeting the precision threshold
+    
+    Attributes:
+        model: Model adapter with .predict() method
+        training_data: Reference data for generating perturbations
+        feature_names: List of feature names
+        class_names: List of class names
+        threshold: Minimum precision for the anchor (default: 0.95)
+        n_samples: Number of samples for precision estimation (default: 1000)
+        beam_size: Number of candidates in beam search (default: 4)
+    """
+    
+    def __init__(
+        self,
+        model,
+        training_data: np.ndarray,
+        feature_names: List[str],
+        class_names: List[str],
+        threshold: float = 0.95,
+        n_samples: int = 1000,
+        beam_size: int = 4,
+        max_anchor_size: int = None,
+        discretizer: str = "quartile",
+        random_state: int = 42
+    ):
+        """
+        Initialize the Anchors explainer.
+        
+        Args:
+            model: Model adapter with .predict() method
+            training_data: Reference data (n_samples, n_features)
+            feature_names: List of feature names
+            class_names: List of class names
+            threshold: Minimum precision for a valid anchor
+            n_samples: Number of perturbation samples
+            beam_size: Number of candidates to keep in beam search
+            max_anchor_size: Maximum number of conditions in anchor
+            discretizer: How to discretize continuous features ("quartile", "decile")
+            random_state: Random seed
+        """
+        super().__init__(model)
+        self.training_data = np.array(training_data)
+        self.feature_names = list(feature_names)
+        self.class_names = list(class_names)
+        self.threshold = threshold
+        self.n_samples = n_samples
+        self.beam_size = beam_size
+        self.max_anchor_size = max_anchor_size or len(feature_names)
+        self.discretizer = discretizer
+        self.random_state = random_state
+        self.rng = np.random.RandomState(random_state)
+        
+        # Pre-compute feature statistics for discretization
+        self._compute_discretization()
+    
+    def _compute_discretization(self):
+        """Pre-compute discretization bins for each feature."""
+        self.bins = {}
+        self.bin_labels = {}
+        
+        if self.discretizer == "quartile":
+            percentiles = [25, 50, 75]
+        elif self.discretizer == "decile":
+            percentiles = list(range(10, 100, 10))
+        else:
+            percentiles = [25, 50, 75]
+        
+        for idx in range(self.training_data.shape[1]):
+            values = self.training_data[:, idx]
+            bins = np.percentile(values, percentiles)
+            bins = np.unique(bins)  # Remove duplicates
+            self.bins[idx] = bins
+            
+            # Create human-readable labels
+            labels = []
+            if len(bins) == 0:
+                labels = [f"{self.feature_names[idx]} = any"]
+            else:
+                labels.append(f"{self.feature_names[idx]} <= {bins[0]:.2f}")
+                for i in range(len(bins) - 1):
+                    labels.append(f"{bins[i]:.2f} < {self.feature_names[idx]} <= {bins[i+1]:.2f}")
+                labels.append(f"{self.feature_names[idx]} > {bins[-1]:.2f}")
+            self.bin_labels[idx] = labels
+    
+    def _discretize_value(self, value: float, feature_idx: int) -> int:
+        """Discretize a single value into a bin index."""
+        bins = self.bins[feature_idx]
+        if len(bins) == 0:
+            return 0
+        return int(np.searchsorted(bins, value))
+    
+    def _discretize_instance(self, instance: np.ndarray) -> np.ndarray:
+        """Discretize an entire instance."""
+        return np.array([
+            self._discretize_value(instance[i], i)
+            for i in range(len(instance))
+        ])
+    
+    def _get_condition_label(self, feature_idx: int, bin_idx: int) -> str:
+        """Get human-readable label for a condition."""
+        labels = self.bin_labels[feature_idx]
+        if bin_idx < len(labels):
+            return labels[bin_idx]
+        return f"{self.feature_names[feature_idx]} in bin {bin_idx}"
+    
+    def _generate_perturbations(
+        self,
+        instance: np.ndarray,
+        anchor: List[int],
+        n_samples: int
+    ) -> np.ndarray:
+        """
+        Generate perturbation samples that respect the anchor conditions.
+        
+        Args:
+            instance: Original instance
+            anchor: List of feature indices that are fixed
+            n_samples: Number of samples to generate
+            
+        Returns:
+            Array of perturbed samples
+        """
+        perturbations = np.zeros((n_samples, len(instance)))
+        
+        # Discretize the instance
+        disc_instance = self._discretize_instance(instance)
+        
+        for i in range(n_samples):
+            # Start with random sample from training data
+            sample_idx = self.rng.randint(len(self.training_data))
+            sample = self.training_data[sample_idx].copy()
+            
+            # Fix anchor features to match the instance's bin
+            for feat_idx in anchor:
+                # Find values in training data that fall in the same bin
+                target_bin = disc_instance[feat_idx]
+                bins = self.bins[feat_idx]
+                
+                # Get values in the same bin from training data
+                if len(bins) == 0:
+                    # Use original value if no bins
+                    sample[feat_idx] = instance[feat_idx]
+                else:
+                    # Sample from values in the same bin
+                    feature_values = self.training_data[:, feat_idx]
+                    in_bin = np.array([
+                        self._discretize_value(v, feat_idx) == target_bin
+                        for v in feature_values
+                    ])
+                    if np.any(in_bin):
+                        valid_values = feature_values[in_bin]
+                        sample[feat_idx] = self.rng.choice(valid_values)
+                    else:
+                        sample[feat_idx] = instance[feat_idx]
+            
+            perturbations[i] = sample
+        
+        return perturbations
+    
+    def _compute_precision(
+        self,
+        instance: np.ndarray,
+        anchor: List[int],
+        target_class: int
+    ) -> Tuple[float, int]:
+        """
+        Compute the precision of an anchor.
+        
+        Precision = P(prediction = target_class | anchor conditions hold)
+        
+        Returns:
+            Tuple of (precision, coverage_count)
+        """
+        perturbations = self._generate_perturbations(
+            instance, anchor, self.n_samples
+        )
+        
+        predictions = self.model.predict(perturbations)
+        
+        if predictions.ndim == 2:
+            pred_classes = np.argmax(predictions, axis=1)
+        else:
+            pred_classes = predictions
+        
+        matches = np.sum(pred_classes == target_class)
+        precision = matches / len(pred_classes)
+        
+        return precision, matches
+    
+    def _compute_coverage(self, anchor: List[int], instance: np.ndarray) -> float:
+        """
+        Compute the coverage of an anchor (fraction of data matching conditions).
+        """
+        disc_instance = self._discretize_instance(instance)
+        
+        matches = 0
+        for sample in self.training_data:
+            disc_sample = self._discretize_instance(sample)
+            if all(disc_sample[i] == disc_instance[i] for i in anchor):
+                matches += 1
+        
+        return matches / len(self.training_data)
+    
+    def _beam_search(
+        self,
+        instance: np.ndarray,
+        target_class: int
+    ) -> Tuple[List[int], float, float]:
+        """
+        Use beam search to find the best anchor.
+        
+        Returns:
+            Tuple of (anchor_features, precision, coverage)
+        """
+        n_features = len(instance)
+        
+        # Start with empty anchor
+        candidates = [
+            ([], 1.0, 1.0)  # (anchor, precision, coverage)
+        ]
+        
+        best_anchor = ([], 0.0, 1.0)
+        
+        for _ in range(self.max_anchor_size):
+            new_candidates = []
+            
+            for anchor, _, _ in candidates:
+                # Try adding each unused feature
+                for feat_idx in range(n_features):
+                    if feat_idx in anchor:
+                        continue
+                    
+                    new_anchor = anchor + [feat_idx]
+                    precision, _ = self._compute_precision(
+                        instance, new_anchor, target_class
+                    )
+                    coverage = self._compute_coverage(new_anchor, instance)
+                    
+                    new_candidates.append((new_anchor, precision, coverage))
+                    
+                    # Check if this is a valid anchor
+                    if precision >= self.threshold:
+                        if coverage > best_anchor[2] or \
+                           (coverage == best_anchor[2] and len(new_anchor) < len(best_anchor[0])):
+                            best_anchor = (new_anchor, precision, coverage)
+            
+            if not new_candidates:
+                break
+            
+            # Keep top candidates by precision (prefer smaller anchors for ties)
+            new_candidates.sort(
+                key=lambda x: (x[1], -len(x[0]), x[2]),
+                reverse=True
+            )
+            candidates = new_candidates[:self.beam_size]
+            
+            # Early stopping if we found a good anchor
+            if best_anchor[1] >= self.threshold:
+                # Check if we can improve coverage
+                can_improve = any(c[1] >= self.threshold and c[2] > best_anchor[2] 
+                                  for c in candidates)
+                if not can_improve:
+                    break
+        
+        if best_anchor[0]:
+            return best_anchor
+        elif candidates:
+            # Return best candidate even if below threshold
+            return max(candidates, key=lambda x: x[1])
+        else:
+            return ([], 0.0, 1.0)
+    
+    def explain(self, instance: np.ndarray, **kwargs) -> Explanation:
+        """
+        Generate an anchor explanation for the given instance.
+        
+        Args:
+            instance: The instance to explain (1D array)
+            
+        Returns:
+            Explanation object with anchor rules
+        """
+        instance = np.array(instance).flatten()
+        
+        # Get the model's prediction
+        predictions = self.model.predict(instance.reshape(1, -1))
+        if predictions.ndim == 2:
+            target_class = np.argmax(predictions[0])
+        else:
+            target_class = int(predictions[0])
+        
+        target_name = self.class_names[target_class] if target_class < len(self.class_names) else f"class_{target_class}"
+        
+        # Find anchor using beam search
+        anchor_features, precision, coverage = self._beam_search(instance, target_class)
+        
+        # Convert to human-readable rules
+        disc_instance = self._discretize_instance(instance)
+        rules = [
+            self._get_condition_label(feat_idx, int(disc_instance[feat_idx]))
+            for feat_idx in anchor_features
+        ]
+        
+        return Explanation(
+            explainer_name="Anchors",
+            target_class=target_name,
+            explanation_data={
+                "rules": rules,
+                "precision": float(precision),
+                "coverage": float(coverage),
+                "anchor_features": [self.feature_names[i] for i in anchor_features],
+                "anchor_indices": anchor_features,
+                "feature_attributions": {
+                    self.feature_names[i]: 1.0 / (idx + 1)
+                    for idx, i in enumerate(anchor_features)
+                } if anchor_features else {}
+            }
+        )

explainiverse-0.2.0.dist-info/METADATA

@@ -0,0 +1,264 @@
+Metadata-Version: 2.1
+Name: explainiverse
+Version: 0.2.0
+Summary: Unified, extensible explainability framework supporting LIME, SHAP, Anchors, Counterfactuals, PDP, ALE, SAGE, and more
+Home-page: https://github.com/jemsbhai/explainiverse
+License: MIT
+Keywords: xai,explainability,interpretability,machine-learning,lime,shap,anchors
+Author: Muntaser Syed
+Author-email: jemsbhai@gmail.com
+Requires-Python: >=3.10,<3.13
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Dist: lime (>=0.2.0.1,<0.3.0.0)
+Requires-Dist: numpy (>=1.24,<2.0)
+Requires-Dist: scikit-learn (>=1.1,<1.6)
+Requires-Dist: scipy (>=1.10,<2.0)
+Requires-Dist: shap (>=0.48.0,<0.49.0)
+Requires-Dist: xgboost (>=1.7,<3.0)
+Project-URL: Repository, https://github.com/jemsbhai/explainiverse
+Description-Content-Type: text/markdown
+
+# Explainiverse
+
+**Explainiverse** is a unified, extensible Python framework for Explainable AI (XAI).  
+It provides a standardized interface for model-agnostic explainability with 8 state-of-the-art XAI methods, evaluation metrics, and a plugin registry for easy extensibility.
+
+---
+
+## Features
+
+### 🎯 Comprehensive XAI Coverage
+
+**Local Explainers** (instance-level explanations):
+- **LIME** - Local Interpretable Model-agnostic Explanations ([Ribeiro et al., 2016](https://arxiv.org/abs/1602.04938))
+- **SHAP** - SHapley Additive exPlanations via KernelSHAP ([Lundberg & Lee, 2017](https://arxiv.org/abs/1705.07874))
+- **Anchors** - High-precision rule-based explanations ([Ribeiro et al., 2018](https://ojs.aaai.org/index.php/AAAI/article/view/11491))
+- **Counterfactual** - DiCE-style diverse counterfactual explanations ([Mothilal et al., 2020](https://arxiv.org/abs/1905.07697))
+
+**Global Explainers** (model-level explanations):
+- **Permutation Importance** - Feature importance via performance degradation ([Breiman, 2001](https://link.springer.com/article/10.1023/A:1010933404324))
+- **Partial Dependence (PDP)** - Marginal feature effects ([Friedman, 2001](https://projecteuclid.org/euclid.aos/1013203451))
+- **ALE** - Accumulated Local Effects, unbiased for correlated features ([Apley & Zhu, 2020](https://academic.oup.com/jrsssb/article/82/4/1059/7056085))
+- **SAGE** - Shapley Additive Global importancE ([Covert et al., 2020](https://arxiv.org/abs/2004.00668))
+
+### 🔌 Extensible Plugin Registry
+- Register custom explainers with rich metadata
+- Filter by scope (local/global), model type, data type
+- Automatic recommendations based on use case
+
+### 📊 Evaluation Metrics
+- **AOPC** (Area Over Perturbation Curve)
+- **ROAR** (Remove And Retrain)
+- Multiple baseline options and curve generation
+
+### 🧪 Standardized Interface
+- Consistent `BaseExplainer` API
+- Unified `Explanation` output format
+- Model adapters for sklearn and more
+
+---
+
+## Installation
+
+From PyPI:
+
+```bash
+pip install explainiverse
+```
+
+For development:
+
+```bash
+git clone https://github.com/jemsbhai/explainiverse.git
+cd explainiverse
+poetry install
+```
+
+---
+
+## Quick Start
+
+### Using the Registry (Recommended)
+
+```python
+from explainiverse import default_registry, SklearnAdapter
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.datasets import load_iris
+
+# Train a model
+iris = load_iris()
+model = RandomForestClassifier().fit(iris.data, iris.target)
+adapter = SklearnAdapter(model, class_names=iris.target_names.tolist())
+
+# List available explainers
+print(default_registry.list_explainers())
+# ['lime', 'shap', 'anchors', 'counterfactual', 'permutation_importance', 'partial_dependence', 'ale', 'sage']
+
+# Create and use an explainer
+explainer = default_registry.create(
+    "lime",
+    model=adapter,
+    training_data=iris.data,
+    feature_names=iris.feature_names,
+    class_names=iris.target_names.tolist()
+)
+explanation = explainer.explain(iris.data[0])
+print(explanation.explanation_data["feature_attributions"])
+```
+
+### Filter Explainers by Criteria
+
+```python
+# Find local explainers for tabular data
+local_tabular = default_registry.filter(scope="local", data_type="tabular")
+print(local_tabular)  # ['lime', 'shap', 'anchors', 'counterfactual']
+
+# Find global explainers
+global_explainers = default_registry.filter(scope="global")
+print(global_explainers)  # ['permutation_importance', 'partial_dependence', 'ale', 'sage']
+
+# Get recommendations
+recommendations = default_registry.recommend(
+    model_type="any",
+    data_type="tabular",
+    scope_preference="local"
+)
+```
+
+### Using Specific Explainers
+
+```python
+# Anchors - Rule-based explanations
+from explainiverse.explainers import AnchorsExplainer
+
+anchors = AnchorsExplainer(
+    model=adapter,
+    training_data=X_train,
+    feature_names=feature_names,
+    class_names=class_names
+)
+explanation = anchors.explain(instance)
+print(explanation.explanation_data["rules"])
+# ['petal length (cm) > 2.45', 'petal width (cm) <= 1.75']
+
+# Counterfactual - What-if explanations
+from explainiverse.explainers import CounterfactualExplainer
+
+cf = CounterfactualExplainer(
+    model=adapter,
+    training_data=X_train,
+    feature_names=feature_names
+)
+explanation = cf.explain(instance, num_counterfactuals=3)
+print(explanation.explanation_data["changes"])
+
+# SAGE - Global Shapley importance
+from explainiverse.explainers import SAGEExplainer
+
+sage = SAGEExplainer(
+    model=adapter,
+    X=X_train,
+    y=y_train,
+    feature_names=feature_names
+)
+explanation = sage.explain()
+print(explanation.explanation_data["feature_attributions"])
+```
+
+### Explanation Suite (Multi-Explainer Comparison)
+
+```python
+from explainiverse import ExplanationSuite
+
+suite = ExplanationSuite(
+    model=adapter,
+    explainer_configs=[
+        ("lime", {"training_data": X_train, "feature_names": feature_names, "class_names": class_names}),
+        ("shap", {"background_data": X_train[:50], "feature_names": feature_names, "class_names": class_names}),
+    ]
+)
+
+results = suite.run(instance)
+suite.compare()
+```
+
+---
+
+## Registering Custom Explainers
+
+```python
+from explainiverse import ExplainerRegistry, ExplainerMeta, BaseExplainer
+
+@default_registry.register_decorator(
+    name="my_explainer",
+    meta=ExplainerMeta(
+        scope="local",
+        model_types=["any"],
+        data_types=["tabular"],
+        description="My custom explainer",
+        paper_reference="Author et al., 2024"
+    )
+)
+class MyExplainer(BaseExplainer):
+    def explain(self, instance, **kwargs):
+        # Your implementation
+        return Explanation(...)
+```
+
+---
+
+## Running Tests
+
+```bash
+# Run all tests
+poetry run pytest
+
+# Run with coverage
+poetry run pytest --cov=explainiverse
+
+# Run specific test file
+poetry run pytest tests/test_new_explainers.py -v
+```
+
+---
+
+## Roadmap
+
+- [x] LIME, SHAP (KernelSHAP)
+- [x] Anchors, Counterfactuals
+- [x] Permutation Importance, PDP, ALE, SAGE
+- [x] Explainer Registry with filtering
+- [ ] TreeSHAP (optimized for tree models)
+- [ ] Integrated Gradients (gradient-based for neural nets)
+- [ ] PyTorch/TensorFlow adapters
+- [ ] Interactive visualization dashboard
+
+---
+
+## Citation
+
+If you use Explainiverse in your research, please cite:
+
+```bibtex
+@software{explainiverse2024,
+  title = {Explainiverse: A Unified Framework for Explainable AI},
+  author = {Syed, Muntaser},
+  year = {2024},
+  url = {https://github.com/jemsbhai/explainiverse}
+}
+```
+
+---
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+

explainiverse-0.2.0.dist-info/RECORD

@@ -0,0 +1,29 @@
+explainiverse/__init__.py,sha256=G8RreMDjukC0quXjsutBmEP_dtTdj_Q9CClA61xen0o,1207
+explainiverse/adapters/__init__.py,sha256=fNlWQ0VDjNqi4G4lwaJRTtL0wGVgvEE-4pZt6vOOjYU,322
+explainiverse/adapters/base_adapter.py,sha256=Nqt0GeDn_-PjTyJcZsE8dRTulavqFQsv8sMYWS_ps-M,603
+explainiverse/adapters/sklearn_adapter.py,sha256=pzIBtMuqrG-6ZbUqUCMt7rSk3Ow0FgrY268FSweFvw4,958
+explainiverse/core/__init__.py,sha256=P3jHMnH5coFqTTO1w-gT-rurkCM1-9r3pF-055pbXMg,474
+explainiverse/core/explainer.py,sha256=Z9on-9VblYDlQx9oBm1BHpmAf_NsQajZ3qr-u48Aejo,784
+explainiverse/core/explanation.py,sha256=6zxFh_TH8tFHc-r_H5-WHQ05Sp1Kp2TxLz3gyFek5jo,881
+explainiverse/core/registry.py,sha256=neI--cDC6j2VyZdUQbKkt1ERLGsaJdSyZSMvJ1b9RYs,19061
+explainiverse/engine/__init__.py,sha256=1sZO8nH1mmwK2e-KUavBQm7zYDWUe27nyWoFy9tgsiA,197
+explainiverse/engine/suite.py,sha256=sq8SK_6Pf0qRckTmVJ7Mdosu9bhkjAGPGN8ymLGFP9E,4914
+explainiverse/evaluation/__init__.py,sha256=Y50L_b4HKthg4epwcayPHXh0l4i4MUuzvaNlqPmUNZY,212
+explainiverse/evaluation/metrics.py,sha256=tSBXtyA_-0zOGCGjlPZU6LdGKRH_QpWfgKa78sdlovs,7453
+explainiverse/explainers/__init__.py,sha256=CYaDGsASoiNkwUUkeugLowR1-kupLNSvaCK8Fw_zdRI,1564
+explainiverse/explainers/attribution/__init__.py,sha256=ei8w6_4VL5aA5HSwIhcJx6gD_oVNAYFf_H1PRAi1SCA,326
+explainiverse/explainers/attribution/lime_wrapper.py,sha256=OnXIV7t6yd-vt38sIi7XmHFbgzlZfCEbRlFyGGd5XiE,3245
+explainiverse/explainers/attribution/shap_wrapper.py,sha256=tKie5AvN7mb55PWOYdMvW0lUAYjfHPzYosEloEY2ZzI,3210
+explainiverse/explainers/counterfactual/__init__.py,sha256=gEV6P8h2fZ3-pv5rqp5sNDqrLErh5ntqpxIIBVCMFv4,247
+explainiverse/explainers/counterfactual/dice_wrapper.py,sha256=PyJYF-z1nyyy0mFROnkJqPtcuT2PwEBARwfh37mZ5ew,11373
+explainiverse/explainers/global_explainers/__init__.py,sha256=91xayho0r-fVeIxBLTxF-aBaBhRTRRXxGZ7oUHh7z64,713
+explainiverse/explainers/global_explainers/ale.py,sha256=tgG3XTppCf8LiD7uKzBt4DI8C589EHsTmzeydHh79OQ,6287
+explainiverse/explainers/global_explainers/partial_dependence.py,sha256=dH6yMjpwZads3pACR3rSykTbssLGHH7e6HfMlpl-S3I,6745
+explainiverse/explainers/global_explainers/permutation_importance.py,sha256=bcgKz1S_D3lrBMgpqEF_Z6qw8Knxl_cfR50hrSO2tBc,4410
+explainiverse/explainers/global_explainers/sage.py,sha256=57Xw1SK529x5JXWt0TVrcFYUUP3C65LfUwgoM-Z3gaw,5839
+explainiverse/explainers/rule_based/__init__.py,sha256=gKzlFCAzwurAMLJcuYgal4XhDj1thteBGcaHWmN7iWk,243
+explainiverse/explainers/rule_based/anchors_wrapper.py,sha256=ML7W6aam-eMGZHy5ilol8qupZvNBJpYAFatEEPnuMyo,13254
+explainiverse-0.2.0.dist-info/LICENSE,sha256=28rbHe8rJgmUlRdxJACfq1Sj-MtCEhyHxkJedQd1ZYA,1070
+explainiverse-0.2.0.dist-info/METADATA,sha256=WqgN7AquEhUxeO6G3ZLhOXjKuNoVcOuVfXU8jQ1u1F0,7731
+explainiverse-0.2.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+explainiverse-0.2.0.dist-info/RECORD,,