semvec/pypi-packages huggingface dataset:
docksible 1.0.1
Deploy and set up Docker Compose based web apps with Ansible
Requires Python: >=3.9

# Docksible

## About

Install a Dockerized web app on a given remote VPS, with a single command
in your local CLI - powered by Ansible.

Supports SSL, so it's perfect for quick demo servers, or even lightweight production
environments.

You can also install on localhost or local VMs, perfect for local experiments
with different types of apps.

## Features

* WordPress
* Joomla
* Redmine (open source issue tracker)
* "Custom app" - you simply provide a valid container name (from Docker Hub),
  and any required app specific environment variables (via `--extra-env-vars`), and it should work.
* SSL certs, including test certs
* SSH proxy to tunnel hidden services like database
* phpMyAdmin container
* Hopefully more soon ;-)

## Requirements

* Local: Unix with Python 3.9 or newer. Tested this on Gentoo and Ubuntu Linux.
  Might work on macOS, but I don't know. Won't work on Windows, because it uses
  Ansible under the hood, which AFAIK is not supported for Windows.
* Remote: VPS running Ubuntu, or maybe other Debian based flavor, reachable via SSH.
  It should probably work on all Debian distros, but I have only tested on Ubuntu.

## Installing

Intall with Pip: `python -m pip install docksible`

## Usage

These examples should be self explanatory:

* `docksible user@example.com wordpress --letsencrypt --email admin@example.com`
* `docksible user@example.com redmine --letsencrypt --email admin@example.com`

Run the `--help` flag for all supported options.

### Using the SSH proxy

You can include a [simple SSH proxy](https://github.com/belal-i/simple-ssh-proxy)
into your app's Docker network, by passing the `--ssh-proxy` flag. This will drop in
a small container that you can use to port forward some hidden services, like the
database. Here's how to do it:

* Include `--ssh-proxy` in the Docksible command (ex: `docksible user@host wordpress --ssh-proxy`)
* Set up the proxy service's `authorized_keys` file. This will be improved in the future,
  but until then:
  * SSH into your server as root
  * Copy root's `.ssh/authorized_keys` into `docksible-volumes/ssh-proxy-data/`
  * Shell into the proxy container, and basically `chown -R proxy_user:proxy_user /home/proxy_user`.
    This could also be improved, but for now, just needs to be done once.
* Now the proxy service is ready to use. For example:
  * Set up the tunnel to proxy the database:
  ```
  ssh -p 2222 proxy_user@yourserver.com -L 9000:docksible_db:3306
  ```
  * Connect to the database:
  ```
  mysql -u your_db_user -p --port=9000 --host=localhost --protocol=TCP
  ```
hangeul-jamo-rs 0.1.1
A high-performance Korean Hangul syllable and jamo manipulation library with Rust backend
Requires Python: >=3.13
Keywords: korean, hangul, jamo, nlp, korean-language, rust

# hangeul_jamo_rs

A high-performance Korean Hangul syllable and jamo manipulation library written in Rust with Python bindings.

## Features

- **Fast decomposition/composition** using pre-computed lookup tables
- **Dual API support**: Both Rust and Python
- **Two jamo formats**: HCJ (U+31xx) and U+11xx jamo
- **Compound jamo handling**: Decompose/compose complex jamo characters

## Installation

### Rust

```toml
[dependencies]
hangeul_jamo = "0.1"
```

## Usage

### Rust

```rust
use hangeul_jamo::hcj::{decompose_hcj, compose_hcj};

// HCJ decomposition/composition
assert_eq!(decompose_hcj("한글"), "ㅎㅏㄴㄱㅡㄹ");
assert_eq!(compose_hcj("ㅎㅏㄴㄱㅡㄹ"), "한글");

// U+11xx jamo
use hangeul_jamo::jamo::{decompose_jamo, compose_jamo};
let jamo = decompose_jamo("한글");
assert_eq!(compose_jamo(&jamo), "한글");

// Compound jamo
use hangeul_jamo::core::{decompose_compound, compose_compound};
assert_eq!(decompose_compound('ㄲ'), Some(vec!['ㄱ', 'ㄱ']));
assert_eq!(compose_compound(&['ㄱ', 'ㄱ']), Some('ㄲ'));
```

## API Reference

### Core Functions

#### HCJ (Hangul Compatibility Jamo - U+31xx)
- `decompose_hcj(text)` - Decompose syllables into HCJ jamo (한 → ㅎㅏㄴ)
- `compose_hcj(text)` - Compose HCJ jamo into syllables (ㅎㅏㄴ → 한)

#### U+11xx Jamo
- `decompose_jamo(text)` - Decompose syllables into U+11xx jamo
- `compose_jamo(text)` - Compose U+11xx jamo into syllables

#### Character Checks
- `is_hangul_syllable(ch)` - Check if character is Hangul syllable (U+AC00-U+D7A3)
- `is_hcj(ch)` - Check if character is HCJ (U+31xx)
- `is_jamo(ch)` - Check if character is U+11xx jamo
- `is_jamo_lead(ch)` - Check if leading consonant
- `is_jamo_vowel(ch)` - Check if vowel
- `is_jamo_tail(ch)` - Check if trailing consonant
- `is_jamo_compound(ch)` - Check if compound jamo (ㄲ, ㅘ, etc.)

#### Compound Jamo
- `decompose_compound(jamo)` - Decompose compound jamo (ㄲ → [ㄱ, ㄱ])
- `compose_compound(components)` - Compose into compound ([ㄱ, ㄱ] → ㄲ)

#### Conversion
- `jamo_to_hcj(ch)` - Convert U+11xx jamo to HCJ (ᄀ → ㄱ)
- `hcj_to_jamo(ch, position)` - Convert HCJ to U+11xx jamo (ㄱ → ᄀ)
  - `position`: "lead", "vowel", or "tail"