semvec/pypi-packages huggingface dataset:
surfio 0.0.15
Reader/Writer library for irap files.
Requires Python: >=3.11

# surfio

Surfio is a library for reading and writing surface files. Currently only supports the irap format.

## Installation

```bash
pip install .
```

## Usage

Irap surfaces can be imported using the `from_ascii_file`, `from_ascii_string`, `from_binary_file` and `from_binary_buffer` methods of `IrapSurface`.

```python
import surfio


surface = surfio.IrapSurface.from_ascii_file("./file.irap")
print(surface.header.ncol, surface.header.nrow) # 10, 11
print(surface.values.shape) # (10, 11)
```

`from_ascii_file` is equivalent to

```python
with open("./file.irap") as f:
    surface = surfio.IrapSurface.from_ascii_string(f.read())
```

but is more performant.

Exporting irap surfaces can be done with

```python
    surface = surfio.IrapSurface(
        surfio.IrapHeader(
            ncol=3,
            nrow=2,
            xori=0.0,
            yori=0.0,
            xinc=2.0,
            yinc=2.0,
            xmax=2.0,
            ymax=2.0,
            rot=0.0,
            xrot=0.0,
            yrot=0.0,
        ),
        values=np.zeros((3, 2)),
    )
    surface.to_ascii_file("./file.txt")
```

which is equivalent to:

```python
with open("./file.irap", mode="w") as f:
    f.write(surface.to_ascii_file())
```

## Development

```bash
pip install -e ".[dev]"
```

Style is enforced via pre-commit:

```bash
pre-commit install
```

## C++ development

To configure the project

```bash
cmake --preset release-posix
```

To build it

```bash
cmake --build --preset release-posix
```

To test it

```bash
ctest --preset release-posix
```
iflow-mcp_algonacci_mcp-wikipedia 0.1.0
Add your description here
Requires Python: >=3.11

# mcp-wikipedia

MCP server to give client the ability to access Wikipedia pages

# Usage

```json
{
  "mcpServers": {
    "wikipedia": {
      "command": "uv",
      "args": [
        "--directory",
        "%USERPROFILE%/Documents/GitHub/mcp-wikipedia",
        "run",
        "python",
        "main.py"
      ]
    }
  }
}
```
x402-omni-oracle 0.1.1
Agent-First Data Provider. Native tools for LangChain, AutoGen, and CrewAI.
Requires Python: >=3.9

# x402-omni-oracle

**The Agent-First Data Provider.**

This package provides native integration tools for **Omni-Oracle** services, compatible with:

- **LangChain**
- **AutoGen**
- **CrewAI**

## Installation

```bash
pip install x402-omni-oracle
```

## Usage

### LangChain

```python
from omni_oracle.langchain import getKLAXThermalRisk, getCoinGeckoPrice

tools = [getKLAXThermalRisk, getCoinGeckoPrice]
```

### AutoGen

```python
from omni_oracle.autogen import getSwarmPulse
# Register with generic autogen function registration
```

## Authentication

All data calls require **x402 Payment** (USDC on Base/Arbitrum/Solana).
By default, the tools will return a `402 Payment Required` message with instructions if unpaid.
To automate payments, configure the library with your agent's wallet key (Coming Soon).
topsis-vishwas-102317022 0.0.1
TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) Python package
Requires Python: >=3.6

# Topsis-Vishwas-102317022

This package implements the TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) method.

## Installation
```bash
pip install topsis-vishwas-102317022




topsis data.csv "1,1,1,2,1" "+,+,-,+,+" output.csv
beaver-ai 0.1.0
Python SDK for the Beaver AI Gateway
Requires Python: >=3.8

# Beaver AI Python SDK

Python SDK for the Beaver AI Gateway.

## Installation

```bash
pip install beaver-ai
```

## Quick Start

```python
from beaver_ai import Beaver

beaver = Beaver(api_key="your-api-key")

response = beaver.chat.completions.create(
    model="gemini-2.5-flash",
    messages=[
        {"role": "user", "content": "Hello, how are you?"}
    ]
)

print(response["choices"][0]["message"]["content"])
```

## Configuration

### Constructor Options

```python
beaver = Beaver(
    api_key="your-api-key",      # Required
    base_url="http://localhost:8080"  # Optional, defaults to http://localhost:8080
)
```

## API Reference

### Chat Completions

Create a chat completion request.

```python
response = beaver.chat.completions.create(
    model="gemini-2.5-flash",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the capital of France?"}
    ],
    temperature=0.7,           # Optional
    max_output_tokens=1000,    # Optional
    top_p=1.0                  # Optional
)
```

#### Request Parameters

- `model` (str, required): Model identifier
- `messages` (list[dict], required): List of message dictionaries with `role` and `content`
- `temperature` (float, optional): Sampling temperature (0-2)
- `max_output_tokens` (int, optional): Maximum tokens to generate
- `top_p` (float, optional): Nucleus sampling parameter

#### Response Format

```python
{
    "id": str,
    "model": str,
    "choices": [
        {
            "index": int,
            "message": {
                "role": "assistant",
                "content": str
            },
            "finish_reason": str | None
        }
    ],
    "usage": {  # Optional
        "prompt_tokens": int,
        "completion_tokens": int,
        "total_tokens": int
    }
}
```

## Error Handling

The SDK raises `BeaverError` for non-2xx responses.

```python
from beaver_ai import Beaver, BeaverError

