semvec/pypi-packages huggingface dataset:
quart-shell-ipython 0.1.2
Startup the quart shell with ipython
License: MIT
Requires Python: >=3.7

# quart-shell-ipython

generated from flask-shell-ipython

Start quart shell with ipython, if it installed

## Features

- Drop-in replacement for the default Quart shell command
- Full IPython integration with enhanced REPL features
- Python 3.7+ support, including Python 3.13
- Compatible with Python 3.13's improved asyncio event loop handling

## Installation

```bash
pip install quart-shell-ipython
```

## Usage

Once installed, the package automatically registers a `shell` command
with your Quart application. Simply run:

```bash
quart shell
```

You can pass any IPython arguments:

```bash
quart shell --no-banner --quick
```

## Python 3.13 Compatibility

This package has been updated to work seamlessly with Python 3.13's
stricter asyncio event loop management. The shell command properly
handles event loop creation and management to ensure compatibility
across all supported Python versions.
dil-gcm-envelope 0.1.1
AES-256-GCM envelope encryption (payload, iv, tag) compatible cross-language.
License: MIT
Requires Python: >=3.8
Keywords: aes-gcm, encryption, envelope, cryptography

# dil-gcm-envelope

AES-256-GCM Envelope Encryption for Python  
Outputs `{ payload, iv, tag }` compatible with JavaScript, Node.js, Dart/Flutter, and other languages.

This package provides simple, secure, interoperable encryption using **AES-256-GCM**.  
It is designed for **cross-platform encrypted API communication**, **secure app-to-server payloads**, and **lightweight secrets encryption**.

## Features

- 🔐 AES-256-GCM encryption
- 📦 Returns `{ payload, iv, tag }` — same as the JS NPM package  
- 🔄 Cross-language compatible (Node.js, Python, Flutter/Dart)
- ⚙️ Two key-derivation modes:
  - SHA256(password) — deterministic, ideal for interoperability  
  - PBKDF2-HMAC-SHA256 — stronger security with salt  
- 🔧 Encrypts:
  - JSON objects  
  - Strings  
  - Bytes  
- 🧪 Includes automated tests
- 📁 Optional CLI tool for encryption/decryption
- 🛡 Authenticated encryption with AES-GCM (rejects tampered data)

## Installation

```
pip install dil-gcm-envelope
```

## Usage Examples

### 1️ Basic SHA-256 Key Mode (cross-language)

```python
from dil_gcm_envelope import encrypt, decrypt
import json

password = "my-secret-key"
data = {"message": "Hello World", "n": 123}

encrypted = encrypt(password, data)
print(encrypted)

plaintext_bytes = decrypt(
    password,
    encrypted["payload"],
    encrypted["iv"],
    encrypted["tag"]
)
print(json.loads(plaintext_bytes.decode()))
```

### 2️ Strong Mode (PBKDF2)

```python
encrypted = encrypt(
    "my-password",
    "sensitive text",
    use_pbkdf2=True,
    pbkdf2_iterations=200_000
)
print(encrypted)
```

Decrypt:

```python
pt = decrypt(
    "my-password",
    encrypted["payload"],
    encrypted["iv"],
    encrypted["tag"],
    salt_b64=encrypted["salt"],
    pbkdf2_iterations=200_000
)
print(pt.decode())
```

### 3️ Encrypt Bytes

```python
binary_data = b"\x01\x02\x03ABC123"
enc = encrypt("pw", binary_data)
pt = decrypt("pw", enc["payload"], enc["iv"], enc["tag"])
print(pt)
```

## 🧰 CLI Usage

Encrypt:

```
dil-gcm-envelope encrypt mypass --text "Hello World"
```

PBKDF2:

```
dil-gcm-envelope encrypt mypass --text "Top Secret" --pbkdf2
```

Decrypt:

```
dil-gcm-envelope decrypt mypass --payload "..." --iv "..." --tag "..." --salt "..."
```

## Cross-Language Compatibility

Compatible with:

