weirdo 2.1.0__py3-none-any.whl

weirdo/scorers/trainable.py

@@ -0,0 +1,219 @@
+"""Base class for trainable (ML-based) scorers.
+
+Provides common infrastructure for training, saving, and loading models.
+"""
+
+import json
+import os
+from abc import abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
+import numpy as np
+
+from .base import BatchScorer
+
+
+class TrainableScorer(BatchScorer):
+    """Base class for trainable foreignness scorers.
+
+    Extends BatchScorer with training, saving, and loading capabilities.
+    Subclasses implement specific model architectures (MLP, etc.).
+
+    Parameters
+    ----------
+    k : int, default=8
+        K-mer size for decomposing peptides.
+    batch_size : int, default=256
+        Batch size for training and inference.
+    """
+
+    def __init__(
+        self,
+        k: int = 8,
+        batch_size: int = 256,
+        **kwargs
+    ):
+        super().__init__(batch_size=batch_size, **kwargs)
+        self._params.update({'k': k})
+        self._model = None
+        self._is_trained = False
+        self._training_history: List[Dict[str, float]] = []
+        self._metadata: Dict[str, Any] = {}
+
+    @property
+    def k(self) -> int:
+        """Get k-mer size."""
+        return self._params['k']
+
+    @property
+    def is_trained(self) -> bool:
+        """Check if model has been trained."""
+        return self._is_trained
+
+    @property
+    def training_history(self) -> List[Dict[str, float]]:
+        """Get training history (loss per epoch)."""
+        return self._training_history.copy()
+
+    @abstractmethod
+    def train(
+        self,
+        peptides: Sequence[str],
+        labels: Sequence[float],
+        val_peptides: Optional[Sequence[str]] = None,
+        val_labels: Optional[Sequence[float]] = None,
+        epochs: Optional[int] = None,
+        learning_rate: Optional[float] = None,
+        verbose: bool = True,
+    ) -> 'TrainableScorer':
+        """Train the model on labeled data.
+
+        Parameters
+        ----------
+        peptides : sequence of str
+            Training peptide sequences.
+        labels : sequence of float or 2D array
+            Target labels. For multi-label classification, use a 2D array.
+        val_peptides : sequence of str, optional
+            Validation peptides for early stopping.
+        val_labels : sequence of float, optional
+            Validation labels.
+        epochs : int, optional
+            Number of training epochs. Defaults to model's max_iter.
+        learning_rate : float, optional
+            Learning rate for optimizer. Defaults to model's learning_rate_init.
+        verbose : bool, default=True
+            Print training progress.
+
+        Returns
+        -------
+        self : TrainableScorer
+            Returns self for method chaining.
+        """
+        pass
+
+    @abstractmethod
+    def _save_model(self, path: Path) -> None:
+        """Save model weights to path (implemented by subclass)."""
+        pass
+
+    @abstractmethod
+    def _load_model(self, path: Path) -> None:
+        """Load model weights from path (implemented by subclass)."""
+        pass
+
+    def save(self, path: Union[str, Path]) -> None:
+        """Save trained model to disk.
+
+        Creates a directory containing:
+        - model.pt: Model weights
+        - config.json: Model configuration
+        - metadata.json: Training metadata
+
+        Parameters
+        ----------
+        path : str or Path
+            Directory path to save model.
+        """
+        if not self._is_trained:
+            raise RuntimeError("Model must be trained before saving.")
+
+        path = Path(path)
+        path.mkdir(parents=True, exist_ok=True)
+
+        # Save model weights
+        self._save_model(path / 'model.pt')
+
+        # Save configuration
+        config = {
+            'scorer_type': self.__class__.__name__,
+            'params': self._params,
+        }
+        with open(path / 'config.json', 'w') as f:
+            json.dump(config, f, indent=2)
+
+        # Save metadata
+        metadata = {
+            'training_history': self._training_history,
+            **self._metadata,
+        }
+        with open(path / 'metadata.json', 'w') as f:
+            json.dump(metadata, f, indent=2)
+
+    @classmethod
+    def load(cls, path: Union[str, Path]) -> 'TrainableScorer':
+        """Load a trained model from disk.
+
+        Parameters
+        ----------
+        path : str or Path
+            Directory path containing saved model.
+
+        Returns
+        -------
+        scorer : TrainableScorer
+            Loaded model ready for inference.
+        """
+        path = Path(path)
+
+        # Load configuration
+        with open(path / 'config.json', 'r') as f:
+            config = json.load(f)
+
+        # Create instance with saved params
+        instance = cls(**config['params'])
+
+        # Load model weights
+        instance._load_model(path / 'model.pt')
+        instance._is_trained = True
+        instance._is_fitted = True
+
+        # Load metadata
+        if (path / 'metadata.json').exists():
+            with open(path / 'metadata.json', 'r') as f:
+                metadata = json.load(f)
+            instance._training_history = metadata.get('training_history', [])
+            instance._metadata = metadata
+
+        return instance
+
+    def fit(self, reference=None) -> 'TrainableScorer':
+        """For compatibility with BaseScorer interface.
+
+        Trainable scorers use train() instead of fit().
+        If already trained, this is a no-op.
+        """
+        if self._is_trained:
+            self._is_fitted = True
+            return self
+        raise RuntimeError(
+            "Trainable scorers must be trained with train() or loaded with load(). "
+            "Use scorer.train(peptides, labels) to train a new model."
+        )
+
+    def _extract_kmers(self, peptide: str) -> List[str]:
+        """Extract overlapping k-mers from peptide."""
+        k = self.k
+        if len(peptide) < k:
+            # Pad short peptides
+            peptide = peptide + 'X' * (k - len(peptide))
+        return [peptide[i:i+k] for i in range(len(peptide) - k + 1)]
+
+    def _peptide_to_indices(self, peptide: str) -> List[List[int]]:
+        """Convert peptide to list of k-mer amino acid indices.
+
+        Returns list of k-mers, each as list of AA indices (0-20).
+        """
+        AA_TO_IDX = {
+            'A': 0, 'C': 1, 'D': 2, 'E': 3, 'F': 4,
+            'G': 5, 'H': 6, 'I': 7, 'K': 8, 'L': 9,
+            'M': 10, 'N': 11, 'P': 12, 'Q': 13, 'R': 14,
+            'S': 15, 'T': 16, 'V': 17, 'W': 18, 'Y': 19,
+            'X': 20,  # Unknown/padding
+        }
+        kmers = self._extract_kmers(peptide)
+        return [
+            [AA_TO_IDX.get(aa, 20) for aa in kmer]
+            for kmer in kmers
+        ]

