semvec/pypi-packages huggingface dataset:
zk-rag-image-generator 1.1.0
Tool plugin for zk-rag to generate images with stable diffusion 3.5 medium
Requires Python: >=3.11

# zk-rag-image-generator

A plugin for zk-rag that enables image generation using Stable Diffusion 3.5 Medium model.

## Description

This plugin provides a tool to generate images from textual descriptions using the Stable Diffusion 3.5 Medium model. It can be used to enhance your RAG (Retrieval-Augmented Generation) applications with image generation capabilities.

## Features

- Generate images from textual descriptions
- Save generated images as PNG files
- Integration with mojentic LLM tools
- Comprehensive error handling
- Configurable through a gateway pattern

## Installation

```bash
pip install zk-rag-image-generator
```

## Usage

The plugin will be automatically discovered by zk-rag when installed. It provides the `GenerateImage` tool which can be used to create images from textual descriptions.

Example usage through zk-rag:

```python
from zk_rag import get_tool

image_tool = get_tool("generate_image")
filename = image_tool.run(
    image_description="A serene mountain landscape at sunset with snow-capped peaks and a clear lake reflecting the orange sky",
    base_filename="mountain_sunset"
)
print(f"Image saved as: {filename}")  # Will print: Image saved as: mountain_sunset.png
```

## Requirements

- Python >= 3.11
- mojentic (LLM tools framework)
- torch, torchvision, torchaudio (PyTorch stack)
- diffusers (Stable Diffusion implementation)
- transformers (Hugging Face Transformers)
- accelerate (Hardware acceleration support)
- safetensors (Model weight handling)
- Additional dependencies: scipy, protobuf, sentencepiece

For the complete list with specific versions, see `requirements.txt`.

## Local Development

1. Clone the repository
2. Install dependencies:
   ```bash
   pip install -r requirements.txt
   pip install -r dev-requirements.txt
   ```
3. Install pre-commit hooks (recommended):
   ```bash
   # Create a pre-commit hook that runs pytest
   cat > .git/hooks/pre-commit << 'EOL'
   #!/bin/sh

   # Run pytest
   echo "Running pytest..."
   python -m pytest

   # Store the exit code
   exit_code=$?

   # Exit with pytest's exit code
   exit $exit_code
   EOL

   # Make the hook executable
   chmod +x .git/hooks/pre-commit
   ```

## Testing Guidelines

- Tests are co-located with implementation files
- Run tests: `pytest`
- Linting: `flake8 src`
- Code style:
  - Max line length: 127
  - Max complexity: 10
  - Follow numpy docstring style

### Testing Best Practices
- Use pytest for testing, with mocker if you require mocking
- Do not use unittest or MagicMock directly
- Use @fixture markers for pytest fixtures
- Break up fixtures into smaller fixtures if they are too large
- Separate test phases with a single blank line
- Each test must fail for only one clear reason
- Only write mocks for our own gateway classes

## License

MIT License

## Author

Stacey Vetzal (stacey@vetzal.com)
zk-rag-wikipedia 1.1.0
Tool plugin for zk-rag to search Wikipedia
Requires Python: >=3.11

# zk-rag-wikipedia Plugin

A plugin for zk-rag that enables Wikipedia content lookup functionality.

## Description

This plugin provides a tool to search and retrieve content from Wikipedia articles. It can be used to enhance your RAG (Retrieval-Augmented Generation) applications with Wikipedia knowledge.

## Features

- Search Wikipedia articles
- Retrieve article summaries
- Handle disambiguation pages
- Comprehensive error handling

## Installation

```bash
pip install zk-rag-wikipedia
```

## Usage

The plugin will be automatically discovered by zk-rag when installed. It provides the `LookUpTopicOnWikipedia` tool which can be used to retrieve information about specific topics from Wikipedia.

Example usage through zk-rag:

```python
from zk_rag import get_tool

wikipedia_tool = get_tool("wikipedia")
result = wikipedia_tool.run("Python programming language")
print(result.title)  # The article title
print(result.content)  # The article summary
print(result.url)  # The Wikipedia URL
```

## Requirements

- Python >= 3.11
- mojentic
- wikipedia

## Local Development

To set up this project for local development:

1. Clone the repository:
   ```bash
   git clone https://github.com/yourusername/zk-rag-wikipedia.git
   cd zk-rag-wikipedia
   ```

