semvec/pypi-packages huggingface dataset:
hexdoc-hexstruction 1.3.1.1.20.1.1.1
Structure manipulation with Hex Casting
Requires Python: >=3.11
Keywords: hexdoc

# hexdoc-hexstruction

Python web book docgen and [hexdoc](https://pypi.org/project/hexdoc) plugin for HexStruction.

Structure manipulation with Hex Casting

## Version scheme

We use [hatch-gradle-version](https://pypi.org/project/hatch-gradle-version) to generate the version number based on whichever mod version the docgen was built with.

The version is in this format: `mod-version.python-version.mod-pre.python-dev.python-post`

For example:
* Mod version: `0.11.1-7`
* Python package version: `1.0.dev0`
* Full version: `0.11.1.1.0rc7.dev0`

## Setup

Install Python 3.11.

```sh
python3.11 -m venv venv

.\venv\Scripts\activate   # Windows
. venv/bin/activate.fish  # fish
source venv/bin/activate  # everything else

# run from the repo root, not doc/
pip install -e .[dev]
```

## Usage

For local testing, create a file called `.env` in the repo root following this template:

```sh
GITHUB_REPOSITORY=PetersonE1/hexstructiondummy
GITHUB_SHA=main
GITHUB_PAGES_URL=https://github.com/PetersonE1/hexstruction
```

Useful commands:

```sh
# show help
hexdoc -h

# render and serve the web book in watch mode
nodemon --config doc/nodemon.json

# render and serve the web book
hexdoc serve

# build and merge the web book
hexdoc build
hexdoc merge

# start the Python interpreter with some extra local variables
hexdoc repl
```
nvidia-nvshmem-cu13 3.5.19
NVSHMEM creates a global address space that provides efficient and scalable communication for NVIDIA GPU clusters.
Requires Python: >=3
Keywords: cuda, nvidia, runtime, machine learning, deep learning

NVSHMEM is a parallel programming interface based on OpenSHMEM that provides efficient and scalable communication for NVIDIA GPU clusters. NVSHMEM creates a global address space for data that spans the memory of multiple GPUs and can be accessed with fine-grained GPU-initiated operations, CPU-initiated operations, and operations on CUDA streams.
nvidia-nvshmem-cu12 3.5.19
NVSHMEM creates a global address space that provides efficient and scalable communication for NVIDIA GPU clusters.
Requires Python: >=3
Keywords: cuda, nvidia, runtime, machine learning, deep learning

NVSHMEM is a parallel programming interface based on OpenSHMEM that provides efficient and scalable communication for NVIDIA GPU clusters. NVSHMEM creates a global address space for data that spans the memory of multiple GPUs and can be accessed with fine-grained GPU-initiated operations, CPU-initiated operations, and operations on CUDA streams.
seta-datasets 1.2.2
The official Python client for the SETA Dataset Platform.
Requires Python: >=3.7

# SETA Datasets Loader

A high-performance CLI tool and library for downloading datasets from the SETA Protocol.

## Installation

```bash
pip install seta-datasets

## v1.3.0
- Added folder structure preservation
- Unified support for recent, version, and instance APIs
- Improved download safety and auth handling
beangulp-simplefin 0.2.0
Beangulp importer for SimpleFIN
Requires Python: >=3.9
Keywords: beancount, beangulp, simplefin, accounting, finance, import

# Beangulp SimpleFIN Importer

[![PyPI version](https://img.shields.io/pypi/v/beangulp-simplefin.svg)](https://pypi.org/project/beangulp-simplefin/)
[![Python versions](https://img.shields.io/pypi/pyversions/beangulp-simplefin.svg)](https://pypi.org/project/beangulp-simplefin/)
[![CI](https://github.com/robcohen/beangulp-simplefin/actions/workflows/ci.yml/badge.svg)](https://github.com/robcohen/beangulp-simplefin/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A [beangulp](https://github.com/beancount/beangulp) importer for [SimpleFIN](https://www.simplefin.org/) data.

## Installation

```bash
uv add beangulp-simplefin
```

Or with pip:

```bash
pip install beangulp-simplefin
```

## Usage

### 1. Download SimpleFIN data

Use the SimpleFIN CLI to download your account data:

```bash
uv add simplefin
simplefin fetch --output ~/simplefin-data/
```

This creates one JSON file per account in the output directory.

### 2. Configure your importer

Create an `import.py` configuration:

```python
from beangulp_simplefin import SimpleFINImporter
import beangulp

importers = [
    SimpleFINImporter(account_mapping={
        "ACT-xxx-xxx": "Assets:Checking:Chase",
        "ACT-yyy-yyy": "Assets:Checking:Schwab",
        "ACT-zzz-zzz": "Liabilities:CreditCard:Amex",
    })
]

if __name__ == "__main__":
    beangulp.Ingest(importers)()
```

### 3. Extract transactions

```bash
python import.py extract ~/simplefin-data/ >> ledger.beancount
```

### 4. Archive the files (optional)

```bash
python import.py archive ~/simplefin-data/ -o documents/
```

## Importer Options

```python
SimpleFINImporter(
    account_mapping,        # Dict mapping SimpleFIN account IDs to Beancount accounts
    currency='USD',         # Default currency
    expense_account='Expenses:Uncategorized',   # For outflows
    income_account='Income:Uncategorized',      # For inflows
)
```

## Output Format

Each transaction becomes a Beancount entry:

```beancount
2024-01-15 * "GROCERY STORE #123"
  simplefin_id: "TRN-abc123"
  Assets:Checking:Chase  -45.67 USD
    simplefin_id: "TRN-abc123"
  Expenses:Uncategorized

2024-01-16 balance Assets:Checking:Chase  1234.56 USD
```

## Workflow Example

```bash
# Daily/weekly sync
simplefin fetch --output ~/simplefin-data/
python import.py extract ~/simplefin-data/ >> ledger.beancount
bean-check ledger.beancount
```

## Related Tools

- [simplefin](https://github.com/simplefin/simplefin-py) - SimpleFIN Python client
- [sfin2beancount](https://github.com/simplefin/sfin2beancount) - Pipe-based SimpleFIN to Beancount converter
- [sfin2ledger](https://github.com/simplefin/sfin2ledger) - SimpleFIN to Ledger converter

## License

MIT
vqpu 1.0.1
Virtual Quantum Processing Unit - High-Performance Quantum Simulator (Open Source Edition)
Requires Python: >=3.8
Keywords: quantum computing, quantum simulation, quantum algorithms, VQE, QAOA, Shor's algorithm, quantum chemistry, quantum machine learning

# QPU Quantum Simulator - Open Source Edition

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![PyPI version](https://badge.fury.io/py/vqpu.svg)](https://pypi.org/project/vqpu/)

**High-performance quantum circuit simulator with C++ acceleration**

## ⚠️ Open Source Limitations

**🆓 FREE TIER:** Maximum **300 qubits**
- Basic quantum algorithms (Grover, VQE, QAOA)
- Community support
- Open source license (MIT)

**🔓 PREMIUM FEATURES:** Unlimited qubits & advanced algorithms
- Unlimited qubit simulations
- Breakthrough quantum storage algorithms
- Priority support
- Commercial license

**Upgrade to Premium:** Contact vivek.yemky@gmail.com

---

## Installation

```bash
pip install vqpu
```

## Quick Start

```python
from vqpu import QuantumSimulator

# Create simulator (max 300 qubits in open source)
sim = QuantumSimulator()
sim.reset(10)  # ✅ OK - within 300 qubit limit

# Quantum gates
sim.h(0)
sim.cnot(0, 1)
sim.x(2)

# Measure
results = sim.measure(shots=1000)
print(results)
```

## Features

### ✅ Available in Open Source
- **Quantum Gates:** H, X, Z, CNOT, CZ, rotations
- **Algorithms:** Grover's search, VQE, QAOA
- **Performance:** C++ accelerated simulation
- **Limit:** 300 qubits maximum

### 🔒 Premium Features (Coming Soon)
- Unlimited qubit simulations
- Advanced storage algorithms
- Enterprise support
- Commercial applications

## Usage Examples

### Bell State
```python
from vqpu import QuantumSimulator

sim = QuantumSimulator()
sim.reset(2)
sim.h(0)
sim.cnot(0, 1)

results = sim.measure(1000)
# ~50% |00⟩, ~50% |11⟩
```

### VQE Chemistry
```python
from vqpu.algorithms import run_vqe

# H2 molecule (within 300 qubit limit)
energy = run_vqe('H2', basis='sto-3g')
print(f"Energy: {energy:.5f} Ha")
```

## System Requirements

- **Python:** 3.8+
- **Memory:** 8GB+ recommended for large circuits
- **OS:** Windows, Linux, macOS
- **Qubit Limit:** 300 (open source)

## Error Messages

If you exceed the 300 qubit limit:

```
❌ Open Source Limit Exceeded: 500 > 300 qubits
🆓 QPU Open Source is limited to 300 qubits maximum.
🔓 For unlimited qubits and premium features:
   Contact: vivek.yemky@gmail.com
```

## Contributing

We welcome contributions! See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.

## License

**MIT License** - Open source and free to use.

For commercial applications requiring unlimited qubits, contact us for premium licensing.

## Support

- **Documentation:** [docs/](docs/)
- **Issues:** [GitHub Issues](https://github.com/qpu/qpu/issues)
- **Premium Support:** vivek.yemky@gmail.com

---

**QPU - Democratizing Quantum Computing** 🚀</content>
<parameter name="filePath">d:\Aim\projects\ai-ml\computer-vision\Q1\qpu\vQPU\README.md