beaver = Beaver(api_key="your-api-key")

try:
    response = beaver.chat.completions.create(
        model="gemini-2.5-flash",
        messages=[{"role": "user", "content": "Hello"}]
    )
except BeaverError as e:
    print(f"Error {e.status}: {e.message}")
    print(f"Code: {e.code}")
```

### Error Properties

- `status` (int): HTTP status code
- `code` (str | None): Beaver error code
- `message` (str): Error message

## Custom Base URL

```python
beaver = Beaver(
    api_key="your-api-key",
    base_url="https://api.beaver.example.com"
)
```

## Model Support

The SDK accepts model identifiers as strings. Currently supported and documented model: `gemini-2.5-flash`.

## Type Hints

The SDK includes type hints for better IDE support.

```python
from beaver_ai import ChatCompletionRequest, ChatCompletionResponse
```

## License

MIT
toword 0.0.1
Convert numbers into English words easily
Requires Python: >=3.7

# 📘 number_to_words

Convert integers into readable English words – simple, fast, and dependency-free.

[![PyPI version](https://img.shields.io/pypi/v/number_to_words.svg)](https://pypi.org/project/number_to_words/)
[![Python versions](https://img.shields.io/pypi/pyversions/number_to_words.svg)](https://pypi.org/project/number_to_words/)
[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)

---

## Overview

**number_to_words** is a lightweight Python package that converts numbers into English words.
It supports values from **0** up to **billions**, formatted just like humans speak.

✔ No dependencies
✔ Fast and accurate
✔ Easy to import and use
✔ Clean modular implementation

---

## Installation

Install using pip:

```bash
pip install number_to_words
```

---

## Usage

### Basic example

```python
import number_to_words as nw

print(nw.num(45))        # forty five
print(nw.num(2024))      # two thousand twenty four
print(nw.num(987654321)) # nine hundred eighty seven million six hundred fifty four thousand three hundred twenty one
```

### Importing the function directly

```python
from number_to_words import num

print(num(123))  # one hundred twenty three
```

---

## Supported Ranges

| Range                 | Example Output                    |
| --------------------- | --------------------------------- |
| 0–13                  | zero → thirteen                   |
| 14–19                 | fourteen → nineteen               |
| 20–99                 | twenty one, ninety nine           |
| 100–999               | one hundred fifty two             |
| 1,000–999,999         | twelve thousand three hundred ten |
| 1,000,000–999,999,999 | ninety eight million ...          |
| 1,000,000,000+        | up to billions                    |

---

## Project Structure

```
number_to_words/
    __init__.py
    main.py
    ds.py
    tens.py
    hundreds.py
    thousands.py
    millions.py
    billions.py
```

Each module handles one specific number range, making the code easy to maintain and extend.

---

## API Reference

### `num(x: int) -> str`

Convert any integer to its English representation.

**Example:**

```python
from number_to_words import num
num(1200305)
```

Output:

```
one million two hundred thousand three hundred five
```

---

## Contributing

Contributions, issues, and pull requests are welcome.

If you find this package useful, please consider giving the repository a ⭐ on  [GitHub!](https://github.com/Saumya-Kanti-Sarma/number_to_words)

---

## Contact

**Author:** Saumya Kanti Sarma
Email: **[work.saumyasarma@gmail.com](mailto:work.saumyasarma@gmail.com)**
Instagram: **[saumya__sarma](https://www.instagram.com/saumya__sarma/)**

Feel free to reach out for collaboration, questions, or feedback.
sphinx-docsearch 0.3.0
A Sphinx extension for replacing the built-in search with Algolia DocSearch
Requires Python: >=3.9

# Algolia DocSearch for Sphinx

This extension for the [Sphinx](https://www.sphinx-doc.org/en/master/) documentation generator
replaces Sphinx's built-in search with Algolia DocSearch.

## Before you begin

[**Apply for DocSearch**](https://docsearch.algolia.com/apply).
You'll get an email with your Algolia credentials.

This extension supports Python versions 3.9 and later and Sphinx versions 7 and later.

For a list of supported themes, see [HTML theme support](https://sphinx-docsearch.readthedocs.io/themes.html)

## Install

Install the `sphinx-docsearch` package:

```sh
pip install sphinx-docsearch
```

## Configure

1. Add `sphinx-docsearch` to your Sphinx configuration:

   ```python
   # conf.py
   extensions += ["sphinx_docsearch"]
   ```

1. Add your Algolia credentials to your Sphinx configuration:

   ```python
   # conf.py
   docsearch_app_id = "<DOCSEARCH_APP_ID>"
   docsearch_api_key = "<DOCSEARCH_SEARCH_API_KEY>"
   docsearch_index_name = "<DOCSEARCH_INDEX_NAME>"
   ```

   See also:

   - [Manage credentials](https://sphinx-docsearch.readthedocs.io/credentials.html)
   - [Configure DocSearch](https://sphinx-docsearch.readthedocs.io/configuration.html)

## Customize

To change what the crawler should extract from your pages,
see [Record Extractor](https://docsearch.algolia.com/docs/record-extractor).

If you're using a Sphinx theme that's not supported,
you can add custom templates to add the DocSearch UI.
You can further customize the look of the DocSearch UI by adding custom CSS.
For more information, see [Customize](https://sphinx-docsearch.readthedocs.io/customization.html).