semvec/pypi-packages huggingface dataset:
bp-agent 0.5.1
Minimal task execution agent framework
Requires Python: >=3.10
Keywords: agent, llm, automation, task

# bp-agent

> For the developer's vision and thoughts behind this project, see [HUMANS.md](../HUMANS.md).

Minimal task execution agent framework with multi-provider LLM support.

## Features

- **Multi-provider**: Gemini, Codex (OpenAI), Opus with automatic key rotation
- **Streaming**: Real-time token streaming for chat responses
- **Tool system**: Built-in tools (bash, read_file, write_file, list_dir) + custom tools
- **Subagents**: Spawn worker agents for parallel task execution
- **Chat mode**: Multi-turn conversation with tool support
- **Task queue**: Persistent JSON-based task scheduling

## Install

```bash
pip install bp-agent
```

## Quick Start

```bash
# Set API key
export GEMINI_API_KEY=your_key

# Interactive chat (streaming)
bp-chat

# Chat with a specific provider
bp-chat --provider codex
bp-chat --provider opus --model my-model
```

## Providers

| Provider | Env Vars | Models |
|----------|----------|--------|
| Gemini (default) | `GEMINI_API_KEY` | gemini-3-flash-preview, gemini-3-pro-preview |
| Codex | `CODEX_API_KEY` or `~/.codex/auth.json` | gpt-5.2-codex, gpt-5.1-codex-mini, ... |
| Opus | `OPUS_API_KEY` + `OPUS_BASE_URL` | configurable |

Multiple keys supported via `GEMINI_API_KEY_2`, `_3`, etc. or comma-separated `GEMINI_API_KEYS`.

## Python API

```python
from bp_agent import Agent, AgentConfig

# Task execution
agent = Agent("my-agent")
result = agent.execute("List all Python files in src/")
print(result.output)

# Multi-turn chat
response = agent.chat("What files are in this directory?")
print(response)

# Streaming chat
for chunk in agent.chat_stream("Explain this codebase"):
    print(chunk, end="", flush=True)

# Custom tools
from bp_agent.tools import ToolSchema
agent.add_tool("greet", lambda name: f"Hello, {name}!", ToolSchema(
    name="greet",
    description="Greet someone",
    parameters={"type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"]},
))
```

## License

GPL-3.0
eqdsk 0.8.0
A reader, writer and converter for the eqdsk format
Requires Python: >=3.10
Keywords: GEQDSK, cocos, eqdsk, tokamak

# Eqdsk