2. Create and activate a virtual environment:
   ```bash
   python -m venv .venv
   source .venv/bin/activate  # On Windows, use: .venv\Scripts\activate
   ```

3. Install development dependencies:
   ```bash
   pip install -r requirements.txt
   pip install -r dev-requirements.txt
   ```

4. Install the package in editable mode:
   ```bash
   pip install -e .
   ```

## Building Locally

To build the package locally:

1. Ensure you have the build dependencies:
   ```bash
   pip install build
   ```

2. Build the package:
   ```bash
   python -m build
   ```

This will create both wheel and source distribution in the `dist/` directory.

## Running Tests

To run the tests:
```bash
pytest
```

## License

MIT License

## Author

Stacey Vetzal (stacey@vetzal.com)
antitesting 0.0.12
No more testing
Requires Python: >=3.8

![logo](https://raw.githubusercontent.com/pomponchik/antitesting/main/docs/assets/logo_2.png)

[![Downloads](https://static.pepy.tech/badge/antitesting/month)](https://pepy.tech/project/antitesting)
[![Downloads](https://static.pepy.tech/badge/antitesting)](https://pepy.tech/project/antitesting)
[![codecov](https://codecov.io/gh/pomponchik/antitesting/graph/badge.svg?token=jHPEZfRrjC)](https://codecov.io/gh/pomponchik/antitesting)
[![Test-Package](https://github.com/pomponchik/antitesting/actions/workflows/tests_and_coverage.yml/badge.svg)](https://github.com/pomponchik/antitesting/actions/workflows/tests_and_coverage.yml)
[![Hits-of-Code](https://hitsofcode.com/github/pomponchik/antitesting?branch=main)](https://hitsofcode.com/github/pomponchik/antitesting/view?branch=main)
[![Python versions](https://img.shields.io/pypi/pyversions/antitesting.svg)](https://pypi.python.org/pypi/antitesting)
[![PyPI version](https://badge.fury.io/py/antitesting.svg)](https://badge.fury.io/py/antitesting)
[![Checked with mypy](http://www.mypy-lang.org/static/mypy_badge.svg)](http://mypy-lang.org/)
[![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)


There are standard ways to temporarily disable individual tests. As an example, using of the [`pytest.mark.skip`](https://docs.pytest.org/en/latest/how-to/skipping.html#skipping-test-functions) decorator. This plugin adds a new way to do this by extending the standard features of Pytest. Now you can put the names of the disabled tests in a separate file, and then correct and supplement them without going into the source code of the tests.

Install the plugin:

```bash
pip install antitesting
```

Create one or more files containing the names of the tests that you want to disable. In our example, this will be a file `disabled_tests.txt` containing the text like this:

```
test_1
test_2 : 12.12.2012
test_3 : 12.12.2025
test_4 : 13.12.2025 # fix after test_3
```

Finally, add these lines to the file `conftest.py`:

```python
import antitesting  # If you use static type analyzers like mypy, importing using the expression "from antitesting import antitesting" is more suitable for you.

antitesting("disabled_tests.txt")
```

The `disabled_tests.txt` file that we created contains the names of the tests that we want to disable. This is equivalent to putting a  [`skip`](https://docs.pytest.org/en/latest/how-to/skipping.html#skipping-test-functions) decorator on each of them, but it does not require getting into the source code of the tests and saves you time. You could also see the dates in the file in the format `DD.MM.YYYY`. If there is a date in this format in the line with the test name, the test will be ignored only until that date, and after that it will become available. If necessary, you can accompany the lines with comments separated by sharps ("#").
podium-lib 0.1.0
Class-based data-expression framework.
Requires Python: >=3.10

# Podium

Class-based data-expression framework.

## Installation

```bash
# with Astral uv
uv pip install podium-lib

# with pip
pip install podium-lib

# get latest version
git clone https://github.com/lucas-nelson-uiuc/podium-lib.git
```

## Getting Started

```python
import podium_lib
from podium_lib import Model, Field

housing_data = podium_lib.load("california_housing") # TODO: support this method


# create your first class
class CaliforniaHousing(Model):
    latitude: float
    longitude: float

print(CaliforniaHousing.schema())


# add converters and validators to your fields
from podium_lib import validators as pv, converters as pc

class CaliforniaHousing(Model):
    latitude: float = Field(
        converter=pc.field.round(0),
        validator=pv.field.between(32, 42)
    )
    longitude: float = Field(
        converter=pc.field.round(0),
        validator=pv.field.between(114, 124)
    )

print(CaliforniaHousing.workflow())
CaliforniaHousing.validate(housing_data)
```

## Why Podium?

Podium has a few simple - yet powerful - goals in mind:
- Reduce the need to know how to interact with data objects (e.g. DataFrame APIs)
- Simplify the ability to express expectations of your data objects

## Inspiration

The name of this package came about in the following manner:
- This package implements `narwhals` - a group of narwhals is considered a **pod**
- This package is an opinionated workflow orchestrator, so a podium seems a
fitting environment to share these opinions
supercorp-explorium-mcp-server 0.1.3
MCP server for interacting with the Explorium API.
Requires Python: >=3.10

## 🌎 Explorium MCP Server
Explorium MCP server is a [Model Context Protocol](https://modelcontextprotocol.io/introduction) server for interacting with the [Explorium API](https://developers.explorium.ai/reference/overview).

### Obtain an Explorium API key

Follow the instructions in the [Explorium API documentation](https://developers.explorium.ai/reference/getting_your_api_key) to obtain an API key.

Your API key will be used to authenticate your requests to the Explorium API through the MCP server.

### Usage with Claude Desktop

To use the MCP server with Claude Desktop, add the following to your `claude_desktop_config.json` file:

```json
{
  "mcpServers": {
    "Explorium": {
      "command": "python",
      "args": ["-m", "explorium_mcp_server"],
      "env": {
        "EXPLORIUM_API_KEY": "MY_API_KEY"
      }
    }
  }
}
```

Replace `MY_API_KEY` with your actual Explorium API key.

Replace `python` with the path to your Python executable (such as `python3`).
devshare 1.0.0
Secure peer-to-peer file transfer CLI with encryption.
Requires Python: >=3.7

# DevShare - Secure File Transfer via CLI

DevShare is a peer-to-peer file transfer CLI with AES-256 encryption.

## 🔹 Installation
```bash
pip install devshare

🔹 Usage

Send a File

devshare send myfile.txt --password SecurePass123

Receive a File

devshare receive ABC123 --password SecurePass123
json-to-dataclass 1.0.0
Useful tool for mapping out dataclasses based on JSON structure with typing
Requires Python: <4.0,>=3.12

# JSON to Dataclass

Just a simple tool that creates dataclasses from JSON files by assessing the JSON schema structure and 
building typed dataclasses into a .py file

### Requirements
_______
>Python 3.12

### Installation
______

`pip install json_to_dataclass`

### Command Syntax
_____

cd {DIRECTORY}
`$ python json_to_dataclass.py -h`

```optional arguments:
  -h, --help            show this help message and exit
  -i INPUT, --input INPUT
                        Direct system path to a JSON file (default: ${CWD}/sample.json)
  -o OUTPUT, --output OUTPUT
                        Directory the place output .py file with Dataclass (default: ${CWD}/sample.py)
  -d DIRECTORY, --directory DIRECTORY
                        Directory to JSON files, will parse all files within into data classes. (default: ${CWD}/sample.json)
  -n NAME, --name NAME  Name of parent Dataclass (default: GeneratedDataclass)
  -ad APPLY_DEFAULTS, --apply_defaults APPLY_DEFAULTS
                        Apply default values for all fields using the values within provided JSON file (default: None)
```
emd 0.8.1
Empirical Mode Decomposition
Requires Python: >=3.9
Keywords: EMD, Frequency, Hilbert-Huang, Holospectrum, Non-Linear, Spectrum

A python package for Empirical Mode Decomposition and related spectral analyses.

Please note that this project is in active development for the moment - the API may change relatively quickly between releases!

# Installation

You can install the latest stable release from the PyPI repository

```
pip install emd
```

or clone and install the source code.

```
git clone https://gitlab.com/emd-dev/emd.git
cd emd
pip install .
```

Requirements are specified in requirements.txt. Main functionality only depends
on numpy and scipy for computation and matplotlib for visualisation.

# Quick Start

Full documentation can be found at https://emd.readthedocs.org and development/issue tracking at gitlab.com/emd-dev/emd

Import emd

```python
import emd
```

Define a simulated waveform containing a non-linear wave at 5Hz and a sinusoid at 1Hz.

```python
sample_rate = 1000
seconds = 10
num_samples = sample_rate*seconds

import numpy as np
time_vect = np.linspace(0, seconds, num_samples)

freq = 5
nonlinearity_deg = .25  # change extent of deformation from sinusoidal shape [-1 to 1]
nonlinearity_phi = -np.pi/4  # change left-right skew of deformation [-pi to pi]
x = emd.simulate.abreu2010(freq, nonlinearity_deg, nonlinearity_phi, sample_rate, seconds)
x += np.cos(2*np.pi*1*time_vect)
```

Estimate IMFs

```python
imf = emd.sift.sift(x)
```

Compute instantaneous frequency, phase and amplitude using the Normalised Hilbert Transform Method.

```python
IP, IF, IA = emd.spectra.frequency_transform(imf, sample_rate, 'hilbert')
```
Compute Hilbert-Huang spectrum

```python
freq_range = (0, 10, 100)  # 0 to 10Hz in 100 steps
f, hht = emd.spectra.hilberthuang(IF, IA, freq_range, sum_time=False)
```
```
Make a summary plot

```python
import matplotlib.pyplot as plt
plt.figure(figsize=(16, 8))
plt.subplot(211, frameon=False)
plt.plot(time_vect, x, 'k')
plt.plot(time_vect, imf[:, 0]-4, 'r')
plt.plot(time_vect, imf[:, 1]-8, 'g')
plt.plot(time_vect, imf[:, 2]-12, 'b')
plt.xlim(time_vect[0], time_vect[-1])
plt.grid(True)
plt.subplot(212)
plt.pcolormesh(time_vect, f, hht, cmap='ocean_r')
plt.ylabel('Frequency (Hz)')
plt.xlabel('Time (secs)')
plt.grid(True)
plt.show()
```
griffe-typedoc 0.1.0
Signatures for entire TypeScript programs using TypeDoc.
Requires Python: >=3.10

# Griffe TypeDoc

[![documentation](https://img.shields.io/badge/docs-mkdocs-708FCC.svg?style=flat)](https://mkdocstrings.github.io/griffe-typedoc/)
[![gitter](https://badges.gitter.im/join%20chat.svg)](https://app.gitter.im/#/room/#griffe-typedoc:gitter.im)

Signatures for entire TypeScript programs using [TypeDoc](https://typedoc.org/).

WARNING: **Still in prototyping phase!**
Feedback is welcome.

## Installation

This project is available to sponsors only, through my Insiders program. See Insiders [explanation](https://mkdocstrings.github.io/griffe-typedoc/insiders/) and [installation instructions](https://mkdocstrings.github.io/griffe-typedoc/insiders/installation/).

## Usage

Add these [TypeDoc](https://typedoc.org/) configuration files to your repository:

```tree hl_lines="4 5"
./
    src/
        package1/
    typedoc.base.json
    typedoc.json
```

```json title="typedoc.base.json"
{
  "$schema": "https://typedoc.org/schema.json",
  "includeVersion": true
}
```

```json title="typedoc.json"
{
  "extends": ["./typedoc.base.json"],
  "entryPointStrategy": "packages",
  "entryPoints": ["./src/*"]
}
```

Update the entrypoints to match your file layout so that TypeDoc can find your packages. See [TypeDoc's configuration documentation](https://typedoc.org/options/configuration/).

Then in each of your package, add this TypeDoc configuration file:

```tree hl_lines="4"
./
    src/
        package1/
            typedoc.json
    typedoc.base.json
    typedoc.json
```

```json title="typedoc.json"
{
  "extends": ["../../typedoc.base.json"],
  "entryPointStrategy": "expand",
  "entryPoints": ["src/index.d.ts"]
}
```

Again, update entrypoints to match your file and package layout. See [TypeDoc's configuration documentation](https://typedoc.org/options/configuration/).

**Your packages must be built for TypeDoc to work.**

Finally, load your TypeScript API data with Griffe TypeDoc:

```python
from griffe_typedoc.loader import load

data = load(
    "typedoc",  # name or path of the typedoc executable
    working_directory=".",  # point at your monorepo
)
```

See our [API reference](https://mkdocstrings.github.io/griffe-typedoc/reference/griffe_typedoc/).