| Language | Package |
|---------|---------|
| Node.js | @dev_innovations_labs/dil-gcm-envelope/node |
| Browser | @dev_innovations_labs/dil-gcm-envelope/browser |
| Flutter/Dart | dil_gcm_envelope.dart (coming soon) |
| Python | dil-gcm-envelope |

## Security Notes

- AES-256-GCM provides authenticated encryption  
- SHA-256 derivation is deterministic (simple + compatible)  
- PBKDF2 recommended for production  
- Never reuse IV for same key (library auto-generates IV)

## Testing

```
pytest -q
```

## Build & Publish

```
python -m build
twine upload dist/*
```

## Use Cases

- Secure mobile → server communication  
- Encrypted API payloads  
- End-to-end encrypted messaging  
- Secure local storage
GPT-Helper 0.1.0
A helper library for interacting with ChatGPT.
License: MIT
Requires Python: >=3.8

# GPT_Helper

A lightweight Python helper library that simplifies interacting with **ChatGPT (OpenAI API)**.  
It provides a clean interface for sending prompts, formatting responses, summarizing text, and maintaining simple conversation history.

---

## 🚀 Features

- **ChatGPTClient** — send prompts easily using the official OpenAI Chat Completions API.
- **summarize_text()** — generate a neat summary of long text.
- **format_response()** — clean & normalize ChatGPT output.
- **ConversationHistory** — minimal in-memory storage for prompts & responses.
- Fully documented & ready for PyPI packaging.

---

## 📦 Installation

### Local development install

From the project root:

```bash
pip install -e .
ai-queryhelper 0.1.0
Gemini-powered AI helper functions for Flask web apps
License: MIT
Requires Python: >=3.8

# ai_queryhelper

A simple Python library that wraps the Gemini API to process user queries, summarize long text, and format AI output.  
This library is designed to be used in Flask web applications for AI-powered web assistants.

---

## 🧾 Overview

`ai_queryhelper` is a lightweight utility library that provides:

- `get_response(prompt)` — ask any question and get an AI response  
- `summarize_text(text)` — summarize long text using AI  
- `format_response(text)` — clean and format AI output  

This library uses **Google Gemini API**, which offers fast and affordable text generation.

---
cppvector-jediz 0.1.1
A C++ style vector implementation for Python
License: MIT
Requires Python: >=3.7

# cppvector

A C++ style vector implementation for Python.

## Installation

```bash
pip install cppvector-jediz
```
v = Vector([1, 2, 3, 4, 5])
    print("1. SVO test:", v)
    for x in [999, 111, 222, 333]:
        v.push_back(x)
    print("   After overflow:", v)

    # 2. swap + comparison
    a = Vector(range(10))
    b = Vector([100, 200, 300])
    a.swap(b)
    print("2. After swap():", a, b)
    print("   Equality check:", a == Vector([100, 200, 300]))

    # 3. REAL NumPy zero-copy interop
    print("\n3. NUMPY ZERO-COPY INTEROP")
    nv = NumericVector()
    for i in range(10):
        nv.push_back(i * 10)
    print("   NumericVector:", nv)

    arr = np.frombuffer(nv, dtype=np.int64)
    print("   NumPy view:", arr)
    arr[5] = 9999
    print("   After NumPy modify:", list(nv))

    # 4. vector<bool>
    print("\n4. vector<bool> bit packing")
    vb = VectorBool([True, False, True] * 2000)
    print(f"   {len(vb)} bits → {len(vb._data)} bytes used")
    vb[5] = True
    print("   First 10:", list(vb)[:10])

    # 5. Speed test
    print("\n5. 10 million push_back speed test...")
    v = Vector()
    v.reserve(10_000_000)
    start = time.time()
    for i in range(10_000_000):
        v.push_back(i)
    print(f"   Done in {time.time() - start:.3f}s")

    # 6. Shrink back to SVO
    while len(v) > 5:
        v.pop_back()
    v.shrink_to_fit()
    print("6. Shrunk to SVO:", v)
```

## Features

- Dynamic array with automatic resizing
- C++ STL vector-like interface
- Efficient memory management

## License

MIT License