[![Hatch project](https://img.shields.io/badge/%F0%9F%A5%9A-Hatch-4051b5.svg)](https://github.com/pypa/hatch)
[![linting - Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
![Downloads](https://img.shields.io/pypi/dm/eqdsk?color=blue)
[![Actions status](https://github.com/Fusion-Power-Plant-Framework/eqdsk/actions/workflows/main_and_pr.yml/badge.svg)](https://github.com//Fusion-Power-Plant-Framework/eqdsk/actions)

An EQDSK reader and writer for GEQDSK (more soon), with COCOS identification and conversion.

There is support for writing an eqdsk to a JSON format (which is now preferred) and an IMAS database integration.

We have extended the EQDSK standard to optionally allow for the definition of a CoilSet.

## Setup

We are pip installable therefore for the most recent release:

```bash
pip install eqdsk
```

or for the most recent commit

```bash
pip install git+https://github.com/Fusion-Power-Plant-Framework/eqdsk.git
```

For a developer setup please see [CONTRIBUTING.md](CONTRIBUTING.md#setup-with-hatch)

## Basic Usage

To read in an eqdsk (json or eqdsk) in its raw state:

```python
from eqdsk import EQDSKInterface

EQDSKInterface.from_file('file.json', no_cocos=True)
```

To read in an eqdsk file with a known cocos format and convert it to a given cocos format:

```python
EQDSKInterface.from_file('file.eqdsk', from_cocos=11, to_cocos=17)
```

Alternatively if the direction (clockwise or anticlockwise) and the units of phi (V.s or V.s/rad) are known,
the cocos standard will be calculated for you:

```python
EQDSKInterface.from_file('file.eqdsk', clockwise_phi=True, volt_seconds_per_radian=True)
```

## CLI

This package includes a CLI tool for eqdsk exploration.

This can be accessed by running `eqdsk` in the terminal after installing the package (or in the Hatch `cli` environment, see [CONTRIBUTING.md](CONTRIBUTING.md#setup-with-hatch)).

For more information on the CLI tool, run `eqdsk --help`.
asteca 0.6.3
Stellar cluster analysis package
Requires Python: >=3.12
Keywords: astrophysics, cluster

<div align="center">
  <br>
  <img src="https://raw.githubusercontent.com/asteca/ASteCA/main/docs/_static/asteca_icon.webp" alt="asteca" width="200"/>
  <br>
</div>


# ASteCA [Automated Stellar Cluster Analysis]
[![AA](https://img.shields.io/badge/A%26A-576--A6,%202015-yellowgreen.svg)][1]
[![License](https://img.shields.io/badge/license-MIT-blue)][2]

**ASteCA** is a package designed to automatize the usual analysis applied on star
clusters, in order to estimate their characteristics and fundamental parameters.

Install with:

```
pip install asteca
```

See the [documentation](https://asteca.github.io) for more details. If you use this
package in your research, please cite its accompanying [article][1] using the following
Bibtex:

````
@article{Perren_2015,
    author = {{Perren, G. I.} and {V\'azquez, R. A.} and {Piatti, A. E.}},
    title = {ASteCA: Automated Stellar Cluster Analysis},
    DOI= "10.1051/0004-6361/201424946",
    url= "http://dx.doi.org/10.1051/0004-6361/201424946",
    journal = {A\&A},
    year = 2015,
    volume = 576,
    pages = "A6",
    month = "04",
}
````

[1]: http://www.aanda.org/articles/aa/abs/2015/04/aa24946-14/aa24946-14.html
[2]: https://opensource.org/license/mit/
[3]: http://asteca.github.io
[4]: https://github.com/asteca/asteca/releases/latest
dais-sdk 0.6.16
A wrapper of LiteLLM
Requires Python: >=3.14

# Dais-SDK

Dais-SDK is a wrapper of LiteLLM which provides a more intuitive API and [AI SDK](https://github.com/vercel/ai) like DX.

## Installation

```
pip install dais_sdk
```

## Examples

Below is a simple example of just a API call:

```python
import os
from dotenv import load_dotenv
from dais_sdk import LLM, LlmProviders, LlmRequestParams, UserMessage

load_dotenv()

llm = LLM(provider=LlmProviders.OPENAI,
          api_key=os.getenv("API_KEY", ""),
          base_url=os.getenv("BASE_URL", ""))

response = llm.generate_text_sync( # sync API of generate_text
    LlmRequestParams(
        model="deepseek-v3.1",
        messages=[UserMessage(content="Hello.")]))
print(response)
```

Below is an example that shows the automatically tool call:

```python
import os
from dotenv import load_dotenv
from dais_sdk import LLM, LlmProviders, LlmRequestParams, UserMessage

load_dotenv()

def example_tool():
    """
    This is a test tool that is used to test the tool calling functionality.
    """
    print("The example tool is called.")
    return "Hello World"

llm = LLM(provider=LlmProviders.OPENAI,
          api_key=os.getenv("API_KEY", ""),
          base_url=os.getenv("BASE_URL", ""))

params = LlmRequestParams(
        model="deepseek-v3.1",
        tools=[example_tool],
        execute_tools=True,
        messages=[UserMessage(content="Please call the tool example_tool.")])

print("User: ", "Please call the tool example_tool.")
messages = llm.generate_text_sync(params)
for message in messages:
    match message.role:
        case "assistant":
            print("Assistant: ", message.content)
        case "tool":
            print("Tool: ", message.result)
```

## Development

Create virtual environment
```
uv venv
```

Install all dependencies
```
uv sync --all-groups
```

Run test
```
uv run pytest
```