semvec/pypi-packages huggingface dataset:
radnn 0.2.4
Rapid Deep Neural Networks
Requires Python: >=3.10

# RaDNN - Rapid Deep Neural Networks

RaDNN is a library that aims to assist Machine Learning research and development, by minimizing the time needed for trivial functionality, streamlining experiments and standardizing the development of neural network models and datasets. It follows an object-oriented approach, employing software design patterns. 

## 🚀 Key Features

-   The notion of the `mlsystem` that is the sandbox of the ML Engineer / Data Scientist. 
-   In the `mlsystem` there is a central file store for `datasets`, a file store for `configs` of experiments and a file store for storing trained `models` along with the experiment artifacts.
-   Experiment reproducibility for `torch` and `tensorflow` , taking into account GPU non-determinism.
-   All hyperparameters for an experiment (architectural, data, training, ...) are organized in `json` configuration files, that are used as python dictionaries.
-   Allows for rapid development of file system related functionality. The class `FileStore` encapsulates the use of `os`, `shutil`, `pickle`, `json` and other packages that are trivial to the objective of the ML research and development process.
-   Follows a composition approach to rapidly develop custom Neural Network models. 
-   Layers are organized into *neural modules*, that are organized into *neural blocks*, that belong to an *encoder* / *decoder* part of the model.
-   Data are organized following hierarchical grouping to rapidly re-use samples in k-fold experiments.
-   The notion of dataset caches, speeds up the data feeding during training of models.
-   Library of image data pipeline method, support for image tensor standardization, and combos of image augmentation techniques.
-   Several classes for common plots that are deployed rapidly in comparison to custom `matplotlib`development.
-   Provides evaluator objects for calculating metrics. 

------------------------------------------------------------------------

## 📦 Installation

Install via pip:

``` bash
pip install radnn
```


------------------------------------------------------------------------

## 🧠 Quick Start

``` python
from radnn import mlsys, FileSystem
from radnn.plot import PlotImage

# Get the file store for the CIFAR10 dataset
mlsys.filesys = FileSystem(dataset_folder="/home/user/MLData")
fs = mlsys.filesys.datasets.subfs("CIFAR10")

# Deserialize the original sample set dictionary
dCIFAR10Test = fs.obj.load("test_batch", is_python2_format=True)
dCIFAR10ClassName = {0: "airplane", 1: "automobile", 2: "bird", 3: "cat", 4: "deer",
               5: "dog", 6: "frog", 7: "horse", 8: "ship", 9: "truck"}

# Get the first image, its label and the corresponding class, to create a title for the plot
nFirstImage = dCIFAR10Test["data"][0].reshape([-1, 3, 32, 32]).transpose([0, 2, 3, 1])
nFirstImageLabel = dCIFAR10Test["labels"][0]
sFirstImageClass = dCIFAR10ClassName[nFirstImageLabel]
sTitle = f"First image in CIFAR10 validation set is a {sFirstImageClass}"

# Show the image
PlotImage(nFirstImage, title=sTitle).prepare().show()
```
Topsis-Harseerat-102317191 1.0.0
TOPSIS command-line implementation
Requires Python: >=3.6

# TOPSIS Package

This package implements the TOPSIS (Technique for Order Preference by Similarity to Ideal Solution) method.

## Installation
pip install Topsis-Harseerat-102317191

## Usage
topsis input.csv "1,1,1,2" "+,+,-,+" output.csv

## Input Rules
- CSV file must have at least 3 columns
- First column is identifier
- Other columns must be numeric
- Weights and impacts must be comma-separated

## Output
Generates a CSV file with TOPSIS score and rank.
reactor-runtime 1.4.3
Reactor runtime with public model API
Requires Python: >=3.9

# Reactor Runtime

A Python runtime for building real-time video processing models. This runtime abstracts all the techincal implementations of real-time networking, allowing
researchers and models developers to run their model focusing only on the ML code.

You can think of this similarly to the way you write Telegram/Discord applications or bots using SDKs. You don't have to worry about the networking and the protocols of the medium. Instead, you can put all your effort in writing your application code, which in this case is ML code.

Documentation: https://docs.reactor.inc/runtime/overview

## Installation

```bash
pip install reactor-runtime
```

## Development Setup

Proto dependencies are fetched from the private `reactor-team/reactor-proto` repo. The version is defined in `pyproject.toml` under `[tool.reactor-proto]`.

