pepe-cli 1.4.0__tar.gz → 1.5.0__tar.gz

{pepe_cli-1.4.0/src/pepe_cli.egg-info → pepe_cli-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pepe-cli
-Version: 1.4.0
+Version: 1.5.0
 Summary: Pipeline for Easy Protein Embedding - Extract embeddings and attention matrices from protein sequences
 Home-page: https://github.com/csi-greifflab/pepe-cli
 Author: Jahn Zhong
@@ -16,13 +16,11 @@ Classifier: Intended Audience :: Science/Research
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: torch>=1.9.0
@@ -32,6 +30,15 @@ Requires-Dist: numpy
 Requires-Dist: protobuf
 Requires-Dist: alive_progress
 Requires-Dist: rjieba
+Provides-Extra: esm
+Requires-Dist: fair-esm; extra == "esm"
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: biopython; extra == "dev"
 Dynamic: author
 Dynamic: home-page
 Dynamic: license-file
@@ -39,19 +46,19 @@ Dynamic: requires-python
 
 # PEPE
 
-PEPE (Pipeline for Easy Protein Embedding) is a tool for extracting embeddings and attention matrices from protein sequences using pre-trained models. This tool supports various configurations for extracting embeddings and attention matrices, including options for handling CDR3 sequences. Currently implemented models are ESM2 from the 2023 paper ["Evolutionary-scale prediction of atomic-level protein structure with a language model"](https://science.org/doi/10.1126/science.ade2574) and AntiBERTa2-CSSP from the 2023 conference paper ["Enhancing Antibody Language Models with Structural Information"](https://www.mlsb.io/papers_2023/Enhancing_Antibody_Language_Models_with_Structural_Information.pdf). PEPE also supports custom PLMs from local files or from Huggingface Hub addresses. 
+PEPE (Pipeline for Easy Protein Embedding) is a tool for extracting embeddings and attention matrices from protein sequences using pre-trained models. This tool supports various configurations for extracting embeddings and attention matrices, including options for handling CDR3 sequences. Currently implemented models are ESM2 from the 2023 paper ["Evolutionary-scale prediction of atomic-level protein structure with a language model"](https://science.org/doi/10.1126/science.ade2574) and AntiBERTa2-CSSP from the 2023 conference paper ["Enhancing Antibody Language Models with Structural Information"](https://www.mlsb.io/papers_2023/Enhancing_Antibody_Language_Models_with_Structural_Information.pdf). PEPE also supports custom PLMs from local files or from Huggingface Hub addresses.
 
 ### Citation
 > **PEPE: Scalable extraction of multi-modal protein language model representations**
 > Jahn Zhong, Niccolò Cardente, Geir Kjetil Sandve, Habib Bashour, Maria Francesca Abbate, Victor Greiff
-> *bioRxiv* (2026) 
+> *bioRxiv* (2026)
 > [DOI: 10.1101/2025.10.13.680902](https://doi.org/10.1101/2025.10.13.680902)
 
 ## Quick start
 
 1. Install PEPE
 
-    From PyPI:    
+    From PyPI:
     ```sh
     pip install pepe-cli
     ```
@@ -59,7 +66,7 @@ PEPE (Pipeline for Easy Protein Embedding) is a tool for extracting embeddings a
     ```sh
     conda install -c jahn_zhong pepe-cli
     ```
-    Or install from the GitHub repository:    
+    Or install from the GitHub repository:
     ```sh
     git clone https://github.com/csi-greifflab/pepe-cli
     cd pepe-cli
@@ -71,7 +78,35 @@ PEPE (Pipeline for Easy Protein Embedding) is a tool for extracting embeddings a
     pip install git+https://github.com/Biohub/transformers.git@main
     ```
 
-3. Extract embeddings:\
+3. *(Optional)* For METL 1D embedding models (e.g. `metl-g-20m-1d`), install the backend directly from GitHub (it is not on PyPI):
+
+    ```sh
+    pip install git+https://github.com/gitter-lab/metl-pretrained.git
+    ```
+
+    CLI example:
+
+    ```sh
+    pepe --model_name metl-g-20m-1d --fasta_path <file_path> --output_path <directory> --extract_embeddings mean_pooled
+    ```
+
+    Library example:
+
+    ```python
+    import pepe
+
+    results = pepe.embed(
+        model_name="metl-g-20m-1d",
+        sequences={"prot1": "MADKQKNGIKVNFKIRHNIEDGSVQLADHYQQNTPIGDGPVLLPDNHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK"},
+        output_path="my_embeddings",
+        extract_embeddings=["mean_pooled"],
+        device="cpu",
+    )
+    ```
+
+    **Limitations:** 1D METL models only (`per_token`, `mean_pooled`, `substring_pooled`). Logits and attention outputs are not supported. 3D METL identifiers (requiring structures) and the generic Hugging Face repo id `gitter-lab/METL` are rejected—use a `metl-*-1d` identifier from [metl-pretrained](https://github.com/gitter-lab/metl-pretrained).
+
+4. Extract embeddings:\
     Extract mean pooled embeddings from protein amino acid sequences in FASTA file:
     ```sh
     pepe --experiment_name <optional_string> --fasta_path <file_path> --output_path <directory> --model_name <model_name>
@@ -155,7 +190,7 @@ results = pepe.embed(
 
 # The embeddings are NOT loaded into RAM here.
 # 'data' is a numpy.memmap object pointing to the file on disk.
-data = results.mean_pooled["output_data"][-1] 
+data = results.mean_pooled["output_data"][-1]
 
 # You can slice it like a normal array, which only loads those specific rows into RAM
 first_100_embeddings = data[:100]
@@ -163,7 +198,7 @@ first_100_embeddings = data[:100]
 # Optimizing RAM usage:
 # If you are done with the model but want to keep working with the data,
 # you can delete the embedder object to free up GPU/CPU memory while keeping the memmaps.
-del results 
+del results
 ```
 
 ### Handling Long Sequences (Splitting & Reconstruction)
@@ -171,8 +206,8 @@ del results
 Some models have strict architectural limits on input length (e.g., 1024 for ESM-2, 256 for AntiBERTa2). PEPE can automatically detect sequences that exceed these limits and handle them through chunking and reconstruction.
 
 - **Automatic Detection**: When `--split_long_sequences` is enabled, PEPE automatically identifies sequences exceeding the model's capacity.
-- **Overlapping Chunks**: Use `--split_overlap` to maintain context between chunks. 
-- **Reconstruction**: 
+- **Overlapping Chunks**: Use `--split_overlap` to maintain context between chunks.
+- **Reconstruction**:
     - In **Library mode**, sequences are reconstructed in memory automatically after `embed()`.
     - In **CLI mode**, sequences are reconstructed if `streaming_output=False`. If `streaming_output=True`, chunks are exported individually to maximize efficiency and minimize RAM usage.
 
@@ -238,6 +273,8 @@ results = pepe.embed(
         - biohub/ESMC-300M
         - biohub/ESMC-600M
         - biohub/ESMC-6B
+    - METL 1D models (requires `metl-pretrained` from GitHub; see Quick start)
+        - `metl-g-20m-1d` and other `metl-*-1d` identifiers supported by [metl-pretrained](https://github.com/gitter-lab/metl-pretrained)
     - Custom Hugging Face models
         - Any compatible model from Hugging Face Hub: `username/model-name`
         - Private models with authentication
@@ -253,6 +290,7 @@ results = pepe.embed(
 - **`--model_name`** (str): Name of model or link to model. Choose from [List of supported models](../README.md#list-of-supported-models) or use custom models:
   - ESM models: `esm2_t33_650M_UR50D`
   - ESMC models: `biohub/ESMC-300M` (requires Biohub transformers fork; see Quick start)
+  - METL 1D models: `metl-g-20m-1d` (requires `metl-pretrained` from GitHub; see Quick start)
   - Hugging Face models: `username/model-name`
   - Custom PyTorch models: `/path/to/model.pt` or `/path/to/model_directory/`
   - Local HF models: `/path/to/local_hf_directory/`

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/README.md

@@ -1,18 +1,18 @@
 # PEPE
 
-PEPE (Pipeline for Easy Protein Embedding) is a tool for extracting embeddings and attention matrices from protein sequences using pre-trained models. This tool supports various configurations for extracting embeddings and attention matrices, including options for handling CDR3 sequences. Currently implemented models are ESM2 from the 2023 paper ["Evolutionary-scale prediction of atomic-level protein structure with a language model"](https://science.org/doi/10.1126/science.ade2574) and AntiBERTa2-CSSP from the 2023 conference paper ["Enhancing Antibody Language Models with Structural Information"](https://www.mlsb.io/papers_2023/Enhancing_Antibody_Language_Models_with_Structural_Information.pdf). PEPE also supports custom PLMs from local files or from Huggingface Hub addresses. 
+PEPE (Pipeline for Easy Protein Embedding) is a tool for extracting embeddings and attention matrices from protein sequences using pre-trained models. This tool supports various configurations for extracting embeddings and attention matrices, including options for handling CDR3 sequences. Currently implemented models are ESM2 from the 2023 paper ["Evolutionary-scale prediction of atomic-level protein structure with a language model"](https://science.org/doi/10.1126/science.ade2574) and AntiBERTa2-CSSP from the 2023 conference paper ["Enhancing Antibody Language Models with Structural Information"](https://www.mlsb.io/papers_2023/Enhancing_Antibody_Language_Models_with_Structural_Information.pdf). PEPE also supports custom PLMs from local files or from Huggingface Hub addresses.
 
 ### Citation
 > **PEPE: Scalable extraction of multi-modal protein language model representations**
 > Jahn Zhong, Niccolò Cardente, Geir Kjetil Sandve, Habib Bashour, Maria Francesca Abbate, Victor Greiff
-> *bioRxiv* (2026) 
+> *bioRxiv* (2026)
 > [DOI: 10.1101/2025.10.13.680902](https://doi.org/10.1101/2025.10.13.680902)
 
 ## Quick start
 
 1. Install PEPE
 
-    From PyPI:    
+    From PyPI:
     ```sh
     pip install pepe-cli
     ```
@@ -20,7 +20,7 @@ PEPE (Pipeline for Easy Protein Embedding) is a tool for extracting embeddings a
     ```sh
     conda install -c jahn_zhong pepe-cli
     ```
-    Or install from the GitHub repository:    
+    Or install from the GitHub repository:
     ```sh
     git clone https://github.com/csi-greifflab/pepe-cli
     cd pepe-cli
@@ -32,7 +32,35 @@ PEPE (Pipeline for Easy Protein Embedding) is a tool for extracting embeddings a
     pip install git+https://github.com/Biohub/transformers.git@main
     ```
 
-3. Extract embeddings:\
+3. *(Optional)* For METL 1D embedding models (e.g. `metl-g-20m-1d`), install the backend directly from GitHub (it is not on PyPI):
+
+    ```sh
+    pip install git+https://github.com/gitter-lab/metl-pretrained.git
+    ```
+
+    CLI example:
+
+    ```sh
+    pepe --model_name metl-g-20m-1d --fasta_path <file_path> --output_path <directory> --extract_embeddings mean_pooled
+    ```
+
+    Library example:
+
+    ```python
+    import pepe
+
+    results = pepe.embed(
+        model_name="metl-g-20m-1d",
+        sequences={"prot1": "MADKQKNGIKVNFKIRHNIEDGSVQLADHYQQNTPIGDGPVLLPDNHYLSTQSALSKDPNEKRDHMVLLEFVTAAGITHGMDELYK"},
+        output_path="my_embeddings",
+        extract_embeddings=["mean_pooled"],
+        device="cpu",
+    )
+    ```
+
+    **Limitations:** 1D METL models only (`per_token`, `mean_pooled`, `substring_pooled`). Logits and attention outputs are not supported. 3D METL identifiers (requiring structures) and the generic Hugging Face repo id `gitter-lab/METL` are rejected—use a `metl-*-1d` identifier from [metl-pretrained](https://github.com/gitter-lab/metl-pretrained).
+
+4. Extract embeddings:\
     Extract mean pooled embeddings from protein amino acid sequences in FASTA file:
     ```sh
     pepe --experiment_name <optional_string> --fasta_path <file_path> --output_path <directory> --model_name <model_name>
@@ -116,7 +144,7 @@ results = pepe.embed(
 
 # The embeddings are NOT loaded into RAM here.
 # 'data' is a numpy.memmap object pointing to the file on disk.
-data = results.mean_pooled["output_data"][-1] 
+data = results.mean_pooled["output_data"][-1]
 
 # You can slice it like a normal array, which only loads those specific rows into RAM
 first_100_embeddings = data[:100]
@@ -124,7 +152,7 @@ first_100_embeddings = data[:100]
 # Optimizing RAM usage:
 # If you are done with the model but want to keep working with the data,
 # you can delete the embedder object to free up GPU/CPU memory while keeping the memmaps.
-del results 
+del results
 ```
 
 ### Handling Long Sequences (Splitting & Reconstruction)
@@ -132,8 +160,8 @@ del results
 Some models have strict architectural limits on input length (e.g., 1024 for ESM-2, 256 for AntiBERTa2). PEPE can automatically detect sequences that exceed these limits and handle them through chunking and reconstruction.
 
 - **Automatic Detection**: When `--split_long_sequences` is enabled, PEPE automatically identifies sequences exceeding the model's capacity.
-- **Overlapping Chunks**: Use `--split_overlap` to maintain context between chunks. 
-- **Reconstruction**: 
+- **Overlapping Chunks**: Use `--split_overlap` to maintain context between chunks.
+- **Reconstruction**:
     - In **Library mode**, sequences are reconstructed in memory automatically after `embed()`.
     - In **CLI mode**, sequences are reconstructed if `streaming_output=False`. If `streaming_output=True`, chunks are exported individually to maximize efficiency and minimize RAM usage.
 
@@ -199,6 +227,8 @@ results = pepe.embed(
         - biohub/ESMC-300M
         - biohub/ESMC-600M
         - biohub/ESMC-6B
+    - METL 1D models (requires `metl-pretrained` from GitHub; see Quick start)
+        - `metl-g-20m-1d` and other `metl-*-1d` identifiers supported by [metl-pretrained](https://github.com/gitter-lab/metl-pretrained)
     - Custom Hugging Face models
         - Any compatible model from Hugging Face Hub: `username/model-name`
         - Private models with authentication
@@ -214,6 +244,7 @@ results = pepe.embed(
 - **`--model_name`** (str): Name of model or link to model. Choose from [List of supported models](../README.md#list-of-supported-models) or use custom models:
   - ESM models: `esm2_t33_650M_UR50D`
   - ESMC models: `biohub/ESMC-300M` (requires Biohub transformers fork; see Quick start)
+  - METL 1D models: `metl-g-20m-1d` (requires `metl-pretrained` from GitHub; see Quick start)
   - Hugging Face models: `username/model-name`
   - Custom PyTorch models: `/path/to/model.pt` or `/path/to/model_directory/`
   - Local HF models: `/path/to/local_hf_directory/`

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/examples/custom_model/create_example_custom_model.py

@@ -3,12 +3,12 @@
 Example script showing how to create and use a custom model with EmbedAIRR.
 """
 
+import json
+import os
+
 import torch
 import torch.nn as nn
-import os
-import json
 from transformers import AutoTokenizer
-import numpy as np
 
 
 class ExampleProteinModel(nn.Module):
@@ -309,9 +309,9 @@ def main():
     # Create example model
     model_path = create_example_model_and_tokenizer()
 
-    # Create example data
-    fasta_file = create_example_fasta()
-    substring_file = create_example_substring()
+    # Create example data (written to disk for the demo; return paths unused here)
+    create_example_fasta()
+    create_example_substring()
 
     # Test loading the model
     print("\nTesting model loading...")
@@ -319,7 +319,7 @@ def main():
         model_data = torch.load(
             os.path.join(model_path, "pytorch_model.pt"), map_location="cpu"
         )
-        print(f"✓ Model loaded successfully")
+        print("✓ Model loaded successfully")
         print(f"✓ Model config: {model_data.get('config', {})}")
 
         # Test creating the model
@@ -327,20 +327,20 @@ def main():
             vocab_size=25, hidden_size=384, num_layers=6, num_heads=12, max_length=512
         )
         model.load_state_dict(model_data["model"])
-        print(f"✓ Model architecture created and weights loaded")
+        print("✓ Model architecture created and weights loaded")
 
         # Test tokenizer loading
         try:
             tokenizer = AutoTokenizer.from_pretrained(model_path)
             print(
-                f"✓ Tokenizer loaded successfully with AutoTokenizer.from_pretrained()"
+                "✓ Tokenizer loaded successfully with AutoTokenizer.from_pretrained()"
             )
             print(f"✓ Tokenizer vocab size: {len(tokenizer.get_vocab())}")
 
             # Test tokenization
             test_sequence = "ARNDCEQGHILKMFPSTWYV"
             tokens = tokenizer(test_sequence, return_tensors="pt")
-            print(f"✓ Tokenization test successful")
+            print("✓ Tokenization test successful")
             print(f"✓ Input sequence: {test_sequence}")
             print(f"✓ Tokenized shape: {tokens['input_ids'].shape}")
 
@@ -356,7 +356,7 @@ def main():
                 dummy_input, attention_mask=dummy_mask, output_hidden_states=True
             )
 
-        print(f"✓ Forward pass successful")
+        print("✓ Forward pass successful")
         print(f"✓ Output logits shape: {output.logits.shape}")
         print(
             f"✓ Number of hidden states: {len(output.hidden_states) if output.hidden_states else 0}"

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/examples/custom_model/example_protein_model/config.json

@@ -5,4 +5,4 @@
   "vocab_size": 25,
   "max_position_embeddings": 512,
   "model_type": "protein_transformer"
-}
+}

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/examples/custom_model/example_protein_model/special_tokens_map.json

@@ -3,4 +3,4 @@
   "sep_token": "<sep>",
   "pad_token": "<pad>",
   "unk_token": "<unk>"
-}
+}

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/examples/custom_model/example_protein_model/tokenizer_config.json

@@ -7,4 +7,4 @@
   "pad_token": "<pad>",
   "unk_token": "<unk>",
   "model_type": "protein_transformer"
-}
+}

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/examples/custom_model/example_protein_model/vocab.json

@@ -24,4 +24,4 @@
   "Y": 22,
   "V": 23,
   "X": 24
-}
+}

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/examples/custom_model/example_protein_model/vocab.txt

@@ -22,4 +22,4 @@ T
 W
 Y
 V
-X
+X

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/examples/embedding_options.md

@@ -1,5 +1,5 @@
 # Embedding options
-PEPE can extract numerous different representations from the input sequences while embedding each only once. 
+PEPE can extract numerous different representations from the input sequences while embedding each only once.
 ## Layer selection
 Protein representations can be extracted from any of a PLMs hidden layers using the ```--layers``` argument and passing a list of integers. Use negative integers to index layers from the last element. E.g. ```"1"``` is first layer, ```"-1"``` is the last layer, ```"-2"``` is second to last layer, etc. Use ```"all"``` to select all layers. Default option: ```"-1"```.
 ```sh
@@ -18,7 +18,7 @@ Multiple embedding modes can be selected at once using the ```--extract_embeddin
     - ```"mean_pooled"``` (default option): Average of ```"per_token"``` embedding over all amino acid tokens of the protein sequence.
     - ```"substring_pooled"```: Average of ```"per_token"``` embedding over a specified substring of the protein sequence. Additional arguments when selected:
         - ```--substring_path``` (required for ```"substring_pooled"```): Path to a CSV file with two columns. The first column contains the ```sequence_id``` and the second column must contain a substring of the sequence provided in the FASTA input file.
-        - ```--context``` (optional): Specify the number of residues before and after the substring to include during pooling. 
+        - ```--context``` (optional): Specify the number of residues before and after the substring to include during pooling.
 - Attention weights:
     - ```"attention_head"```: Asymmetrical pairwise attention weight matrices of input tokens from each self-attention head of the specified layer(s)
     - ```"attention_layer"```: Average of ```"attention_head"``` per specified layer.
@@ -38,4 +38,4 @@ pepe \
 The way PEPE outputs representations can be configured with the following arguments:
 - ```--streaming_output```: ```True``` (default) or ```False```.  PEPE preallocates the required disk space and writes each batch of outputs concurrently. Disable if encountering file system issues.
 - ```--precision```: ```full``` (default) or ```half```. Specifies whether to save representations as ```float32``` (full precision) or ```float16``` (half precision) numerical values for smaller file sizes.
-- ```--flatten```: ```True``` or ```False```(default). When enabled, two-dimensional embedding modes (e.g. ```"per_token"``` or ```"attention_layer"```) will be flattened to one-dimensional vector along the first axis.
+- ```--flatten```: ```True``` or ```False```(default). When enabled, two-dimensional embedding modes (e.g. ```"per_token"``` or ```"attention_layer"```) will be flattened to one-dimensional vector along the first axis.

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/examples/model_selection.md

@@ -50,6 +50,6 @@ pepe \
     --model_name "examples/custom_model/example_protein_model" \ # pass the directory path containing custom PyTorch model
     --tokenizer_from "alchemab/antiberta2-cssp" \ # Uses the same tokenizer as AntiBERTa2-CSSP
     --fasta_path "src/tests/test_files/test.fasta" \
-    --output_path "src/tests/test_files/test_output" 
+    --output_path "src/tests/test_files/test_output"
 ```
 For details, see the [example_protein_model folder](examples/custom_model/example_protein_model) and the [python script](examples/custom_model/create_example_custom_model.py) for generating the example_protein_model files.

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/pyproject.toml

@@ -11,15 +11,13 @@ authors = [
 description = "Pipeline for Easy Protein Embedding - Extract embeddings and attention matrices from protein sequences"
 readme = "README.md"
 license = {text = "MIT"}
-requires-python = ">=3.8"
+requires-python = ">=3.10"
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Science/Research",
     "License :: OSI Approved :: MIT License",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.8",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Topic :: Scientific/Engineering :: Bio-Informatics",
@@ -36,6 +34,19 @@ dependencies = [
     "rjieba",
 ]
 
+[project.optional-dependencies]
+esm = ["fair-esm"]
+# Developer toolchain: `pip install -e .[dev]` bootstraps everything needed to
+# run the hooks and the local test suite.
+dev = [
+    "pre-commit",
+    "ruff",
+    "mypy",
+    "pytest",
+    "pytest-cov",
+    "biopython",
+]
+
 [project.urls]
 Homepage = "https://github.com/csi-greifflab/pepe-cli"
 "Bug Reports" = "https://github.com/csi-greifflab/pepe-cli/issues"
@@ -78,3 +89,21 @@ module = [
     "pepe.utils",
 ]
 check_untyped_defs = true
+
+[tool.ruff]
+line-length = 88
+# Matches requires-python (>= 3.10) and the mypy python_version.
+target-version = "py310"
+src = ["src"]
+# Notebooks follow their own conventions (imports mid-cell, etc.); don't lint them.
+extend-exclude = ["notebooks", "*.ipynb"]
+
+[tool.ruff.lint]
+# Pyflakes (F), pycodestyle errors/warnings (E/W), import sorting (I).
+# E501 (line length) is owned by the formatter, which does not wrap strings or
+# comments; enforcing it as a lint rule would flag intentionally long lines.
+select = ["E", "W", "F", "I"]
+ignore = ["E501"]
+
+[tool.ruff.lint.isort]
+known-first-party = ["pepe"]

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/requirements.txt

@@ -6,4 +6,4 @@ sentencepiece
 numpy
 protobuf
 alive_progress
-rjieba
+rjieba

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/setup.py

@@ -1,10 +1,19 @@
-from setuptools import setup, find_packages
 import os
 import sys
 
+from setuptools import find_packages, setup
+
 # Add src to the Python path to import metadata
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
-from pepe import __version__, __package_name__, __author__, __author_email__, __description__, __homepage__, __module_name__
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+from pepe import (
+    __author__,
+    __author_email__,
+    __description__,
+    __homepage__,
+    __module_name__,
+    __package_name__,
+    __version__,
+)
 
 
 # Read the README file for long description
@@ -32,14 +41,12 @@ setup(
         "Operating System :: Linux",
         "Operating System :: macOS",
         "Programming Language :: Python :: 3",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
         "Topic :: Scientific/Engineering :: Bio-Informatics",
         "Topic :: Scientific/Engineering :: Artificial Intelligence",
     ],
-    python_requires=">=3.8",
+    python_requires=">=3.10",
     install_requires=[
         "torch>=1.9.0",
         "transformers>=4.20.0",
@@ -49,6 +56,9 @@ setup(
         "alive_progress",
         "rjieba",
     ],
+    extras_require={
+        "esm": ["fair-esm"],
+    },
     entry_points={
         "console_scripts": [
             f"pepe = {__module_name__}.__main__:main",

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/src/pepe/__init__.py

@@ -2,12 +2,14 @@ import logging
 import sys
 
 try:
-    from pepe.api import embed  # Exported to top-level; requires torch at runtime
+    from pepe.api import (
+        embed,  # noqa: F401  (re-exported to top level; needs torch at runtime)
+    )
 except ImportError:
     pass
 
 # Package metadata - single source of truth
-__version__ = "1.4.0"
+__version__ = "1.5.0"
 __package_name__ = "pepe-cli"
 __module_name__ = "pepe"
 __author__ = "Jahn Zhong"

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/src/pepe/__main__.py

@@ -1,5 +1,6 @@
 import logging
 import sys
+
 from pepe.parse_arguments import parse_arguments
 
 logger = logging.getLogger("pepe.__main__")

{pepe_cli-1.4.0 → pepe_cli-1.5.0}/src/pepe/api.py

@@ -1,14 +1,14 @@
+import logging
 import os
 import tempfile
-import logging
 from types import SimpleNamespace
-from typing import Dict, List, Optional, Union, Any
+from typing import Any, Dict, List, Optional, Union
 
 from pepe.model_selecter import select_model
-import pepe.utils
 
 logger = logging.getLogger("pepe.api")
 
+
 def embed(
     model_name: str,
     sequences: Optional[Union[Dict[str, str], List[str]]] = None,
@@ -23,7 +23,7 @@ def embed(
     discard_padding: bool = False,
     max_input_length: str = "max_length",
     experiment_name: Optional[str] = None,
-    **kwargs
+    **kwargs,
 ) -> Dict[str, Any]:
     """
     High-level API for generating protein embeddings.
@@ -52,8 +52,10 @@ def embed(
     if sequences is not None:
         if isinstance(sequences, list):
             sequences = {f"seq_{i}": seq for i, seq in enumerate(sequences)}
-            
-        temp_fasta = tempfile.NamedTemporaryFile(mode='w', suffix='.fasta', delete=False)
+
+        temp_fasta = tempfile.NamedTemporaryFile(
+            mode="w", suffix=".fasta", delete=False
+        )
         for label, seq in sequences.items():
             temp_fasta.write(f">{label}\n{seq}\n")
         temp_fasta.close()
@@ -65,11 +67,13 @@ def embed(
     return_results = False
     if output_path is None:
         if streaming_output:
-            logger.warning("No output_path provided. Disabling streaming_output and returning in-memory results.")
+            logger.warning(
+                "No output_path provided. Disabling streaming_output and returning in-memory results."
+            )
         output_path = tempfile.mkdtemp()
         streaming_output = False
         return_results = True
-    
+
     # Create args object
     args_dict = {
         "model_name": model_name,
@@ -97,26 +101,26 @@ def embed(
         "flush_batches_after": kwargs.get("flush_batches_after", 128),
         "verbose": kwargs.get("verbose", False),
     }
-    
+
     args = SimpleNamespace(**args_dict)
-    
+
     selected_model_class = select_model(
         model_name, trust_remote_code=args.trust_remote_code
     )
     embedder = selected_model_class(args)
     embedder.run()
-    
+
     results = {"output_path": output_path}
-    
+
     if return_results:
         # Pick up in-memory results before they are lost
         for output_type in extract_embeddings:
             obj = getattr(embedder, output_type, None)
             if obj and "output_data" in obj:
                 results[output_type] = obj["output_data"]
-    
+
     # Cleanup temp file
     if temp_fasta:
         os.unlink(temp_fasta.name)
-        
+
     return results