semvec/pypi-packages huggingface dataset:
societal-costs-pipeline-2026-02-04-1400 0.1.0
Societal costs pipeline CLI.
Requires Python: >=3.9

# societal_costs

Workspace for the societal costs study.

## Crates

- `crates/costs_core` — core domain types, aggregation, pricing, and validation.
- `crates/costs_models` — two-part, Tweedie, and log-normal models + selection tools.
- `crates/costs_matching` — matching + balance diagnostics.
- `crates/costs_cohort` — cohort assignment + diagnostics.
- `crates/costs_components` — register-derived component builders (LMDB volume so far).
- `crates/costs_pipeline` — configuration, orchestration, and report outputs.

## LMDB example

See `crates/costs_pipeline/README.md` for the LMDB ingestion example.

## Pipeline config

Start from `pipeline.example.toml` and update the register file paths to match
your local dataset layout. Most SAS7BDAT paths accept either a single file
or a directory (all `.sas7bdat` files are loaded, sorted by name). You can
also set `base_path` in the config to prefix all relative register paths.
File filtering uses `study.data_*` and optional `study.baseline_*` /
`study.followup_*` windows to avoid reading out-of-scope files.
Event registers (VNDS/DOD/DODSAARS/DODSAASG) are **not** year-filtered.
If you use contact-based SCD classification, set
`components.lpr.scd_inpatient_contact_types` (or flip
`components.lpr.scd_allow_outpatient = true` to allow outpatient contacts).

Pipeline outputs include consolidated QC under `qc_summary.csv/json`, plus
step-specific outputs such as `lpr_episode_qc.csv`, `matching_outcome_qc.csv`,
`matching_parent_qc.csv`, and `population_public_stats.csv`.

For terminal progress and timing, set:
- `pipeline.progress = true`
- `pipeline.log_level = "info"` (or `debug`)

## Additional docs

- `crates/costs_core/README.md` — core domain and aggregation usage.
- `crates/costs_models/README.md` — model APIs and examples.
- `crates/costs_models/examples/README.md` — runnable model examples.
- `crates/costs_components/README.md` — LMDB note (missing price fields).
- `crates/costs_pipeline/README.md` — pipeline usage and LMDB example.
briefcasex-slint 1.15.0b1
Plugin for Briefcase to offer Slint application templates
Requires Python: >=3.10


# Briefcase Slint Plugin

The `briefcasex-slint` package extends the [Briefcase](https://briefcase.beeware.org/en/stable/) tool
with support for Slint as toolkit for standalone applications.

Install it in your Python environment, and `briefcase new` will offer you Slint as GUI framework for your next application.

## Get Started

In a terminal, create a new Python environment and run the following commands:

1. `pip install briefcasex-slint`
2. `briefcase new -Q bootstrap=Slint`

Following the instructions on the screen.
pychemelt 0.1.13
Add your description here
Requires Python: >=3.12

# Work in Progress!

# PyChemelt

[![Tests](https://github.com/osvalB/pychemelt/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/osvalB/pychemelt/actions/workflows/ci-cd.yml)
[![codecov](https://codecov.io/gh/osvalB/pychemelt/graph/badge.svg)](https://codecov.io/gh/osvalB/pychemelt)
[![Docs](https://img.shields.io/badge/docs-online-blue)](https://osvalb.github.io/pychemelt)


# Install from Source - Development

Run these commands in your shell:

```bash
git clone https://github.com/osvalB/pychemelt.git
cd pychemelt
uv sync --extra dev
```

# Verify Installation

Run the following to verify the installation:

```bash
uv run pytest
uv run build_docs.py
```
dovepy 0.0.1a2
Experimental DOVE encryption algorithm (NOT production secure)
Requires Python: >=3.9

# 🕊️ DOVE — Experimental Encryption Algorithm (Python Version)

⚠️ WARNING: EXPERIMENTAL & NOT PRODUCTION-READY
DOVE is a research / experimental encryption algorithm.
Do NOT use this library to protect real, sensitive, or valuable data.

## Overview

DOVE is an experimental encryption algorithm implemented in Python for learning, research, and cryptographic exploration.

This project is not a replacement for established cryptographic standards such as `AES`, `ChaCha20`, or `RSA`.
It exists to explore ideas such as:

- Custom S-Box–based transformations

- Tag / authentication value evolution

- Byte-level operations

- Algorithm design trade-offs

## ⚠️ Security Disclaimer (Read This First)

- ❌ NOT audited

- ❌ NOT peer-reviewed

- ❌ NOT proven secure

- ❌ Vulnerable to cryptanalysis

If you need real security, use well-established libraries like cryptography, PyNaCl, hashlib (for hashing)

By using DOVE, you accept full responsibility for any consequences.

### Installation

```{py}
pip install dovepy
```

Installation does not imply stability or security.

### Basic Usage

```{python}
from dovepy import DOVE 

message = "Only I allow who will know my secrets."
key1 = "Matsubishi"
key2 = "Nissan"

cipher, salt, tag = DOVE.encrypt(message.encode("utf-8"), key1, key2)
print("Cipher:", cipher.hex()) #bytes , key1 and key2 are strings
print("Salt:", salt.hex()) #bytes
print("Tag:", tag) #int 

recovered = DOVE.decrypt(cipher, key1, key2, salt, tag)
print("Decrypted:", recovered.decode("utf-8"))
```

## Design Notes

- DOVE operates at the byte level

- Uses a custom S-Box

- Maintains an evolving authentication tag

- Focuses on simplicity and experimentation rather than performance or security guarantees

- This design intentionally avoids hiding complexity — the goal is learning, not obscurity.

## What This Project Is For

- ✅ Cryptography learning
- ✅ Algorithm experimentation
- ✅ Educational use
- ✅ Research and exploration
- ✅ Personal hidden projects
- ✅ Secondary data obfuscation

## What This Project Is NOT For

- ❌ Production encryption
- ❌ Protecting passwords
- ❌ Financial data
- ❌ Personal or private data directly

## Versioning & Stability

Current status:

- Development Stage:         Pre-Alpha

- API Stability:             Unstable

- Backward Compatibility:    Not guaranteed

Breaking changes may happen at any time.

## Testing

This project uses pytest for testing.

```{python}
pytest
```

Benchmarks:

```{python}
pytest --benchmark-only
```

## License

Licensed under the Apache-2.0 License.

## A few words

If you are studying cryptography: `Designing crypto is easy. Designing secure crypto is extremely hard.` DOVE is a step toward understanding why.

If you are curious about why an experimental encryption algorithm like DOVE was published, We plan to extend our research and build the most secure encryption algorithm oneday if we have enough fundings.......