semvec/pypi-packages huggingface dataset:
biskit 3.0.1
A Python platform for structural bioinformatics

Biskit is a modular, object-oriented Python library for structural
 bioinformatics research. It facilitates the manipulation and analysis
 of macromolecular structures, protein complexes, and molecular
 dynamics trajectories. For efficient number crunching, Biskit objects
 tightly integrate with numpy. Biskit also offers a platform for the
 integration of external programs and new algorithms into complex
 workflows. Calculations are thus often delegated to established
 programs like Xplor-NIH, Amber, Delphi, T-Coffee, TMAlign, Reduce and
 Modeller.
deep-research-agent 0.1.0
An AI-powered deep research agent for autonomous web research
Requires Python: >=3.9

# Deep Research Agent

[![PyPI version](https://badge.fury.io/py/deep-research-agent.svg)](https://badge.fury.io/py/deep-research-agent)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

An AI-powered research agent that autonomously searches the web, analyzes content, and generates comprehensive research reports on any topic.

## Features

- **Automated Web Research**: Generate search queries, scrape content, and synthesize information
- **Multi-cycle Research**: Progressively build deeper understanding with multiple research cycles
- **Reflective Analysis**: Identify knowledge gaps and areas for further exploration
- **Structured Reports**: Generate well-organized markdown reports with clear sections
- **Multiple Interfaces**: Use via command line, Python API, or Streamlit web UI

## Installation

```bash
pip install deep-research-agent
```

## Usage

### Command Line

```bash
deep-research --topic "Your research topic" --cycles 2 --output report.md
```

### Streamlit UI

```bash
deep-research-ui
```

Then open your browser to the URL shown (typically http://localhost:8501).

### Python API

```python
from deep_research_agent import ResearchConfig, ResearchController

# Configure research parameters
config = ResearchConfig(
    topic="Your research topic",
    max_research_cycles=2,
    max_search_results_per_query=5,
    max_urls_to_scrape_per_cycle=3
)

# Initialize and run the research controller
controller = ResearchController(config)
results = controller.run_full_research()

# Access the final report
print(results["final_report"])
```

## Requirements

- Python 3.9+
- Local LLM (Ollama with QwQ model recommended)

## Environment Configuration

Create a `.env` file with:

```
OLLAMA_BASE_URL=http://localhost:11434
OLLAMA_MODEL=qwq
```

## How It Works

1. **Query Generation**: Creates effective search queries based on the topic and current knowledge
2. **Web Search**: Retrieves search results from DuckDuckGo
3. **Content Scraping**: Extracts and cleans content from web pages
4. **Summary Generation**: Integrates new information with existing knowledge
5. **Reflection**: Identifies gaps and contradictions to guide further research
6. **Report Generation**: Creates a comprehensive final report

## License

MIT License - see LICENSE file for details.
spacy-cymraeg 0.1.1
An installable version of Techiaith's cy model for SpaCy
Requires Python: >=3.9

# Spacy Cymraeg

A package makes the `cy` language package from [github.com/techiaith/spacy/](https://github.com/techiaith/spacy/tree/welsh/spacy/lang)
installable and usable without having to modify the files within the virtual environment.

## Install package
To install the package using `uv` run the following command:
```bash
uv add spacy-cymraeg
```
or you can install the repository directly like so:
```bash
uv add git+https://gitlab.com/prvInSpace/spacy-cymraeg
```

## Using the package
The language is not loaded by default, so you need to register the language.
You can do this by adding the following line of code to your code:
```python
import spacy_cymraeg
```
By importing the package the language gets registered as `cy` which means that you can use models that depend on it
such as the `cy_techiaith_tag_lem_ner_lg` pipeline which you can find on [github.com/techiaith/spacy_cy_tag_lem_ner_lg](https://github.com/techiaith/spacy_cy_tag_lem_ner_lg).

To use the package with `cy_techiaith_tag_lem_ner_lg` please also install that package by running the following command:
```bash
uv add https://github.com/techiaith/spacy_cy_tag_lem_ner_lg/releases/download/23.03/cy_techiaith_tag_lem_ner_lg-0.0.1.tar.gz"
```

and then you can use it on code like so:
```python
import spacy
import spacy_cymraeg

nlp = spacy.load("cy_techiaith_tag_lem_ner_lg")
doc = nlp("Lansiodd David Hill Jones ei gyfrol newydd The Singularity Show yn nigwyddiad y Cyngor Llyfrau yn Aberystwyth yn gynharach heddiw.")
for item in [(t, t.lemma_, t.pos_, t.morph, t.ent_type_, t.vector_norm) for t in doc]:
    print (item)
```

**N.B.:** Note that `cy_techiaith_tag_lem_ner_lg` depends on a `numpy<2`, so make sure that you are using something like `1.26` or something.
persistent-bm25 0.4
A persistent implementation of BM25 retrieval.
Requires Python: >=3.7

# persistent_bm25

persistent_bm25 is a Python package that provides a persistent implementation of BM25 retrieval.

## Installation

You can install it via pip:

```bash
pip install persistent_bm25
```


## Usage

```python
from persistent_bm25 import PersistentBM25Retriever
from langchain_core.documents import Document
docs = [
    Document(page_content="LangChain makes AI powerful"),
    Document(page_content="BM25 is a ranking function for search"),
]

# Create retriever
bm25_retriever = PersistentBM25Retriever.from_documents(docs)
bm25_retriever.persist("./bm25_retriever")

loaded_bm25_retriever = PersistentBM25Retriever.from_persist_dir("./bm25_retriever")

results = loaded_bm25_retriever.get_relevant_documents("AI search")
print(results)
```
pyformlang 1.0.11
A python framework for formal grammars

# pyformlang

[![Python package](https://github.com/Aunsiels/pyformlang/actions/workflows/python-package.yml/badge.svg)](https://github.com/Aunsiels/pyformlang/actions/workflows/python-package.yml)
[![pypi](https://img.shields.io/pypi/v/pyformlang.svg)](https://pypi.org/project/pyformlang/)
[![Documentation](https://readthedocs.org/projects/pyformlang/badge/?version=latest)](https://pyformlang.readthedocs.io/en/latest/)
![badge](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/Aunsiels/135f01c630063c3e69d999a2edf59fdb/raw/coverage_pyformlang.json)


A python library to manipulate formal grammar. In general, it can be used to better understand algorithms in a formal way.

If you use Pyformlang in your project, please cite our paper:

```
@InProceedings{pyformlang,
author="Romero, Julien",
title="Pyformlang: An Educational Library for Formal Language Manipulation",
booktitle="SIGCSE",
year="2021"
doi = {https://doi.org/10.1145/3408877.3432464}
}
```

## Installation

```bash
pip3 install pyformlang
```

## Sources

Most algorithms come from Introduction to *Automata Theory, Languages, and Computation*
(2nd edition) by John E. Hopcroft, Rajeev Motwani and Jeferey D. Ullman.

Indexed grammars come from the original paper *Index Grammars - An Extension of Context-free grammars* by Alfred V. Aho.

On the implementation of Hopcroft minimization algorithm: [Implementation of Hopcroft's Algorithm, Hang Zhou](https://www.irif.fr/~carton/Enseignement/Complexite/ENS/Redaction/2009-2010/hang.zhou.pdf)

[Intersection CFG/Regex](https://www.degruyter.com/downloadpdf/j/stuf.1961.14.issue-1-4/stuf.1961.14.14.143/stuf.1961.14.14.143.pdf) and [a better written version](http://www.cs.umd.edu/~gasarch/BLOGPAPERS/cfg.pdf)

## Usage

Please refer to the official documentation: [pyformlang.readthedocs.io](https://pyformlang.readthedocs.io).
bitpapa-pay 0.2.4
Bitpapa Pay async python wrapper
Requires Python: <4.0,>=3.8

# Bitpapa Pay asynchronous api wrapper

**Docs**: https://apidocs.bitpapa.com/docs/apidocs/wvea40l9be95f-integracziya-bitpapa-pay

## Installation

Install bitpapa-pay

```
pip install bitpapa-pay
```

## Usage/Examples

```python
import asyncio

from bitpapa_pay import BitpapaPay


async def main():
    bitpapa_pay = BitpapaPay(api_token="api_token")
    # Создаем крипто инвойс
    crypto_invoice = await bitpapa_pay.create_crypto_invoice(
        amount=1, currency_code="USDT",
        private_message="test crypto invoice message",
        paid_button_name="open_bot",
        paid_button_url="https://google.com"
    )
    print(crypto_invoice)

    # Создаем фиат инвойс
    fiat_invoice = await bitpapa_pay.create_fiat_invoice(
        accepted_crypto=["USDT"],
        fiat_amount=10,
        fiat_currency_code="RUB",
        expiration_time=29,
        merchant_invoice_id="test merchant id 123",
        paid_button_name="callback",
        paid_button_url="https://google.com",
        private_message="test fiat invoice message"
    )
    print(fiat_invoice)

    # Получаем инвойсы
    invoices = await bitpapa_pay.get_invoices(page=3)
    print(invoices)

    await bitpapa_pay.close()


if __name__ == "__main__":
    asyncio.run(main())
```
zxart 0.3.5
Asynchronous Python client for the ZXArt.ee API.
Requires Python: <3.14,>=3.12
Keywords: api, async, client, zxart, zxspectrum

# Python: Asynchronous ZXArt.ee API Client

![PyPI - Python Version](https://img.shields.io/pypi/pyversions/zxart)
![PyPI - Version](https://img.shields.io/pypi/v/zxart)
![PyPI - Status](https://img.shields.io/pypi/status/zxart)
![PyPI - License](https://img.shields.io/pypi/l/zxart)
![PyPI - Downloads](https://img.shields.io/pypi/dm/zxart)

## About

Simple asynchronous Python [ZXArt.ee](https://zxart.ee/) API client.

## Installation

```bash
pip install zxart
```