semvec/pypi-packages huggingface dataset:
keyring-wincred 0.1.0
Windows Credential Manager backend for keyring
Requires Python: >=3.8

# keyring_wincred

Windows Credential Manager backend for [keyring](https://pypi.org/project/keyring/) for WSL.

This package allows Python applications running in WSL (Windows Subsystem for Linux) to store secrets in the Windows Credential Manager.

## Installation

```bash
git clone https://github.com/ilpianista/keyring_wincred.git
cd keyring_wincred
pip install .
```

## Usage

Once installed, keyring should automatically detect and use this backend when running under WSL. To force it configure `~/.config/python_keyring/keyringrc.cfg` like so:

```
[backend]
default-keyring = keyring_wincred.WinCredKeyring
```

Instead, in Python:

```python
import keyring

# Store a password
keyring.set_password("myservice", "myuser", "secret123")

# Retrieve a password
password = keyring.get_password("myservice", "myuser")

# Delete a password
keyring.delete_password("myservice", "myuser")
```

You can also use the keyring CLI:

```bash
keyring set myservice myuser
keyring get myservice myuser
keyring del myservice myuser
```

## How it works

This backend uses PowerShell with inline C# code to call the Windows Credential Manager API (`advapi32.dll`). No external PowerShell modules are required.

Credentials are stored with target names in the format `service:username`.

## Requirements

- WSL (Windows Subsystem for Linux)
- Python 3.8+
- `keyring` package

## License

MIT
cvo20251229 0.1.0
Development flow as Paleofuturistic Python
Requires Python: >=3.12

# cvo20251229

Development flow as Paleofuturistic Python

## Usage

Legacy: `pip install cvo20251229`

Preferred: `uv add cvo20251229`

## Developing further

> Development flow as [Paleofuturistic Python](https://github.com/schubergphilis/paleofuturistic_python)

Prerequisite: [uv](https://docs.astral.sh/uv/)

### Setup

- Fork and clone this repository.
- Download additional dependencies: `uv sync --all-extras --dev`
- Optional: validate the setup with `uv run python -m unittest`

### Workflow

- Download dependencies (if you need any): `uv add some_lib_you_need`
- Develop (optional, tinker: `uvx --with-editable . ptpython`)
- QA:
    - Format: `uv run ruff format`
    - Lint: `uv run ruff check`
    - Type check: `uv run mypy`
    - Test: `uv run python -m unittest`
- Build (to validate it works): `uv build`
- Review documentation updates: `uv run mkdocs serve`
- Make a pull request.
tetherpy 0.2.0
Triton-powered framework for training and deploying Spiking Transformers.
Requires Python: >=3.10

# Tether
<img width="1000" height="600" alt="Gemini_Generated_Image_xofloxxofloxxofl" src="https://github.com/user-attachments/assets/420a486f-1a09-4d72-a98b-22678abd0e75" />


**Tether** is a Triton-powered framework for training and deploying **Spiking Transformers** and deep Spiking Neural Networks (SNNs).

We’ve solved the non-differentiability of discrete spikes by implementing high-performance Triton kernels with modular **Surrogate Gradients**.

## Key Features

- **High-Performance Neurons**:
  - **LIF (Leaky Integrate-and-Fire)**: Standard spiking neuron with fused Triton kernels.
  - **ALIF (Adaptive LIF)**: Neurons with adaptive thresholds for better temporal dynamics.
  - **PLIF (Parametric LIF)**: Neurons with learnable, per-channel decay and threshold parameters.
- **Modular Surrogate Gradients**: Choose from `Arctan`, `Sigmoid`, or `FastSigmoid` to train your SNNs effectively.
- **Linear Spike-Driven Attention**: Eliminates the $O(N^2)$ Softmax bottleneck, allowing for massive context windows with significantly lower energy per inference.
- **Data Utilities**: `SpikingDatasetWrapper` and encoding functions (`rate_encoding`, `latency_encoding`) to convert static datasets to spike trains.
- **Triton-Powered**: Leverages OpenAI's Triton language for custom CUDA kernels, enabling massive speedups (60x+) over vanilla PyTorch.

## Installation

This project is managed with `uv`.

```bash
uv sync
```

Or install dependencies manually:

```bash
pip install torch triton numpy
```

## Usage

### Using PLIF with Sigmoid Surrogate

```python
import torch
from tether import PLIF, Sigmoid

# Create a Parametric LIF layer with Sigmoid surrogate
# Decay and threshold are learnable vectors per neuron
layer = PLIF(
    n_neurons=128, 
    init_decay=0.9, 
    surrogate=Sigmoid(alpha=4.0)
).cuda()

# Input sequence: (Time, Batch, Neurons)
x = torch.randn(32, 16, 128).cuda()
spikes = layer(x)
```

### Training a Spiking Language Model

The `train_stories.py` script demonstrates training a **Spiking-LLM** on the TinyShakespeare dataset.

```bash
python train_stories.py
```

### Data Encoding

```python
from tether.data import SpikingDatasetWrapper, rate_encoding
from torchvision.datasets import MNIST

# Wrap MNIST to output spike trains
spiking_mnist = SpikingDatasetWrapper(
    MNIST(root="./data", download=True, train=True),
    encode_fn=lambda x: rate_encoding(x, n_steps=10)
)
```

## Architecture

- **`tether.kernels`**: Custom Triton kernels for LIF, ALIF, and PLIF.
- **`tether.functional`**: PyTorch autograd functions wrapping the Triton kernels.
- **`tether.nn`**: Neural network modules including `LIF`, `ALIF`, `PLIF`, `SpikingSelfAttention`.
- **`tether.data`**: Utilities for spike encoding and dataset wrapping.

## License

[Apache-2.0](https://github.com/Khushiyant/tether/blob/main/LICENSE)