semvec/pypi-packages huggingface dataset:
rpgFactory 0.0.1
A simple RPG factory to create monsters
Requires Python: >=3.8

# tartaro

Description.
The package tartaro is used to: - creation of list with monsters for basics adventures of RPG

## Installation

Use the package manager [pip](https://pip.pypa.io/en/stable/) to install tartaro

```bash
pip install tartaro
```

## Usage

```python
from tartaro import equidna
equidna = Equidna("Equidna", "Equidna", 0)
horde1 = equidna.create_horde("Beast", "Beast", 1, 2, 5, 10)
```

## Author

[Marcelo Batista](https://github.com/Marcelo-Batista)

## License

[MIT](https://choosealicense.com/licenses/mit/)
ai-agent2agent 0.1.1
A Python library for Agent-to-Agent communication
Requires Python: >=3.8

# AI Agent2Agent

A Python library for Agent-to-Agent communication.

## Installation

```bash
pip install ai_agent2agent
```

## Usage

### Client

```python
from agent2agent import A2AClient, A2ACardResolver

# Initialize client
client = A2AClient(url="https://your-agent-endpoint.com", api_key="your-api-key")

# Example: Send a task to an agent
response = client.send_task(
    message={
        "role": "user",
        "parts": [{"type": "text", "text": "Hello, Agent!"}]
    }
)

# Print the task ID
print(f"Task ID: {response.id}")
```

### Server

```python
from agent2agent import A2AServer, InMemoryTaskManager

# Initialize server with an in-memory task manager
task_manager = InMemoryTaskManager()
server = A2AServer(task_manager=task_manager)

# Register handler for tasks
@server.handle_task
async def handle_task(task):
    # Process the task
    return {
        "role": "agent",
        "parts": [{"type": "text", "text": "Task completed!"}]
    }

# Run the server (depends on your web framework)
```

## Features

- Client-server architecture for agent communication
- Support for various message types (text, files, data)
- Task management with different states
- In-memory caching
- Push notification support

## License

MIT
dicedb 0.1.1
A simple DiceDB client for Python
Requires Python: >=3.8

# DiceDB for Python

⚠️ This is not an official sdk for python and still in development.

## Installation and Usage

### From PyPI

```bash
pip install dicedb
```

### From Source

Clone the repository and install the package:

```bash
$ git clone https://github.com/un4gt/dicedb.git --depth 1 --branch main
$ uv sync
$ uv buid
```

## Supported Commands

|    command    | description  |
|:-------------:|:------------:|
|    `decr`     |   `DECRBY`   |
|   `decrby`    |   `DECRBY`   |
|   `delete`    |    `DEL`     |
|    `echo`     |    `ECHO`    |
|   `exists`    |   `EXISTS`   |
|   `expire`    |   `EXPIRE`   |
|  `expire_at`  |  `EXPIREAT`  |
| `expire_time` | `EXPIRETIME` |
|   `flushdb`   |  `FLUSHDB`   |
|     `get`     |    `GET`     |
|   `get_del`   |  `GET_DEL`   |
|   `get_ex`    |   `GET_EX`   |
|    `hget`     |    `HGET`    |
|  `hget_all`   |  `HGETALL`   |
|    `hset`     |    `HSET`    |
|   `incr_by`   |   `INCRBY`   |
|    `incr`     |   `INCRBY`   |
|    `ping`     |    `PING`    |
|     `ttl`     |    `TTL`     |
|   `typeof`    |    `TYPE`    |
|     `set`     |    `SET`     |


## Roadmap

- [ ] More documentation/tests/examples
- [ ] Support for all commands
- [ ] Connection pool
- [ ] Support for async


## Contributing

PRs and issues are welcome! 

## About Developing

### Generate Python Proto Files

*cmd.proto and res.proto comes from https://github.com/DiceDB/dicedb-protos*

On Windows: 

```bash
protoc -I=protos\ --python_out=src\dicedb\proto\ --pyi_out=src\dicedb\proto cmd.proto res.proto
```
atopile-auth 0.1.3
A package to help manage authentication for atopile
Requires Python: >=3.13

# atopile-auth

A tiny package to help manage authentication for atopile to supabase via CLI and FastAPI.

## Installation

Client:

```bash
uv add atopile-auth
```

Server:

```bash
uv add "atopile-auth[server]"
```

## Pitfalls

```
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xff in position 0: invalid start byte
```

This happens when trying to return the `ClaimsResponse` object, rather than the `claims` attribute/field via FastAPI.
hezarfenai 0.1.3
A Teknofest project named HezarfenAI Official Python Package
Requires Python: >=3.6

# HezarfenAI - Official Python Package

## List Of Content

- [Installation](#installation)
- [Usage](#usage)
- [Contributing](#contributing)
- [License](#license)

## Installation

To install HezarfenAI, run the following command:

```bash
pip install hezarfenai
```

## Usage

To use HezarfenAI, import it in your Python script:

```python
import hezarfenai
```

import hezarfenai

## Contributing

Contributions are welcome! Please read our [contributing guidelines](CONTRIBUTING.md) for more information.

## License

HezarfenAI is licensed under the [MIT License](LICENSE).

## Acknowledgments

We would like to thank the following organizations for their support:

- [HezarfenAI](https://www.hezarfenai.com/)
msys2-env 2025.4.23.0
Create Python virtual environment using MSYS2. (Windows only)
Requires Python: >=3.10

# msys2_env

<a href="https://pypi.org/project/msys2_env/">
    <img alt="PyPI - Version" src="https://img.shields.io/pypi/v/msys2_env">
</a>

Create python virtual environment using MSYS2.

## Install

```
pip install -U msys2_env
msys2_env --init
```

## usage

`msys2_env`: create a msys2 env in `venv`. the name can be specified via `--venv [name]`. The creation usually takes 3-5 minutes.

provide venv-like directory:

![tree directory](https://github.com/soda92/msys2_env/raw/main/image.png)

together with helper scripts:
- `.venv2/Scripts/Activate.ps1`: powershell activation script.
- `pack_install`: install msys2 packages.
- `pack_remove`: remove msys2 packages.
- `bash`: bash launcher.
- `fish`: fish launcher.


## command line help

```
msys2_env -h
usage: msys2_env [-h] [--init] [--venv VENV] [--wrapper]

options:
  -h, --help   show this help message and exit
  --init       download and init msys2
  --venv VENV  venv name
  --wrapper    reinstall the shell wrapper
```
setuptools-gopy 0.0.9
Setuptools Gopy extension plugin
Requires Python: >=3.13
Keywords: distutils, setuptools, go, golang

# Setuptools plugin for Gopy extensions

`setuptools-gopy` is a plugin for `setuptools` to build Go Python extensions using [`gopy`](https://github.com/go-python/gopy).

## Usage

You can configure `setuptools-gopy` either through `pyproject.toml` or `setup.py`:

```toml
[build-system]
requires = ["setuptools", "setuptools-gopy >= 0.0.7"]
build-backend = "setuptools.build_meta"

[project]
name = "simple"
version = "0.0.1"

[tool.setuptools.packages]
find = { where = ["python"] }

[[tool.setuptools-gopy.ext-packages]]
# the name of the package to create (e.g. this will create hello.py, _hello.DYLIB_SUFFIX and go.py in the simple package)
name = "simple.hello"
# name of the package to build (as would be accessible through the go cli)
go_package = "github.com/LouisBrunner/setuptools-gopy/examples/simple"
# optional: select which version of Go to install (otherwise expects the system to have it installed)
go_version = "1.24.1"
```

```python
from setuptools import find_packages, setup

from setuptools_gopy import GopyExtension

setup(
    name="simple",
    version="0.0.1",
    packages=find_packages(where="python"),
    package_dir={"": "python"},
    gopy_extensions=[
        GopyExtension(
            # same as above
            "simple.hello",
            "github.com/LouisBrunner/setuptools-gopy/examples/simple",
            go_version="1.24.1"
        )
    ],
)
```

In either case, you need to provide a `target`: this is the name of the Go package which should be built.

Once built, you can import Go symbols like so:

```python
from .hello import Hello
```

Note that the name of the file will match the Go `package` that you imported.

## Examples

 * [`examples/simple`](examples/simple) shows a simple example of calling a Go function from Python
 * Check [`gopy-ha-proton-drive`](https://github.com/LouisBrunner/gopy-ha-proton-drive) for a real-life example

## Acknowledgements

 * This repository is heavily inspired by [`setuptools-rust`](https://github.com/PyO3/setuptools-rust), thanks to them!
blazor-microfrontends-python 1.0.0
Python SDK for Blazor Microfrontends
Requires Python: >=3.8

# Blazor Microfrontends Python SDK

A Python SDK for integrating Python microfrontends with Blazor applications.

## Installation

1. Create a virtual environment:
```bash
python3 -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
```

2. Install the SDK:
```bash
pip install -e .
```

## Usage

### App Shell Configuration

1. Initialize an app shell:
```bash
blazor-mf appshell init --name "MyAppShell" --version "1.0.0"
```

2. Add a microfrontend to the app shell:
```bash
blazor-mf appshell add "my-microfrontend" "http://localhost:5000" "/my-path"
```

3. List all microfrontends:
```bash
blazor-mf appshell list
```

### Microfrontend Development

1. Initialize a new microfrontend:
```bash
blazor-mf microfrontend init --name "MyMicrofrontend" --version "1.0.0"
```

2. Add routes to your microfrontend:
```bash
blazor-mf microfrontend add-route "/dashboard" "DashboardComponent"
```

3. List all routes:
```bash
blazor-mf microfrontend list-routes
```

### Flask Integration

```python
from flask import Flask, render_template
from blazor_microfrontends import MicrofrontendApi, microfrontend_route

app = Flask(__name__)
api = MicrofrontendApi(__name__)

@microfrontend_route(api, "/dashboard", "DashboardComponent")
@app.route('/dashboard')
def dashboard():
    return render_template('dashboard.html')

if __name__ == '__main__':
    app.run(debug=True)
```

### Django Integration

```python
from django.shortcuts import render
from blazor_microfrontends import MicrofrontendApi, microfrontend_route

api = MicrofrontendApi(__name__)

@microfrontend_route(api, "/dashboard", "DashboardComponent")
def dashboard(request):
    return render(request, 'dashboard.html')
```

## Configuration

### App Shell Configuration (appshell.yaml)

```yaml
name: MyAppShell
version: 1.0.0
microfrontends:
  - name: dashboard
    url: http://localhost:5000
    path: /dashboard
  - name: profile
    url: http://localhost:5001
    path: /profile
```

### Microfrontend Configuration (microfrontend.json)

```json
{
  "name": "MyMicrofrontend",
  "version": "1.0.0",
  "routes": [
    {
      "path": "/dashboard",
      "component": "DashboardComponent"
    }
  ]
}
```

## Development

1. Install development dependencies:
```bash
pip install -e ".[dev]"
```

2. Run tests:
```bash
pytest
```

3. Format code:
```bash
black .
```

4. Run type checking:
```bash
mypy .
```

## License

MIT License
pvWebMonitor 2021.0.3rc1
Create static web site from EPICS PVs.
Requires Python: >=3.9
Keywords: EPICS, PV, tool, HTML

.. _pvWebMonitor:

============
pvWebMonitor
============

**Create static web site from EPICS PVs.**

This package provides a background service that monitors EPICS PVs 
and writes them into customized HTML files in a WWW server 
directory.  The service can be started and stopped by a manage.csh 
script for automated startup in a cron task or at system startup.

:author: 	Pete R. Jemian
:email:  	jemian@anl.gov
:copyright: 2002-2025, University of Chicago, The Regents of the University of California, and Berliner Elektronenspeicherring Gesellschaft fuer Synchrotronstrahlung m.b.H. (BESSY) All rights reserved.
:license:   EPICS (see *LICENSE*)
:docs:      https://bcda-aps.github.io/pvWebMonitor/
:git:       https://github.com/BCDA-APS/pvWebMonitor.git
:PyPI:      https://pypi.python.org/pypi/pvWebMonitor

:publishing:
   .. image:: https://img.shields.io/github/tag/prjemian/pvWebMonitor.svg
      :target: https://github.com/BCDA-APS/pvWebMonitor/tags
   .. image:: https://img.shields.io/github/release/prjemian/pvWebMonitor.svg
      :target: https://github.com/BCDA-APS/pvWebMonitor/releases
midjourney-mcp 0.1.1
A MCP server for generating images with Midjourney
Requires Python: >=3.10

# Midjourney MCP

A MCP server implementation for generating images with Midjourney.



```json
{
    "mcpServers": {
        "midjourney": {
            "command": "uvx",
            "args": [
                "midjourney-mcp"
            ]
        }
    }

}
```


- `TOKEN_R`: Midjourney auth token R
- `TOKEN_I`: Midjourney auth token I
- `API_BASE`: Midjourney API base URL (optional, defaults to "midjourney.com")


## API

The server provides the following tool:

- `generating_image(prompt: str, aspect_ratio: str) -> str`
  - `prompt`: Description of the image you want to generate
  - `aspect_ratio`: Aspect ratio of the image (e.g. "16:9")

## License

This project is licensed under the GNU General Public License v3.0 (GPL-3.0). This means:
VanJr 0.1.0
VanJr: A lightweight Python library for streamlined data processing, EDA, and machine learning workflows.
Requires Python: >=3.7

# VanJr 📊🔥

**VanJr** is a Python library designed to simplify and accelerate data preprocessing, exploratory data analysis (EDA), and machine learning model development. Whether you're a beginner or an experienced data scientist, VanJr brings a clean, intuitive interface for working with datasets from start to finish.

---

## 🚀 Key Features

- 🧾 **Data Collection**: Load datasets from CSV, Excel, or URLs.
- 🔍 **EDA (Exploratory Data Analysis)**: Quick insights and visualizations.
- 🧹 **Data Cleaning**: Handle missing values, duplicates, and outliers.
- ⚙️ **Data Transformation**: Type conversion, encoding, scaling.
- 🧠 **Modeling**: Train/test split, train models, evaluate performance.
- ⚖️ **Balancing**: Fix imbalanced datasets with ease.
- 💾 **Save Results**: Export cleaned data to CSV or database.

---

## 🛠️ Installation

```bash
pip install VanJr


## Usage
```python
from VanJr import VanJr

vj = VanJr("your_dataset.csv")
vj.inspect()
vj.preprocess()
vj.train_model()
vj.evaluate_model()
datos-gob-es-mcp 0.1.0
Open data from Spain Government API integration with MCP (Model Context Protocol)
Requires Python: >=3.10

[![en](https://img.shields.io/badge/lang-en-red.svg)](README.md)
[![es](https://img.shields.io/badge/lang-es-yellow.svg)](README_es.md)

# Datos.gob.es-MCP. MCP integration with the Spanish Government Open Data Portal

**Datos.gob.es-mcp** enables querying and analyzing over 90,000 public datasets available on the [datos.gob.es](https://datos.gob.es/es/) portal directly from Claude AI and other compatible MCP clients using the **Model Context Protocol (MCP)**.

This MCP server exposes tools for LLMs to search, filter, and access open data across multiple sectors.

## Main features

- **Keyword search** across dataset titles, descriptions and tags.
- **Thematic category filtering** (environment, transportation, education, etc.)
- **Detailed metadata access** for each dataset.
- **Available distributions** listing (formats and access URLs)
- **Custom SPARQL queries** execution against the official SPARQL endpoint.

## Installation

### Install via uv

### Prerequisites

- Python 3.10 or higher
- [uv](https://docs.astral.sh/uv/getting-started/installation/) package manager

### uv Installation

First install `uv`, a modern Python package manager.
**Install from command line**:

En MAC y Linux:

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

En Windows:

```bash
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

También se puede instalar con pip:

```bash
pip install uv
```

For more information about installing **uv**, visit the [uv documentation](https://docs.astral.sh/uv/getting-started/installation/).

## Integration with clients like Claude for Desktop

Once **uv** is installed, you can use the MCP server with any compatible client like Claude Desktop. Configuration steps:

1. Go to **Claude > Settings > Developer > Edit Config > `claude_desktop_config.json`**
2. Add this configuration block under `"mcpServers"`:

```json
"datos_gob_es_mcp": {
    "command": "uvx",
    "args": [
        "datos_gob_es_mcp"
    ]
}
```

3. If you have other MCP servers configured, separate them with commas `,`

For other MCP-compatible clients like Cursor, CODEGPT or Roo Code, add the same configuration block to their respective MCP server settings.

## Usage Examples

Once properly configured, you can request operations like:

```
- `"Search for public transportation datasets in Madrid"`
- `"List latest datasets published by Barcelona City Council"`
- `"Show details for dataset with URI https://datos.gob.es/es/catalogo/l01330241-padron-de-vehiculos-ano-2023-autobuses"`
---