```bash
# Set your GitHub token (required for private repo access)
export GH_TOKEN=your_github_token

# Install with proto dependencies
make install

# Or fetch protos separately
make proto
```

The proto wheel is downloaded to `generated/` (gitignored). Once installed, proto types are available via:

```python
from api import reactor_pb2
from api.types import api_types_pb2, base_pb2
```

## Publishing

```bash
make publish
```

The publish script performs two key transformations before building:

### 1. Obfuscation

All files and directories prefixed with `_` are stripped from the published package (except `__init__.py` and `__pycache__`). This allows you to keep private/internal code in the repository that won't be shipped to users.

Example: A `_cloud/` directory or `_internal.py` file will exist in the repo for development but won't appear in the PyPI package.

### 2. Proto Vendoring

The script uses AST analysis to scan all remaining (public) source files and identifies which `api.*` modules are actually imported. Only those specific proto files are copied into the published package.

This means:

- Users don't need access to the private `reactor-proto` repo
- The published package is self-contained with proto types bundled
- Only the protos actually used by public code are included, keeping the package minimal

**Prerequisite**: Run `make proto` before publishing to ensure proto types are installed locally for vendoring.

## Reactor CLI

Docs: https://docs.reactor.inc/runtime/cli-reference

## Coding Models

Guide: https://docs.reactor.inc/runtime/coding-models
umlshapes 1.6.0
Pyut Ogl without homegrown miniogl
Keywords: pyut, graphical shapes, python

