BM25 0.3.0rc5__tar.gz

bm25-0.3.0rc5/BM25.egg-info/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: BM25
+Version: 0.3.0rc5
+Summary: A simple high-level API and CLI for BM25.
+Home-page: https://github.com/xhluca/bm25s/tree/main/bm25s/high_level
+Author: Xing Han Lù
+Author-email: bm25s@googlegroups.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: bm25s[cli,core]==0.3.0.rc5
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<div align="center">
+
+<h1>BM25</h1>
+
+<i>A fast, simple, and high-level Python API and CLI for BM25, powered by `bm25s`.</i>
+
+<table>
+      <tr>
+            <td>
+                  <a href="https://github.com/xhluca/bm25s">💻 GitHub</a>
+            </td>
+            <td>
+                  <a href="https://pypi.org/project/bm25s/">📦 bm25s</a>
+            </td>
+            <td>
+                  <a href="https://bm25s.github.io">🏠 Homepage</a>
+            </td>
+      </tr>
+</table>
+</div>
+
+`BM25` is a wrapper package that installs `bm25s` with its optional core dependencies, providing a simple, high-level API and a command-line interface for fast and effective text retrieval.
+
+## Installation
+
+Install `BM25` using pip:
+
+```bash
+pip install BM25
+```
+
+This will automatically install the highly optimized `bm25s` backend, alongside necessary dependencies for stemming (`PyStemmer`), parallelization, and CLI (`rich`).
+
+## High Level API
+
+If you want to quickly search on a local file, you can use the `BM25` module:
+
+```python
+import BM25
+
+# Load a file (csv, json, jsonl, txt)
+# For csv/jsonl, you can specify the column/key to use as document text
+corpus = BM25.load("tests/data/dummy.csv", document_column="text")
+# Index the corpus
+retriever = BM25.index(corpus)
+
+# Search
+results = retriever.search(["your query here"], k=5)
+for result in results[0]:
+    print(result)
+```
+
+The `load` function handles file reading, while `index` handles tokenization, indexing, and provides a simple search interface.
+
+## Command-Line Interface
+
+The package provides a terminal-based CLI for quick indexing and searching without writing Python code.
+
+### Indexing Documents
+
+Create an index from a CSV, TXT, JSON, or JSONL file:
+
+```bash
+# Index a CSV file (uses first column by default)
+bm25 index documents.csv -o my_index
+
+# Index with a specific column
+bm25 index documents.csv -o my_index -c text
+
+# Index a text file (one document per line)
+bm25 index documents.txt -o my_index
+
+# Index a JSONL file
+bm25 index documents.jsonl -o my_index -c content
+```
+
+If you don't specify an output directory with `-o`, the index will be saved to `<filename>_index`.
+
+### User Directory
+
+You can save indices to a central user directory (`~/.bm25s/indices/`) using the `-u` flag:
+
+```bash
+# Save index to ~/.bm25s/indices/my_docs
+bm25 index documents.csv -u -o my_docs
+
+# Search using the user directory
+bm25 search -u -i my_docs "your query"
+```
+
+### Searching
+
+Search an existing index with a query using `-i` (or `--index`):
+
+```bash
+# Basic search (returns top 10 results)
+bm25 search -i my_index "what is machine learning?"
+
+# Search with full path
+bm25 search -i ./path/to/my_index "your query here"
+
+# Return more results
+bm25 search -i my_index "your query here" -k 20
+
+# Save results to a JSON file
+bm25 search -i my_index "your query here" -s results.json
+```
+
+### Interactive Index Picker
+
+When using `-u` without specifying an index name, an interactive picker is displayed (requires `bm25s[cli]` which is installed by default with `BM25`):
+
+```bash
+# Interactive picker will show available indices
+bm25 search -u "your query"
+```
+
+### Example Workflow
+
+**Basic usage** (index saved to current directory):
+
+```bash
+# 1. Create a simple text file with documents
+echo -e "Machine learning is a subset of AI\nDeep learning uses neural networks\nNatural language processing handles text" > docs.txt
+
+# 2. Index the documents
+bm25 index docs.txt -o my_index
+
+# 3. Search the index
+bm25 search -i my_index "what is AI?"
+```
+
+**With user directory** (indices saved to `~/.bm25s/indices/`):
+
+```bash
+# Index to user directory
+bm25 index docs.txt -u -o ml_docs
+
+# Search from user directory
+bm25 search -u -i ml_docs "what is AI?"
+
+# Or use the interactive picker
+bm25 search -u "what is AI?"
+```
+
+## Flexibility
+
+For more advanced use cases, including memory mapping, customized tokenization, hugging face integration, or using different BM25 variants, please use the underlying `bm25s` API directly. 
+
+See the [bm25s documentation](https://github.com/xhluca/bm25s) for full details.

bm25-0.3.0rc5/BM25.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+setup.py
+./__init__.py
+BM25.egg-info/PKG-INFO
+BM25.egg-info/SOURCES.txt
+BM25.egg-info/dependency_links.txt
+BM25.egg-info/entry_points.txt
+BM25.egg-info/requires.txt
+BM25.egg-info/top_level.txt

bm25-0.3.0rc5/BM25.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bm25-0.3.0rc5/BM25.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bm25 = bm25s.cli:main

bm25-0.3.0rc5/BM25.egg-info/requires.txt

@@ -0,0 +1 @@
+bm25s[cli,core]==0.3.0.rc5

bm25-0.3.0rc5/BM25.egg-info/top_level.txt

@@ -0,0 +1 @@
+BM25

bm25-0.3.0rc5/PKG-INFO

@@ -0,0 +1,173 @@
+Metadata-Version: 2.4
+Name: BM25
+Version: 0.3.0rc5
+Summary: A simple high-level API and CLI for BM25.
+Home-page: https://github.com/xhluca/bm25s/tree/main/bm25s/high_level
+Author: Xing Han Lù
+Author-email: bm25s@googlegroups.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: bm25s[cli,core]==0.3.0.rc5
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<div align="center">
+
+<h1>BM25</h1>
+
+<i>A fast, simple, and high-level Python API and CLI for BM25, powered by `bm25s`.</i>
+
+<table>
+      <tr>
+            <td>
+                  <a href="https://github.com/xhluca/bm25s">💻 GitHub</a>
+            </td>
+            <td>
+                  <a href="https://pypi.org/project/bm25s/">📦 bm25s</a>
+            </td>
+            <td>
+                  <a href="https://bm25s.github.io">🏠 Homepage</a>
+            </td>
+      </tr>
+</table>
+</div>
+
+`BM25` is a wrapper package that installs `bm25s` with its optional core dependencies, providing a simple, high-level API and a command-line interface for fast and effective text retrieval.
+
+## Installation
+
+Install `BM25` using pip:
+
+```bash
+pip install BM25
+```
+
+This will automatically install the highly optimized `bm25s` backend, alongside necessary dependencies for stemming (`PyStemmer`), parallelization, and CLI (`rich`).
+
+## High Level API
+
+If you want to quickly search on a local file, you can use the `BM25` module:
+
+```python
+import BM25
+
+# Load a file (csv, json, jsonl, txt)
+# For csv/jsonl, you can specify the column/key to use as document text
+corpus = BM25.load("tests/data/dummy.csv", document_column="text")
+# Index the corpus
+retriever = BM25.index(corpus)
+
+# Search
+results = retriever.search(["your query here"], k=5)
+for result in results[0]:
+    print(result)
+```
+
+The `load` function handles file reading, while `index` handles tokenization, indexing, and provides a simple search interface.
+
+## Command-Line Interface
+
+The package provides a terminal-based CLI for quick indexing and searching without writing Python code.
+
+### Indexing Documents
+
+Create an index from a CSV, TXT, JSON, or JSONL file:
+
+```bash
+# Index a CSV file (uses first column by default)
+bm25 index documents.csv -o my_index
+
+# Index with a specific column
+bm25 index documents.csv -o my_index -c text
+
+# Index a text file (one document per line)
+bm25 index documents.txt -o my_index
+
+# Index a JSONL file
+bm25 index documents.jsonl -o my_index -c content
+```
+
+If you don't specify an output directory with `-o`, the index will be saved to `<filename>_index`.
+
+### User Directory
+
+You can save indices to a central user directory (`~/.bm25s/indices/`) using the `-u` flag:
+
+```bash
+# Save index to ~/.bm25s/indices/my_docs
+bm25 index documents.csv -u -o my_docs
+
+# Search using the user directory
+bm25 search -u -i my_docs "your query"
+```
+
+### Searching
+
+Search an existing index with a query using `-i` (or `--index`):
+
+```bash
+# Basic search (returns top 10 results)
+bm25 search -i my_index "what is machine learning?"
+
+# Search with full path
+bm25 search -i ./path/to/my_index "your query here"
+
+# Return more results
+bm25 search -i my_index "your query here" -k 20
+
+# Save results to a JSON file
+bm25 search -i my_index "your query here" -s results.json
+```
+
+### Interactive Index Picker
+
+When using `-u` without specifying an index name, an interactive picker is displayed (requires `bm25s[cli]` which is installed by default with `BM25`):
+
+```bash
+# Interactive picker will show available indices
+bm25 search -u "your query"
+```
+
+### Example Workflow
+
+**Basic usage** (index saved to current directory):
+
+```bash
+# 1. Create a simple text file with documents
+echo -e "Machine learning is a subset of AI\nDeep learning uses neural networks\nNatural language processing handles text" > docs.txt
+
+# 2. Index the documents
+bm25 index docs.txt -o my_index
+
+# 3. Search the index
+bm25 search -i my_index "what is AI?"
+```
+
+**With user directory** (indices saved to `~/.bm25s/indices/`):
+
+```bash
+# Index to user directory
+bm25 index docs.txt -u -o ml_docs
+
+# Search from user directory
+bm25 search -u -i ml_docs "what is AI?"
+
+# Or use the interactive picker
+bm25 search -u "what is AI?"
+```
+
+## Flexibility
+
+For more advanced use cases, including memory mapping, customized tokenization, hugging face integration, or using different BM25 variants, please use the underlying `bm25s` API directly. 
+
+See the [bm25s documentation](https://github.com/xhluca/bm25s) for full details.

bm25-0.3.0rc5/README.md

@@ -0,0 +1,150 @@
+<div align="center">
+
+<h1>BM25</h1>
+
+<i>A fast, simple, and high-level Python API and CLI for BM25, powered by `bm25s`.</i>
+
+<table>
+      <tr>
+            <td>
+                  <a href="https://github.com/xhluca/bm25s">💻 GitHub</a>
+            </td>
+            <td>
+                  <a href="https://pypi.org/project/bm25s/">📦 bm25s</a>
+            </td>
+            <td>
+                  <a href="https://bm25s.github.io">🏠 Homepage</a>
+            </td>
+      </tr>
+</table>
+</div>
+
+`BM25` is a wrapper package that installs `bm25s` with its optional core dependencies, providing a simple, high-level API and a command-line interface for fast and effective text retrieval.
+
+## Installation
+
+Install `BM25` using pip:
+
+```bash
+pip install BM25
+```
+
+This will automatically install the highly optimized `bm25s` backend, alongside necessary dependencies for stemming (`PyStemmer`), parallelization, and CLI (`rich`).
+
+## High Level API
+
+If you want to quickly search on a local file, you can use the `BM25` module:
+
+```python
+import BM25
+
+# Load a file (csv, json, jsonl, txt)
+# For csv/jsonl, you can specify the column/key to use as document text
+corpus = BM25.load("tests/data/dummy.csv", document_column="text")
+# Index the corpus
+retriever = BM25.index(corpus)
+
+# Search
+results = retriever.search(["your query here"], k=5)
+for result in results[0]:
+    print(result)
+```
+
+The `load` function handles file reading, while `index` handles tokenization, indexing, and provides a simple search interface.
+
+## Command-Line Interface
+
+The package provides a terminal-based CLI for quick indexing and searching without writing Python code.
+
+### Indexing Documents
+
+Create an index from a CSV, TXT, JSON, or JSONL file:
+
+```bash
+# Index a CSV file (uses first column by default)
+bm25 index documents.csv -o my_index
+
+# Index with a specific column
+bm25 index documents.csv -o my_index -c text
+
+# Index a text file (one document per line)
+bm25 index documents.txt -o my_index
+
+# Index a JSONL file
+bm25 index documents.jsonl -o my_index -c content
+```
+
+If you don't specify an output directory with `-o`, the index will be saved to `<filename>_index`.
+
+### User Directory
+
+You can save indices to a central user directory (`~/.bm25s/indices/`) using the `-u` flag:
+
+```bash
+# Save index to ~/.bm25s/indices/my_docs
+bm25 index documents.csv -u -o my_docs
+
+# Search using the user directory
+bm25 search -u -i my_docs "your query"
+```
+
+### Searching
+
+Search an existing index with a query using `-i` (or `--index`):
+
+```bash
+# Basic search (returns top 10 results)
+bm25 search -i my_index "what is machine learning?"
+
+# Search with full path
+bm25 search -i ./path/to/my_index "your query here"
+
+# Return more results
+bm25 search -i my_index "your query here" -k 20
+
+# Save results to a JSON file
+bm25 search -i my_index "your query here" -s results.json
+```
+
+### Interactive Index Picker
+
+When using `-u` without specifying an index name, an interactive picker is displayed (requires `bm25s[cli]` which is installed by default with `BM25`):
+
+```bash
+# Interactive picker will show available indices
+bm25 search -u "your query"
+```
+
+### Example Workflow
+
+**Basic usage** (index saved to current directory):
+
+```bash
+# 1. Create a simple text file with documents
+echo -e "Machine learning is a subset of AI\nDeep learning uses neural networks\nNatural language processing handles text" > docs.txt
+
+# 2. Index the documents
+bm25 index docs.txt -o my_index
+
+# 3. Search the index
+bm25 search -i my_index "what is AI?"
+```
+
+**With user directory** (indices saved to `~/.bm25s/indices/`):
+
+```bash
+# Index to user directory
+bm25 index docs.txt -u -o ml_docs
+
+# Search from user directory
+bm25 search -u -i ml_docs "what is AI?"
+
+# Or use the interactive picker
+bm25 search -u "what is AI?"
+```
+
+## Flexibility
+
+For more advanced use cases, including memory mapping, customized tokenization, hugging face integration, or using different BM25 variants, please use the underlying `bm25s` API directly. 
+
+See the [bm25s documentation](https://github.com/xhluca/bm25s) for full details.

bm25-0.3.0rc5/__init__.py

@@ -0,0 +1,252 @@
+"""
+The high level BM25 search API. It wraps bm25s into a simple to use search interface,
+enabling 1-line indexing and 1-line searching. By default, it will require:
+- numba compilation for speed up
+- stemming for better search quality
+- stopword removal for better search quality
+"""
+
+import json
+import csv
+from pathlib import Path
+from bm25s import BM25
+from bm25s.tokenization import Tokenizer
+import Stemmer
+from typing import List
+
+
+
+class BM25Search:
+    def __init__(
+        self,
+        corpus: List[str],
+        language: str = "english",
+        bm25_kwargs: dict = None,
+        tokenizer_kwargs: dict = None,
+        tokenizer_cls: Tokenizer = Tokenizer,
+    ):
+        if bm25_kwargs is not None and "corpus" in bm25_kwargs:
+            raise ValueError(
+                "The 'corpus' argument in bm25_kwargs is reserved and cannot be set manually."
+            )
+        if language != "english":
+            raise NotImplementedError("Currently only English language is supported.")
+        
+        self.leave_progress = leave_progress = False
+        self.show_progress = show_progress = True
+        self.corpus = corpus
+
+        stemmer = Stemmer.Stemmer("english")
+        bm25_kwargs_default = dict(
+            backend="numba", csc_backend="numpy", auto_compile=False
+        )
+        tokenizer_kwargs_default = dict(
+            stemmer=stemmer, stopwords="english", lower=True
+        )
+
+        if isinstance(bm25_kwargs, dict):
+            bm25_kwargs_default.update(bm25_kwargs)
+        elif bm25_kwargs is not None:
+            raise ValueError("bm25_kwargs must be a dict or None.")
+
+        if isinstance(tokenizer_kwargs, dict):
+            tokenizer_kwargs_default.update(tokenizer_kwargs)
+        elif tokenizer_kwargs is not None:
+            raise ValueError("tokenizer_kwargs must be a dict or None.")
+
+        if "corpus" in bm25_kwargs_default:
+            raise ValueError(
+                "The 'corpus' argument in bm25_kwargs is reserved and cannot be set manually."
+            )
+
+        # note: we do not pass corpus here, as we will keep it separately. This means the BM25
+        # object will return document ids instead of texts when retrieving.
+        self.retriever = BM25(**bm25_kwargs_default)
+        self.tokenizer: Tokenizer = tokenizer_cls(**tokenizer_kwargs_default)
+
+        # tokenize the corpus
+        tokenized = self.tokenizer.tokenize(
+            corpus,
+            leave_progress=leave_progress,
+            show_progress=show_progress,
+            update_vocab=True,
+            return_as="tuple",
+        )
+
+        # compile and index (warmup=False to avoid segfaults in some CI environments)
+        self.retriever.compile(activate_numba=True, warmup=False)
+        
+        create_empty_token = True
+        # If the corpus is empty or has no tokens, we can't create an empty token
+        # as it relies on vocab dict having some content or logic that fails if empty
+        if len(tokenized.vocab) == 0:
+            create_empty_token = False
+            
+        self.retriever.index(
+            tokenized,
+            leave_progress=leave_progress,
+            show_progress=show_progress,
+            create_empty_token=create_empty_token,
+        )
+
+    def search(self, queries: List[str], k: int = 10, n_jobs: int = 1):
+        # Ensure k is not larger than the corpus size
+        num_docs = len(self.corpus)
+        if k > num_docs:
+            k = num_docs
+
+        tokenized_queries = self.tokenizer.tokenize(
+            queries,
+            update_vocab=False,
+            show_progress=self.show_progress,
+            leave_progress=self.leave_progress,
+            return_as="tuple",
+            allow_empty=False,
+        )
+        
+        # Handle empty queries explicitly to avoid issues with Numba backend
+        # We filter out queries that result in no tokens
+        non_empty_indices = []
+        empty_indices = []
+        
+        # We access internal ids list from Tokenized namedtuple
+        # Convert to string list first as retrieve expects that or Tokenized object
+        # But checking emptiness is easier on ids
+        
+        for i, q_ids in enumerate(tokenized_queries.ids):
+            if len(q_ids) > 0:
+                non_empty_indices.append(i)
+            else:
+                empty_indices.append(i)
+        
+        # Prepare results structure
+        results = [None] * len(queries)
+        
+        # Process empty queries immediately
+        for i in empty_indices:
+            # Empty query results in empty list of documents
+            # Or do we want to return empty docs with 0 score? 
+            # Standard BM25 usually returns nothing for empty query, or 0 score for all docs.
+            # Let's return empty list as top-k results.
+            results[i] = []
+
+        if len(non_empty_indices) > 0:
+            # Create a new Tokenized object for non-empty queries
+            non_empty_ids = [tokenized_queries.ids[i] for i in non_empty_indices]
+            non_empty_tokenized = self.tokenizer.to_tokenized_tuple(non_empty_ids)
+            
+            # Retrieve for non-empty queries
+            # note: because we did not pass `corpus` when initializing BM25,
+            # the retrieve() will return document ids instead of texts.
+            doc_ids, scores = self.retriever.retrieve(
+                query_tokens=non_empty_tokenized,
+                k=k,
+                sorted=True,
+                return_as="tuple",
+                show_progress=self.show_progress,
+                leave_progress=self.leave_progress,
+                n_threads=n_jobs,
+                chunksize=50,
+                backend_selection="auto",
+            )
+            
+            # Map back to original indices
+            num_docs = doc_ids.shape[1]
+            
+            for idx, original_idx in enumerate(non_empty_indices):
+                query_results = []
+                for di in range(num_docs):
+                    doc_id = doc_ids[idx, di]
+                    doc_text = self.corpus[doc_id]
+                    query_results.append(
+                        {
+                            "id": int(doc_id),
+                            "score": float(scores[idx, di]),
+                            "document": doc_text,
+                        }
+                    )
+                results[original_idx] = query_results
+
+        return results
+
+
+def index(documents, language: str = "english"):
+    return BM25Search(corpus=documents, language=language)
+
+
+def load(path, document_column=None):
+    """
+    Loads a csv, json, jsonl, or txt file from the given path. For json, we expect a list of dicts.
+    Returns a list of strings (corpus) that can be passed to `bm25s.index`.
+
+    Parameters
+    ----------
+    path : str
+        The file path to load the documents from.
+
+    document_column : str, optional
+        The column name to use as the document text when loading from csv, or the key when loading from json/jsonl.
+        If None, the first column will be used by default.
+    
+    Returns
+    -------
+    List[str]
+        A list of strings representing the documents.
+    """
+
+    path = Path(path)
+    documents = []
+
+    if path.suffix == ".txt":
+        with open(path, "r", encoding="utf-8") as f:
+            documents = [line.strip() for line in f if line.strip()]
+
+    elif path.suffix == ".json":
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+            if isinstance(data, list):
+                if len(data) > 0 and isinstance(data[0], str):
+                    documents = data
+                elif len(data) > 0 and isinstance(data[0], dict):
+                    if document_column is None:
+                        # Use the first key available in the first element
+                        document_column = list(data[0].keys())[0]
+                    documents = [d[document_column] for d in data]
+            else:
+                raise ValueError("JSON file must contain a list of strings or dicts.")
+
+    elif path.suffix == ".jsonl":
+        with open(path, "r", encoding="utf-8") as f:
+            for line in f:
+                if not line.strip():
+                    continue
+                d = json.loads(line)
+                if document_column is None and not documents:
+                    # Infer column from first line
+                    document_column = list(d.keys())[0]
+                
+                if document_column in d:
+                    documents.append(d[document_column])
+                else:
+                    # skip or error? Let's skip if key missing, or error. 
+                    # raising error is safer for "load"
+                    raise ValueError(f"Key '{document_column}' not found in JSONL line: {line[:50]}...")
+
+    elif path.suffix == ".csv":
+        with open(path, "r", newline="", encoding="utf-8") as f:
+            reader = csv.DictReader(f)
+            if document_column is None:
+                if reader.fieldnames:
+                    document_column = reader.fieldnames[0]
+                else:
+                    return BM25Search(corpus=[])
+
+            for row in reader:
+                if document_column in row:
+                    documents.append(row[document_column])
+                else:
+                     raise ValueError(f"Column '{document_column}' not found in CSV.")
+    else:
+        raise ValueError(f"Unsupported file extension: {path.suffix}")
+
+    return documents

bm25-0.3.0rc5/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

bm25-0.3.0rc5/setup.py

@@ -0,0 +1,42 @@
+from setuptools import setup
+import os
+import sys
+
+# Change to the current directory to avoid issues if run from elsewhere
+current_dir = os.path.dirname(os.path.abspath(__file__))
+os.chdir(current_dir)
+
+package_name = "BM25"
+version = {}
+with open(os.path.join("..", "version.py"), encoding="utf8") as fp:
+    exec(fp.read(), version)
+
+with open("README.md", encoding="utf8") as fp:
+    long_description = fp.read()
+
+setup(
+    name=package_name,
+    version=version["__version__"],
+    author="Xing Han Lù",
+    author_email="bm25s@googlegroups.com",
+    url="https://github.com/xhluca/bm25s/tree/main/bm25s/high_level",
+    description="A simple high-level API and CLI for BM25.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    packages=["BM25"],
+    package_dir={"BM25": "."},
+    install_requires=[
+        f"bm25s[core,cli]=={version['__version__']}",
+    ],
+    entry_points={
+        "console_scripts": [
+            "bm25=bm25s.cli:main",
+        ],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.8",
+)