semvec/pypi-packages huggingface dataset:
postlette 0.3.0
A tiny desktop editor that adds Unicode emphasis for social posts.
Requires Python: >=3.10

# Postlette

![Postlette logo](https://raw.githubusercontent.com/chrislyons-dev/postlette/main/docs/images/logo-dark-navy.png)

A tiny desktop editor that adds Unicode emphasis for social posts.

Postlette uses Unicode characters, not rich text formatting. Type your post, style selected text with bold or italic, insert separators, and copy the result. Platforms may render these characters differently.

Rendering varies by platform.

Links:
- Docs: https://chrislyons-dev.github.io/postlette/
- Repo: https://github.com/chrislyons-dev/postlette

## Setup

Requires Python 3.10+.

```bash
git clone https://github.com/chrislyons-dev/postlette.git
cd postlette
python -m venv .venv
```

Activate the virtual environment:

```bash
# Windows
.venv\Scripts\activate

# macOS / Linux
source .venv/bin/activate
```

Install dependencies:

```bash
pip install -e ".[dev]"
```

## Usage

```bash
python main.py
```

Windows/Linux: use **Ctrl**. macOS: use **Cmd** for shortcuts.

1. Type or paste your post into the editor.
2. Select text and apply styling (Bold, Italic, etc.) from the toolbar.
3. Insert em dashes or separators at the cursor.
4. Use 📂 to open a `.txt` file or 💾 to save your work (shortcuts: `Ctrl+O`, `Ctrl+S`, `Ctrl+Shift+S`).
5. Click **Copy** (or press `Ctrl+Shift+C`) to copy the result to your clipboard.

Use styling sparingly for readability.

## Test

```bash
python tasks.py test
```

## Lint

```bash
python tasks.py lint    # check
python tasks.py fix     # auto-fix
```

## Security audit

```bash
python tasks.py audit
```

## Icons

Convert an SVG into PNG + ICO + ICNS (dev-only deps):

```bash
python tasks.py icons .\docs\images\logo-dark.svg transparent
```

## Docs (MkDocs)

Serve locally:

```bash
python tasks.py docs-serve
```

Build static site:

```bash
python tasks.py docs-build
```

GitHub Pages deploys automatically on `main` via `.github/workflows/docs.yml`.

## Release

Release builds are tag-driven and publish to GitHub Releases and PyPI.

1. Update the version in `pyproject.toml`.
2. Commit the change.
3. Create and push a tag like `v0.2.0`.

The release workflow will:

- Build Windows and macOS PyInstaller artifacts.
- Generate SHA-256 checksums.
- Create a GitHub Release with auto-generated notes.
- Publish sdist/wheel to PyPI via Trusted Publishing.

See `RELEASING.md` for the full checklist.

## Build

Standalone executables are built with PyInstaller. Each OS requires its own build.

```bash
python tasks.py build
```

### Windows

```bash
pip install pyinstaller
pyinstaller --onefile --windowed --name postlette --icon docs/images/logo-dark-navy.ico main.py
```

The executable will be in `dist/postlette.exe`.

### macOS

```bash
pip install pyinstaller
pyinstaller --onefile --windowed --name postlette main.py
```

The app bundle will be in `dist/postlette.app`.

**Note:** Distributing on macOS may require codesigning and notarization.

## License

MIT
vector-ta 0.1.2
High-performance technical analysis indicators with optional SIMD/CUDA and language bindings.
Requires Python: >=3.9
Keywords: technical-analysis, trading, indicators, finance

# vector-ta

VectorTA is a Rust crate of technical analysis indicators focused on speed and predictable allocations, with optional SIMD/CUDA acceleration and optional Python/WASM bindings.

Full documentation (indicator list, API reference, and guides): https://vectoralpha.dev/projects/ta

The CUDA bindings are predominantly only worth using if used in a VRAM-resident workflow. For example, I can achieve a benchmark timing of 6.08 ms for 250 million calculated ALMA indicator data points on an RTX 4090, whereas the CPU (AMD 9950X) AVX-512, AVX2, and scalar timings are approximately 140.61 ms, 188.64 ms, and 386.20 ms, respectively.

The Tauri backtest optimization demo application using this library can achieve 58300 backtests for a double ALMA crossover strategy over 200k data points in only 158.71 milliseconds on the same hardware (RTX 4090 + AMD 9950X). 



## Rust usage

Example: ADX over HLC slices

```rust
use vector_ta::indicators::adx::{adx, AdxInput, AdxParams};

fn compute_adx(
    high: &[f64],
    low: &[f64],
    close: &[f64],
) -> Result<Vec<f64>, Box<dyn std::error::Error>> {
    let input = AdxInput::from_slices(high, low, close, AdxParams { period: Some(14) });
    Ok(adx(&input)?.values)
}
```

## Features

- `cuda`: GPU acceleration using prebuilt PTX (compute_89) shipped in the crate.
- `cuda-build-ptx`: You can compile PTX from `kernels/cuda/**` using `nvcc`.
- `nightly-avx`: Runtime-selected AVX2/AVX512 kernels on `x86_64` (nightly required).
- `python`: PyO3 bindings (build from source via `maturin`).
- `wasm`: wasm-bindgen bindings (build from source via `wasm-pack`).

## Python (optional)

Build + install into a virtualenv:

```bash
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -U pip maturin numpy
maturin develop --release --features python
```

### Publishing (PyPI)

Python wheels are published by GitHub Actions on version tags:

- Add a repo secret `PYPI_API_TOKEN` (PyPI API token with upload permissions).
- Bump `Cargo.toml` to the desired version.
- Push a matching tag like `v0.1.2` (tags containing `-` are treated as pre-releases and won't publish).

## WASM (optional)

Build with `wasm-pack`:

```bash
rustup target add wasm32-unknown-unknown
wasm-pack build --target nodejs --release --features wasm
```

## CUDA (optional)

Enable:

```toml
[dependencies]
vector-ta = { version = "0.1.2", features = ["cuda"] }
```

Notes:
- To force-disable CUDA probing/usage (tests/CI): set `CUDA_FORCE_SKIP=1`.
- To override where prebuilt PTX is sourced from, set `VECTOR_TA_PREBUILT_PTX_DIR` (see docs link above).

## License

Apache-2.0 (see `LICENSE`).
clams-utils 260131
a collection of smaller helper/utility code of CLAMS platform

# clams-utils

Repository that holds a collection of smaller helper/utility code of CLAMS platform.
Use PyPI release to install the package. 

``` bash 
pip install clams-utils
```

## Usage

Currently, this package provides utilities for speicific tasks related to the American Archive of Public Broadcasting (AAPB) project via `clams_utils.aapb` subpackage. All utilities are accessible via the command line interface (CLI) or can be imported as Python modules. See help messages for more details on included utilities.

``` bash
clams-aapb --help
```