semvec/pypi-packages huggingface dataset:
videre 0.1.0
Simple GUI framework based on Pygame
Requires Python: >=3.13

# Videre

Simple Python GUI framework based on Pygame.

Still Work In Progress.

## Development

To run unit tests with Pytest + Coverage:

```
uv run pytest --cov=videre --cov-report=term-missing --cov-report=html --cov-report=json videre_tests
```

To format code with Ruff:

```
uv run ruff format

uv run ruff check

uv run ruff check --fix
```
uiuapy 0.2.0
Use the Uiua array programming language from Python
Requires Python: >=3.9
Keywords: uiuapy, uiua, apl, J, kdb, numpy, pyo3, array, programming, language, vectorized

# UiuaPy

A bridge between [Uiua](https://www.uiua.org/) and [NumPy](https://numpy.org/) - enabling you to do tacit array processing in Python.

## Installation
```sh
pip install uiuapy
```

If building the source distribution, rather than installing a precompiled wheel, you will need to have [rustup](https://rustup.rs/) installed on your machine.

## Usage
```py
import uiua

print(uiua.compile('/+')([1, 2, 3]))
# 6.0

print(uiua.compile('⌕')('ab', 'abracabra')) 
# [1 0 0 0 0 1 0 0 0]
```

### Flags
You can allow thread spawning either specific to a program, or specific to an invocation. Invocation flags take precedence over program flags.
```py
import numpy as np
import uiua

xs = np.linspace(0, 1, 10_000)

print(uiua.compile('/+', allow_threads=True)(xs))
# 50000.0

print(uiua.compile('/+')(xs, allow_threads=True))
# 50000.0

```

## NumPy integration
UiuaPy uses the [NumPy C-API](https://numpy.org/doc/2.1/reference/c-api/index.html) for taking in Python inputs and returning Python results.

Uiua supports 5 data-types for arrays/scalars:

|Uiua type|NumPy equivalent dtype|
|---------|----------------------|
|Num|float64|
|Byte|uint8|
|Complex|complex128|
|Char|Unicode (32-bit characters)|
|Box|object|

If you pass in a NumPy array that does not have one of the above dtypes, it will be automatically converted according to the table below:
|NumPy dtype|Converted NumPy dtype|Uiua type|
|-|-|-|
|float32|float64|Num|
|uint64|float64|Num|
|uint32|float64|Num|
|uint16|float64|Num|
|int64|float64|Num|
|int32|float64|Num|
|int16|float64|Num|
|bool|uint8|Byte|

#### Interfacing overhead
Passing a numpy array to uiua requires copying its memory (using `memcpy`/ [`std::ptr::copy_nonoverlapping`](https://doc.rust-lang.org/beta/std/ptr/fn.copy_nonoverlapping.html) in Rust). The same is true for the values returned from the Uiua computation.

If using anything other than float64, uint8, complex128 or unicode data - there are also type conversion costs to take into account.

## Development

### Dependencies
- [rustup](https://rustup.rs/)
- [uv](https://docs.astral.sh/uv/getting-started/installation/)

```sh
# Format code
uv run ruff format
cargo fmt

# Fix/report lints
uv run ruff check --fix
cargo clippy

# Run tests
uv run pytest

# Build wheels
uv build
```
wyld-cz 0.1.0
A custom rules sets for commitizen
Requires Python: >=3.12

# Wyld Commitezen Repository

A sets of custom rules and templates for commitezen.

You can find more info about commitezen customization with
official [documentation](https://commitizen-tools.github.io/commitizen/customization/)

## Contributing

This repo, so as others, provide in-built development environment.
To install and enable this environment just run `make`.
libreriajuan 0.0.3
libreria para una calculadora simple de operaciones basicas, dimencionamieto electrico para instalacion de motores industriales
Requires Python: >=3.9

# Guia para usar mi libreria
## Existen 4 funciones 
## srmd
donde se encuentra la multipliacion division como suma y resta de dos numeros.
se requiere 2 numeros a,b que se multiplican, se dividen, se restan y se suman con md dividir 

## elt
libreria donde se asignando la instacion de motores primeramente la cantidad segido de de la potencia, numero de polos,
y los factores de la instalacion podesmos calcular la demanda de consumo de energia del sistema, para poder asi asignar
un transformador adecuado para todo el sistema, segido de ello podemos realizar el dimencionamiento de los cables de
alimentacion del transformador al tablero de control, segido de ellos seleecionar el cable de alimentacion de cada motor
poi-sdk 0.1.0
A Python SDK for creating trustworthy AI agent transactions with Proof-of-Intent
Requires Python: >=3.8
Keywords: proof-of-intent, ai, security, cryptography, agents, trust, audit

# PoI Python SDK Package

This folder contains the PyPI package for the Proof-of-Intent Python SDK.

## Package Structure

```
package/
├── src/                    # Source code
│   └── poi_sdk/          # Main package
├── setup.py               # Package setup script
├── MANIFEST.in            # Package manifest
├── requirements.txt       # Dependencies
├── LICENSE                # MIT License
├── README.md              # This file
└── build_package.py       # Build automation script
```

## Building the Package

### Prerequisites

```bash
pip install setuptools wheel twine
```

### Quick Build

```bash
cd package
python build_package.py
```

### Manual Build

```bash
cd package

# Clean previous builds
rm -rf build dist *.egg-info

# Build source distribution
python setup.py sdist

# Build wheel
python setup.py bdist_wheel

# Check package
twine check dist/*
```

## Package Contents

The package includes:

- **Core SDK**: `PoIReceipt`, `PoIGenerator`, `PoIValidator`, `PoIConfig`
- **CLI Tool**: `poi-cli` command-line interface
- **Type Hints**: Full type annotation support
- **Dependencies**: All required packages with version constraints

## Installation

### From PyPI (when published)

```bash
pip install poi-sdk
```

### From Local Package

```bash
# Install from built wheel
pip install dist/poi_sdk-0.1.0-py3-none-any.whl

# Install in development mode
pip install -e .
```

## Usage

```python
from poi_sdk import PoIGenerator, PoIValidator

# Generate a receipt
generator = PoIGenerator()
receipt = generator.generate_receipt(
    agent_id="my_agent",
    action="data_access",
    target_resource="user_database",
    declared_objective="Fetch user profile"
)

# Validate the receipt
validator = PoIValidator()
is_valid = validator.validate_receipt(receipt)
```

## CLI Usage

```bash
# Generate a receipt
poi-cli generate --agent-id "cli_agent" --action "test" --resource "test" --objective "Testing"

# Validate a receipt
poi-cli validate --receipt receipt.json
```

## Development

For development setup and contribution guidelines, see the main repository's [CONTRIBUTING.md](../CONTRIBUTING.md).

## License

MIT License - see [LICENSE](LICENSE) file for details.
babylonrsa 1.0.0
A Babylonian-style base-60 RSA library in Python
Requires Python: >=3.8

# BabylonRSA 🔑🪔

**BabylonRSA** is a Python library for experimenting with public/private key encryption (RSA-like) using the **Babylonian sexagesimal (base-60) numeral system**.  
Instead of encoding numbers in decimal or hexadecimal, this library stores ciphertext and keys in **base-60**, inspired by ancient Mesopotamian mathematics.

---

## Features
- Generate public/private key pairs.
- Encrypt and decrypt text messages.
- Encode ciphertext and keys in **Babylonian base-60** instead of hex.
- Lightweight, educational, and easy to extend.

---

## Installation

Include the `babylonrsa` folder in your project or install via PyPI (if published):

```bash
pip install babylonrsa