weirdo/static_data.py

@@ -0,0 +1,17 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+from os.path import dirname, realpath, join
+
+PACKAGE_DIR = dirname(realpath(__file__))
+MATRIX_DIR = join(PACKAGE_DIR, 'matrices')

weirdo-2.1.0.dist-info/METADATA

@@ -0,0 +1,294 @@
+Metadata-Version: 2.4
+Name: weirdo
+Version: 2.1.0
+Summary: Metrics of immunological foreignness for candidate T-cell epitopes
+Home-page: https://github.com/pirl-unc/weirdo
+Author: Alex Rubinsteyn
+Author-email: alex.rubinsteyn@unc.edu
+License: http://www.apache.org/licenses/LICENSE-2.0.html
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy<2.0.0,>=1.20.0
+Requires-Dist: pandas<3.0.0,>=1.3.0
+Requires-Dist: scikit-learn<2.0.0,>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: pylint>=2.0.0; extra == "dev"
+Requires-Dist: sphinx>=5.0.0; extra == "dev"
+Requires-Dist: sphinx-rtd-theme>=1.0.0; extra == "dev"
+Requires-Dist: sphinx-autodoc-typehints>=1.0.0; extra == "dev"
+Requires-Dist: tqdm>=4.0.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=5.0.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme>=1.0.0; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints>=1.0.0; extra == "docs"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+[![Tests](https://github.com/pirl-unc/weirdo/actions/workflows/tests.yml/badge.svg)](https://github.com/pirl-unc/weirdo/actions/workflows/tests.yml)
+[![Documentation](https://github.com/pirl-unc/weirdo/actions/workflows/docs.yml/badge.svg)](https://github.com/pirl-unc/weirdo/actions/workflows/docs.yml)
+[![PyPI](https://img.shields.io/pypi/v/weirdo.svg)](https://pypi.python.org/pypi/weirdo/)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+# WEIRDO
+
+**W**idely **E**stimated **I**mmunological **R**ecognition and **D**etection of **O**utliers
+
+A Python library for computing peptide foreignness scores—predicting whether a peptide sequence is likely from a pathogen (bacteria, virus) or from self (human, mammalian).
+
+## Overview
+
+WEIRDO trains a multi-layer perceptron (MLP) on k-mer presence data from SwissProt to predict organism category membership. Given any peptide, it outputs:
+
+- **Category probabilities**: likelihood of appearing in human, bacteria, viruses, mammals, etc.
+- **Foreignness score**: `max(pathogens) / (max(pathogens) + max(self))`
+
+## Quick Start
+
+```python
+from weirdo.scorers import SwissProtReference, MLPScorer
+
+# Load reference data (SwissProt 8-mers with organism labels)
+ref = SwissProtReference().load()
+
+# Define organism categories
+categories = [
+    'archaea', 'bacteria', 'fungi', 'human', 'invertebrates',
+    'mammals', 'plants', 'rodents', 'vertebrates', 'viruses'
+]
+
+# Get training data: each 8-mer labeled with organism presence
+peptides, labels = ref.get_training_data(
+    target_categories=categories,
+    multi_label=True,
+    max_samples=200000  # Optional: sample for faster training
+)
+
+# Train the MLP
+scorer = MLPScorer(k=8, hidden_layer_sizes=(256, 128, 64))
+scorer.train(peptides, labels, target_categories=categories, epochs=200)
+
+# Score new peptides (any length)
+df = scorer.predict_dataframe(['MTMDKSEL', 'SIINFEKL', 'NLVPMVATV'])
+print(df)
+```
+
+**Output:**
+```
+    peptide  human  viruses  bacteria  mammals  ...  foreignness
+   MTMDKSEL   0.82     0.12      0.08     0.79  ...        0.127
+   SIINFEKL   0.15     0.73      0.21     0.18  ...        0.802
+  NLVPMVATV   0.31     0.68      0.15     0.35  ...        0.660
+```
+
+## Installation
+
+```bash
+pip install weirdo
+```
+
+Download reference data (~2.5 GB compressed / ~7.5 GB uncompressed) for training:
+```bash
+weirdo data download
+```
+
+## Training Data
+
+WEIRDO uses pre-computed 8-mer data from SwissProt (~100M unique k-mers):
+
+| Category | Description |
+|----------|-------------|
+| human | Homo sapiens proteins |
+| rodents | Mouse, rat proteins |
+| mammals | Other mammals (dog, cow, primates, etc.) |
+| vertebrates | Fish, birds, reptiles, amphibians |
+| invertebrates | Insects, worms, mollusks |
+| bacteria | Bacterial proteins |
+| viruses | Viral proteins |
+| archaea | Archaeal proteins |
+| fungi | Fungal proteins |
+| plants | Plant proteins |
+
+Each 8-mer has True/False labels for each category, indicating whether it appears in proteins from that organism group.
+
+## Feature Extraction
+
+The MLP uses **592 features** extracted from each peptide:
+
+### Amino Acid Properties (48 features)
+12 physicochemical properties × 4 statistics (mean, std, min, max):
+- Hydropathy, hydrophilicity
+- Mass, volume
+- Polarity, pK side chain
+- Accessible surface area (folded/unfolded)
+- Local flexibility, refractivity
+- Solvent exposed area, % exposed residues
+
+### Structural Features (27 features)
+- **Secondary structure propensities** (12): helix, sheet, turn × 4 stats
+- **Category fractions** (9): positive/negative charged, hydrophobic, aromatic, aliphatic, polar, tiny, small, cysteine
+- **Charge features** (4): net charge, charge transitions, max cluster, R/(R+K) ratio
+- **Disorder features** (2): disorder/order promoting fractions
+
+### Composition Features (420 features)
+- **Amino acid frequencies** (20): fraction of each amino acid
+- **Dipeptide frequencies** (400): fraction of each amino acid pair
+
+### Sequence Statistics (12 features)
+- Length, log-length, sqrt-length
+- Unknown fraction, unique AA fraction
+- Max run length, repeat fraction
+- Entropy/complexity (entropy, effective AAs, Gini, top-2/maximum frequency)
+
+### Reduced Alphabet Frequencies (80 features)
+- Composition across common reduced alphabets (Murphy, GBMR, SDM, etc.)
+
+### Dipeptide Summary (5 features)
+- Entropy, Gini, max/top2 frequency, homodipeptide fraction
+
+## API Reference
+
+### Training
+
+```python
+from weirdo.scorers import SwissProtReference, MLPScorer
+
+# Load reference
+ref = SwissProtReference().load()
+
+# Get training data
+peptides, labels = ref.get_training_data(
+    target_categories=['human', 'viruses', 'bacteria', 'mammals'],
+    multi_label=True,
+    max_samples=100000  # Optional: limit for memory
+)
+
+# Train
+scorer = MLPScorer(
+    k=8,
+    hidden_layer_sizes=(256, 128, 64),
+    activation='relu',
+    alpha=0.0001,  # L2 regularization
+)
+scorer.train(
+    peptides, labels,
+    target_categories=['human', 'viruses', 'bacteria', 'mammals'],
+    epochs=200,
+    learning_rate=0.001
+)
+```
+
+### Prediction
+
+```python
+# Category probabilities (sigmoid-activated)
+probs = scorer.predict_proba(['MTMDKSEL'])
+# Shape: (1, n_categories)
+
+# Foreignness score
+foreign = scorer.foreignness(
+    ['MTMDKSEL'],
+    pathogen_categories=['bacteria', 'viruses'],
+    self_categories=['human', 'mammals', 'rodents']
+)
+# Returns: max(pathogens) / (max(pathogens) + max(self))
+
+# Full DataFrame output (handles variable-length peptides)
+df = scorer.predict_dataframe(['MTMDKSEL', 'SIINFEKL', 'NLVPMVATV'])
+```
+
+### Feature Extraction
+
+```python
+# Extract features as DataFrame
+df = scorer.features_dataframe(['MTMDKSEL', 'SIINFEKL'])
+# Shape: (2, 593) - 592 features + peptide column
+
+# Feature names
+names = scorer.get_feature_names()
+# ['hydropathy_mean', 'hydropathy_std', ..., 'dipep_YY']
+```
+
+### Model Persistence
+
+```python
+from weirdo import save_model, load_model, list_models
+
+# Save trained model
+save_model(scorer, 'my-foreignness-model')
+
+# List saved models
+for model in list_models():
+    print(f"{model.name}: {model.scorer_type}")
+
+# Load model
+scorer = load_model('my-foreignness-model')
+```
+
+### CLI
+
+```bash
+# Data management
+weirdo data download        # Download SwissProt reference
+weirdo data list            # Show data status
+
+# Model management
+weirdo models list          # List trained models
+weirdo models train --data train.csv --name my-model
+weirdo models info my-model # Show model details
+
+# Scoring
+weirdo score --model my-model MTMDKSEL SIINFEKL
+```
+
+## Architecture
+
+```
+weirdo/
+├── scorers/
+│   ├── mlp.py          # MLPScorer with feature extraction
+│   ├── swissprot.py    # SwissProtReference (training data)
+│   ├── config.py       # Presets and configuration
+│   ├── registry.py     # Scorer registry
+│   └── trainable.py    # TrainableScorer base class
+├── model_manager.py    # Save/load trained models
+├── amino_acid_properties.py  # 12 AA property dictionaries
+└── api.py              # High-level functions
+```
+
+## Citation
+
+```bibtex
+@software{weirdo,
+  title = {WEIRDO: Widely Estimated Immunological Recognition and Detection of Outliers},
+  author = {PIRL-UNC},
+  url = {https://github.com/pirl-unc/weirdo}
+}
+```
+
+## License
+
+Apache License 2.0. See [LICENSE](LICENSE) for details.

weirdo-2.1.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+weirdo/__init__.py,sha256=4Y4eon4__PBBd5WBWZBn8qvVAvQhZCe2VYtOCty3jVY,2124
+weirdo/amino_acid.py,sha256=ejd1a3a30qnKeZnrXKpAgTQeCgQ6Q33B6fFH_qzCsOI,1220
+weirdo/amino_acid_alphabet.py,sha256=_0TmcGHP4rCJ3hotHXmFD58_6AkA4GOOrouy219t7qw,4616
+weirdo/amino_acid_properties.py,sha256=5EH1iaO8ryCXIca7QIUJCnWlfpjclr7yxqxB9RlGyM0,6203
+weirdo/api.py,sha256=7tLxZ5NiebQznsBxbS2Yq0mRGFTDIGgMb4h2N3DIrvU,10504
+weirdo/blosum.py,sha256=873ejyPMmTmsLDNS1EM7uNx8hWclw1WCPqFkFuzSIGU,2535
+weirdo/chou_fasman.py,sha256=t_k-JggZtEmm2ZiMVnMHrlGFk47PbQU2e02W35Qoa0A,3214
+weirdo/cli.py,sha256=vk7zdReoXt3LchJlalRfFOL1BDb-rTBa5SWuTfc9DG0,18965
+weirdo/common.py,sha256=iVXKu5ZUQogAaP1arrF53fFu64kFZoTl-vuCv2Pww-k,840
+weirdo/data_manager.py,sha256=NOYLkpznV9FFMAd6ZPJCxefjs-30PnS2NCpC-FEV-s0,14385
+weirdo/distances.py,sha256=CyVyKZc5XOiRsj_kaj73lCXcQam5O8w9qX_tafe3Vxk,648
+weirdo/model_manager.py,sha256=5DkbA4HrWOysbUKaWb_e-HoSgnSnF5lhRTzZDACXFDk,9476
+weirdo/peptide_vectorizer.py,sha256=MeEF5V1t21LvejAPC3OPhrjueAxWTMe0LbAvavILu2U,2817
+weirdo/pmbec.py,sha256=SSJ_Km0DdiGkyYwWn_zHFaCDwz__S89KF5dh808Tr_s,2894
+weirdo/reduced_alphabet.py,sha256=Bkwe8EJ_3f658GM_4NHzric9gr5uDPdP_eAwR_wsKCA,2088
+weirdo/residue_contact_energies.py,sha256=9COim1bw8-q8mGhiKe_yuH9fCMQoO2zjcS7TgN92dNg,2871
+weirdo/static_data.py,sha256=9V5RmhXTTba8ccOrL2n-czEsg5lCNuFHFIm_RPh2s1M,676
+weirdo/matrices/BLOSUM30,sha256=x2ESElo8Qb49iZsPS30KjP57ZYAf_l350ZUBYfk_ahc,1900
+weirdo/matrices/BLOSUM50,sha256=8Q58JEqlHIotcBfE3q1NyBm93WT5xiyrY7TNn5s3-ZA,1322
+weirdo/matrices/BLOSUM62,sha256=7jMEl7Vws5RtKB3HjmCJpWkwDrv75eo2tI-VxqyXDxI,2061
+weirdo/matrices/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+weirdo/matrices/amino_acid_properties.txt,sha256=dpq0L7_MSinEoLAboryhiT28chg49MU-VwzjiqOtKWI,13214
+weirdo/matrices/helix_vs_coil.txt,sha256=britXB_v_TqcCW3IHXz08nSwNe_CB5uaOzykbMYL5wk,2651
+weirdo/matrices/helix_vs_strand.txt,sha256=EanjvMyWH1xkjqMNRawnqqMDGDKxUyWxl37jVrsZ1s4,2692
+weirdo/matrices/pmbec.mat,sha256=psM1Wn2KR46JHA4UXiSPQVwOf5KgwELpS2kcHDpnIag,6746
+weirdo/matrices/strand_vs_coil.txt,sha256=0qv-jyTD_YO1c9oVO2NJ_2t6gLY8pvORP9aH69V1ONA,2610
+weirdo/scorers/__init__.py,sha256=P0YyGdSK1HijaOhPAYcOTlas1Q-muZDz2vOgE2QBKko,2211
+weirdo/scorers/base.py,sha256=7VIDx5Sc6ieuvfW-np1jYwFhywSTifg6fNzksnlo6Lw,6159
+weirdo/scorers/config.py,sha256=eE_9EJSry3QnUsxxOMHlK5c2an2pFdmxZ4qdiAg5Nf4,8275
+weirdo/scorers/mlp.py,sha256=tinatxnu3f9h6SEl4V6l3BWvwLoQe-afhfHI1sCBG8k,39850
+weirdo/scorers/reference.py,sha256=RTIDHLI4tj1ruuu6NVb0HKD7txMhu3NGoctCxM-wEZw,7016
+weirdo/scorers/registry.py,sha256=K2GQtgp-wF975Zf6F4ItQQeh_qsI8UOvfyW8I5DJUJo,7858
+weirdo/scorers/similarity.py,sha256=tIveCPNDCJ8rJmRViVw9VBScW7OKA47Q7xAAsiEz5tk,11658
+weirdo/scorers/swissprot.py,sha256=UGtDgVp4r-lnG2DVTSSFf1gqTLvJKKdd7R2QMhIWtn0,16888
+weirdo/scorers/trainable.py,sha256=XylC98ltHTBaV62rfAN6_iGWQyeD8j-lqMHYfR5J-Vk,6721
+weirdo-2.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+weirdo-2.1.0.dist-info/METADATA,sha256=JxwUuGu72tFNEG-KjFCF2mPzTJQH_VI4ll6c95fcESQ,9238
+weirdo-2.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+weirdo-2.1.0.dist-info/entry_points.txt,sha256=D6RgZ4ugZW0RrZIW2X_DEeIW-vmdFuyCM6xLlUABqac,42
+weirdo-2.1.0.dist-info/top_level.txt,sha256=aC8Ch-s2qwCn-RVOwY1WqNXNoFJHVyfnW3x9umQZ3K0,7
+weirdo-2.1.0.dist-info/RECORD,,

weirdo-2.1.0.dist-info/WHEEL

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

weirdo-2.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+weirdo = weirdo.cli:run