![](https://github.com/hasii2011/code-ally-basic/blob/master/developer/agpl-license-web-badge-version-2-256x48.png "AGPL")

[![CircleCI](https://dl.circleci.com/status-badge/img/gh/hasii2011/umlshapes/tree/master.svg?style=shield)](https://dl.circleci.com/status-badge/redirect/gh/hasii2011/umlshape/tree/master)
[![Build Status](https://app.travis-ci.com/hasii2011/umlshapes.svg?token=xLRFkv8yzJS4p9oSFs49&branch=master)](https://app.travis-ci.com/hasii2011/umlshapes)
[![PyPI version](https://badge.fury.io/py/umlshapes.svg)](https://badge.fury.io/py/umlshapes)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://GitHub.com/Naereen/StrapDown.js/graphs/commit-activity)

[![forthebadge made-with-python](http://ForTheBadge.com/images/badges/made-with-python.svg)](https://www.python.org/)

# Introduction

This is version 2 of the [Pyut](https://github.com/hasii2011/pyut) [Ogl Module](https://github.com/hasii2011/ogl).  

This version removes the internal miniogl code and relies on wxPython's wx.lib.ogl package.



This is the external graphical shapes module for the UML Diagrammer that allows for development of extensions for the UML Diagrammer

This project depends on umlmodel and wxPython

```bash
pip install umlshapes
```

___

Written by Humberto A. Sanchez II <mailto@Humberto.A.Sanchez.II@gmail.com>, (C) 2025


## Note
For all kind of problems, requests, enhancements, bug reports, etc., please drop me an e-mail.


------


![Humberto's Modified Logo](https://raw.githubusercontent.com/wiki/hasii2011/gittodoistclone/images/SillyGitHub.png)

I am concerned about GitHub's Copilot project



I urge you to read about the
[Give up GitHub](https://GiveUpGitHub.org) campaign from[the Software Freedom Conservancy](https://sfconservancy.org).

While I do not advocate for all the issues listed there I do not like that a company like Microsoft may profit from open source projects.

I continue to use GitHub because it offers the services I need for free.  But, I continue to monitor their terms of service.

Any use of this project's code by GitHub Copilot, past or present, is done without my permission.  I do not consent to GitHub's use of this project's code in Copilot.
cadwyn 6.0.3
Production-ready community-driven modern Stripe-like API versioning in FastAPI
Requires Python: >=3.9
Keywords: api, api-versioning, code-generation, fastapi, hints, json-schema, pydantic, python, python310, python311, python312, python313, python39, stripe, versioning

# Cadwyn

Production-ready community-driven modern [Stripe-like](https://stripe.com/blog/api-versioning) API versioning in FastAPI

---

<p align="center">
<a href="https://github.com/zmievsa/cadwyn/actions/workflows/ci.yaml?branch=main&event=push" target="_blank">
    <img src="https://github.com/zmievsa/cadwyn/actions/workflows/ci.yaml/badge.svg?branch=main&event=push" alt="Test">
</a>
<a href="https://codecov.io/gh/zmievsa/cadwyn" target="_blank">
    <img src="https://img.shields.io/codecov/c/github/zmievsa/cadwyn?color=%2334D058&logo=codecov" alt="Coverage">
</a>
<a href="https://pypi.org/project/cadwyn/" target="_blank">
    <img alt="PyPI" src="https://img.shields.io/pypi/v/cadwyn?color=%2334D058&logo=pypi&label=PyPI" alt="Package version">
</a>
<a href="https://pypi.org/project/cadwyn/" target="_blank">
    <img src="https://img.shields.io/pypi/pyversions/cadwyn?color=%2334D058&logo=python" alt="Supported Python versions">
</a>
<a href="https://discord.gg/yRmcWF7rxE" target="_blank">
    <img alt="Discord" src="https://img.shields.io/discord/1183145640407076864?color=%2334D058&logo=discord">
</a>
</p>

## Who is this for?

Cadwyn allows you to maintain the implementation just for your newest API version and get all the older versions generated automatically. You keep API backward compatibility encapsulated in small and independent "version change" modules while your business logic stays simple and knows nothing about versioning.

This [approach](https://docs.cadwyn.dev/theory/how_we_got_here/#ii-migration-based-response-building) may be useful if you want to:

1. Support many API versions for a long time
2. Have features and bugfixes automatically backported to older API versions

Whether you are a newbie in API versioning, a pro looking for a sophisticated tool, an experimenter looking to build a similar framework, or even someone who just wants to learn about all approaches to API versioning -- Cadwyn has the functionality, theory, and documentation to cover all the mentioned use cases.

## Get started

The [documentation](https://docs.cadwyn.dev) has everything you need to succeed.

## Sponsors

These are our gorgeous sponsors. They are using Cadwyn and are sponsoring it through various means. Contact [me](https://github.com/zmievsa) if you would like to become one, too!
marge-bot 1.1.0
marge-bot is a merge bot for GitLab.
Requires Python: >=3.10.0
Keywords: gitlab, merge request, merge train

# marge-bot

[![pipeline status](https://gitlab.com/marge-org/marge-bot/badges/main/pipeline.svg)](https://gitlab.com/marge-org/marge-bot/-/commits/main)
[![Latest Release](https://gitlab.com/marge-org/marge-bot/-/badges/release.svg)](https://gitlab.com/marge-org/marge-bot/-/releases)

**marge-bot** is a merge bot for advanced merge request workflows on GitLab.
Marge helps keep your main branch green, and comes with a set of features to make
managing merge requests at scale easier. It improves on GitHub's
[merge queue](https://docs.github.com/en/repositories/configuring-branches-and-merges-in-your-repository/configuring-pull-request-merges/managing-a-merge-queue)
and GitLab's [merge train](https://docs.gitlab.com/ee/ci/pipelines/merge_trains.html)
workflows by automatically handling rebases and merges, batching merge requests, and more.

Marge-bot offers a simple workflow: when a merge request is ready, just
assign it to the marge-bot user, and let her do all the rebase-wait-retry for you. If
anything goes wrong (merge conflicts, tests that fail, etc.) she'll leave a
message on the merge request, so you'll get notified. Marge-bot can handle an
adversarial environment where some developers prefer to merge their own changes,
so the barrier for adoption is really low.

Whether marge-bot will or will not wait for pipeline to succeed depends on the value of
"Pipelines must succeed" setting in your project. It is available in all Gitlab
versions, and should not be a barrier.

Since she is at it, she can optionally provide some other goodies like tagging
of commits (e.g. `Reviewed-by: ...`) or preventing merges during certain hours.
gancio-py 0.1.0b1
Python client for the Gancio event platform API
Requires Python: >=3.10
Keywords: api-client, events, gancio

# gancio-py

[![Tests](https://github.com/tboye/gancio-py/actions/workflows/test.yml/badge.svg)](https://github.com/tboye/gancio-py/actions/workflows/test.yml)
[![PyPI](https://img.shields.io/pypi/v/gancio-py)](https://pypi.org/project/gancio-py/)
[![Python](https://img.shields.io/pypi/pyversions/gancio-py)](https://pypi.org/project/gancio-py/)

Python client for the [Gancio](https://gancio.org) event platform API.

## Installation

```bash
pip install gancio-py
```

## Usage

```python
from gancio_py import Gancio

# Connect and log in
gancio = Gancio("https://your-gancio-instance.org")
gancio.login("user@example.com", "password")

# Or use a pre-existing token
gancio = Gancio("https://your-gancio-instance.org", access_token="your-token")

# Create an event
event = gancio.create_event(title="My Event",
                            start_datetime=1700000000,
                            place_name="The Venue",
                            place_address="123 Main St",
                            tags=["music", "live"])

# List events
events = gancio.get_events(tags=["music"])

# Get a specific event
event = gancio.get_event("my-event")

# Update an event
gancio.update_event(event_id=1, title="Updated Title")

# Delete an event
gancio.delete_event(event_id=1)

# Search places
places = gancio.search_place("Venue")
```

### Error handling

```python
from gancio_py import Gancio, GancioError

gancio = Gancio("https://your-gancio-instance.org")

try:
    event = gancio.get_event("nonexistent-slug")
except GancioError as e:
    print(e.status_code)     # 404
    print(e.response_body)   # error details from the server
```

## Development

Run integration tests locally with Docker:

```bash
uv sync --extra test

# Fresh container (runs first-time setup automatically):
docker compose down -v && docker compose up -d
uv run pytest -m integration -v --cov

# Or against an existing instance with known credentials:
GANCIO_URL=http://localhost:13120 \
GANCIO_ADMIN_EMAIL=admin \
GANCIO_ADMIN_PASSWORD=yourpassword \
uv run pytest -m integration -v --cov
```

### Linting

```bash
uvx ruff check
uvx ruff check --fix  # auto-fix
```

## License

[MIT](LICENSE)
promptbuilder 0.4.44
Library for building prompts for LLMs
Requires Python: >=3.10

# Prompt Builder

Library for building prompts and agents with LLMs.

## Installation

From PyPI:
```bash
pip install promptbuilder
```

From source:
```bash
git clone https://github.com/kapulkin/promptbuilder.git
cd promptbuilder
pip install -e .
```

## Features

- Prompt templates with variables and content tags
- Structured output with TypeScript-like schema definition
- LLM client with native structured output support and caching option
- Integration with multiple LLM providers through aisuite
- Agents with routing based on tools
- Tools as agent for flexibility and scalability

## Quick Start

### Basic Prompt Usage

```python
from promptbuilder.llm_client import LLMClient
from promptbuilder.prompt_builder import PromptBuilder

# Build prompt template
prompt_template = PromptBuilder() \
    .text("What is the capital of ").variable("country").text("?") \
    .build()

# Use with LLM
llm_client = LLMClient(model="your-model", api_key="your-api-key")
response = llm_client.from_text(
    prompt_template.render(country="France")
)
print(response)
```

### Using Agents

```python
from typing import List
from pydantic import BaseModel, Field
from promptbuilder.agent.agent import AgentRouter
from promptbuilder.agent.context import Context, InMemoryDialogHistory
from promptbuilder.agent.message import Message
from promptbuilder.llm_client import LLMClient

# Define tool arguments
class AddTodoArgs(BaseModel):
    item: TodoItem = Field(..., description="Todo item to add")

# Create custom context
class TodoItem(BaseModel):
    description: str = Field(..., description="Description of the todo item")

class TodoListContext(Context[InMemoryDialogHistory]):
    todos: List[TodoItem] = []

# Create agent with tools
class TodoListAgent(AgentRouter[InMemoryDialogHistory, TodoListContext]):
    def __init__(self, llm_client: LLMClient, context: TodoListContext):
        super().__init__(llm_client=llm_client, context=context)
    
llm_client = LLMClient(model="your-model", api_key="your-api-key")
agent = TodoListAgent(llm_client=llm_client, context=TodoListContext())

@agent.tool(description="Add a new todo item to the list", args_model=AddTodoArgs)
async def add_todo(message: Message, args: AddTodoArgs, context: TodoListContext) -> str:
    context.todos.append(args.item)
    return f"Added todo item: {args.item.description}"

# Use the agent
async def main():
    response = await agent(Message(role="user", content="Add a todo: Buy groceries"))
    print(response)

```

See the `examples` directory for more detailed examples, including a complete todo list manager.

## License

MIT License - see LICENSE file for details.

## Contributing

Contributions are welcome! Please feel free to submit a pull request.