semvec/pypi-packages huggingface dataset:
CodeEntropy 1.0.7
CodeEntropy is a Python package for computing the configurational entropy of macromolecular systems using forces sampled from molecular dynamics (MD) simulations. It implements the multiscale cell correlation method to provide accurate and efficient entropy estimates, supporting a wide range of applications in molecular simulation and statistical mechanics.
Requires Python: >=3.11
Keywords: entropy, macromolecular systems, MD simulation

[//]: # (Badges)
[![CodeEntropy CI](https://github.com/CCPBioSim/CodeEntropy/actions/workflows/project-ci.yaml/badge.svg)](https://github.com/CCPBioSim/CodeEntropy/actions/workflows/project-ci.yaml)
[![Docs - Status](https://app.readthedocs.org/projects/codeentropy/badge/?version=latest)](https://codeentropy.readthedocs.io/en/latest/?badge=latest)
![PyPI - Version](https://img.shields.io/pypi/v/codeentropy?logo=pypi&logoColor=white)
![PyPI - Status](https://img.shields.io/pypi/status/codeentropy?logo=pypi&logoColor=white)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/CodeEntropy)
![PyPI - Total Downloads](https://img.shields.io/pepy/dt/codeentropy?logo=pypi&logoColor=white&color=blue)
![PyPI - Monthly Downloads](https://img.shields.io/pypi/dm/CodeEntropy?logo=pypi&logoColor=white&color=blue)
[![Coverage Status](https://coveralls.io/repos/github/CCPBioSim/CodeEntropy/badge.svg?branch=main)](https://coveralls.io/github/CCPBioSim/CodeEntropy?branch=main)

CodeEntropy
==============================
CodeEntropy is a Python package for computing the configurational entropy of macromolecular systems using forces sampled from molecular dynamics (MD) simulations. It implements the multiscale cell correlation method to provide accurate and efficient entropy estimates, supporting a wide range of applications in molecular simulation and statistical mechanics.

<p align="center">
<img src="docs/images/biosim-codeentropy_logo_grey.svg" alt="CodeEntropy logo" width="300"/>
</p>

See [CodeEntropy’s documentation](https://codeentropy.readthedocs.io/en/latest/) for more information.

## Copyright

Copyright (c) 2025 CCPBioSim


## Acknowledgements
 
Project based on 

- [arghya90/CodeEntropy](https://github.com/arghya90/CodeEntropy) version 0.3
- [jkalayan/PoseidonBeta](https://github.com/jkalayan/PoseidonBeta)
polars-hash 0.5.6
Stable non-cryptographic and cryptographic hashing functions for Polars
Requires Python: >=3.10

This plugin provides stable hashing functionality across different polars versions.

## Examples
### Cryptographic Hashers

```python
import polars
import polars_hash as plh

df = pl.DataFrame({
    "foo":["hello_world"]
})

result = df.select(plh.col('foo').chash.sha256())

print(result)

┌──────────────────────────────────────────────────────────────────┐
│ foo                                                              │
│ ---                                                              │
│ str                                                              │
╞══════════════════════════════════════════════════════════════════╡
│ 35072c1ae546350e0bfa7ab11d49dc6f129e72ccd57ec7eb671225bbd197c8f1 │
└──────────────────────────────────────────────────────────────────┘
```

### Non-cryptographic Hashers
```python
df = pl.DataFrame({
    "foo":["hello_world"]
})

result = df.select(plh.col('foo').nchash.wyhash())
print(result)
┌──────────────────────┐
│ foo                  │
│ ---                  │
│ u64                  │
╞══════════════════════╡
│ 16737367591072095403 │
└──────────────────────┘

```

### Geo Hashers
```python
df = pl.DataFrame(
    {"coord": [{"longitude": -120.6623, "latitude": 35.3003}]},
    schema={
        "coord": pl.Struct(
            [pl.Field("longitude", pl.Float64), pl.Field("latitude", pl.Float64)]
        ),
    },
)

df.with_columns(
    plh.col('coord').geohash.from_coords().alias('geohash')
)
shape: (1, 2)
┌─────────────────────┬────────────┐
│ coord               ┆ geohash    │
│ ---                 ┆ ---        │
│ struct[2]           ┆ str        │
╞═════════════════════╪════════════╡
│ {-120.6623,35.3003} ┆ 9q60y60rhs │
└─────────────────────┴────────────┘


pl.select(pl.lit('9q60y60rhs').geohash.to_coords().alias('coordinates'))
shape: (1, 1)
┌───────────────────────┐
│ coordinates           │
│ ---                   │
│ struct[2]             │
╞═══════════════════════╡
│ {-120.6623,35.300298} │
└───────────────────────┘
```


## Create hash from multiple columns
```python
df = pl.DataFrame({
    "foo":["hello_world"],
    "bar": ["today"]
})

result = df.select(plh.concat_str('foo','bar').chash.sha256())
```
Micro-Mastodon-Reader 1.1.1
Light Mastodon project file reader for Python
Requires Python: >=3.10

# Light Mastodon Reader for Python

This is a lighter version of [Mastodon Reader for Python](https://github.com/mastodon-sc/python-mastodon-importer) from [Chrisoph Sommer](https://github.com/sommerc).

Import the *spots and links tables*, *features*, *tags* and meta data from a *Mastodon project file*.

Ported to Python from: [matlab-mastodon-importer](https://github.com/mastodon-sc/matlab-mastodon-importer)

This reader is lighter mainly because it does not depend on `pandas` nor on `networkx` and it therefore only depends on `numpy`.

## Example

Read the mastodon file:

```python
from micromastodonreader import MicroMastodonReader

mr = MicroMastodonReader("demo/demo.mastodon")

# show meta data
meta_data = mr.read_metadata()

# read spot and link tables with features and tags columns
spots, links, tag_definition, features = mr.read(tags=True, features=True)
```

`spots` is a `numpy.ndarray` where:

- `spots[int_id]` is the cell with id `int_id`
- `spots[int_id, 0]` is the `x` coordinate of the cell `int_id`
- `spots[int_id, 1]` is the `y` coordinate of the cell `int_id`
- `spots[int_id, 2]` is the `z` coordinate of the cell `int_id`
- `spots[int_id, 3]` is the time of the cell `int_id`
- `spots[int_id, 3:10]` are the values of the elongation matrix representing the cell `int_id` sphere
- `spots[int_id, 10]` is the `bsrs` (??) of `int_id`

`links` is a `numpy.ndarray` where:

- `links[int_pos]` is an edge
- `links[int_pos, 2]` is the id of the edge
- `links[int_pos, 0]` is the id of the cell at time `t`
- `links[int_pos, 1]` is the id of the cell at time `t + 1`

`tag_definition` and `features` are a bit more complicated 🫠

You can also read information separately

```python
# read only spot and link tables
spots, links = mr.read_tables()

# read tag_definition
tag_definition = mr.read_tags()

# read features
mr.read_features()
```

## Installation

### Current version

`pip install git+git://github.com/GuignardLab/python-mastodon-importer-light`

### pip

`pip install micro-mastodon-reader`

more information [on PyPi](https://pypi.org/project/micro-mastodon-reader/)
vmux-cli 0.6.0
Run anything in the cloud. Replace uv run with vmux run.
Requires Python: >=3.10
Keywords: cloud, cloudflare, containers, distributed, ml, serverless, tmux, training

# vmux

Run anything in the cloud. Replace `uv run` with `vmux run`.

**[vmux.sdan.io](https://vmux.sdan.io)** | **[demos](https://vmux.sdan.io/demos.html)**

## Install

```bash
uv tool install vmux-cli
```

## Usage

```bash
vmux run python train.py
# like uv run, but in the cloud. you get a tmux session.

vmux run -d python train.py
# detached. close your laptop. job keeps running (up to 7 days).

vmux attach abc123
# back in your tmux session. from your phone, another laptop, wherever.

vmux run -d -p 8000 python server.py
# expose a port, get a preview URL. websockets just work.

vmux ps
vmux logs -f abc123
vmux stop abc123
```

## How it works

- AST parses your imports, bundles only what you need (skips .git, venvs, checkpoints, etc.)
- auto-detects deps from pyproject.toml, requirements.txt, or PEP 723 inline scripts
- editable packages? we find them, bundle them, install them (transitive deps too)
- runs on [cloudflare containers](https://developers.cloudflare.com/containers/) with 168h keepalive
- real tmux session inside. survives disconnects. reattach from anywhere.
- pre-baked image: pytorch, transformers, numpy, pandas, fastapi

## Limits

- 0.25 vCPU, 1GB RAM per job
- 2GB disk (ephemeral, R2 mount soon)
- 7 day max runtime (indefinitely soon)
- outbound network unrestricted, inbound via preview URLs
- experimental: some jobs may be randomly evicted

## Pricing

Free for the holidays, then $2/mo.

## License

MIT
cdef-pil-090126-1135 0.1.0
Parental income loss analysis pipeline.
Requires Python: >=3.9

# Parental Income Loss

## Stacked Event-Study Outputs
The stacked example writes results to:
- `output/stacked_event_study/stacked_results.csv`
- `output/stacked_event_study/stacked_results.parquet`

Each row contains:
- `sample`, `chapter`, `component` (event_time or horizon_*),
- `reference_year`, `target_year`, `event_time`,
- `att`, `se`, `conf_low`, `conf_high`,
- `n_pairs`, `n_treated`, `n_control`, `convergence`,
- `bucket_periods`, `horizon_start`, `horizon_end`, `horizon_label`, `bucket_weight`.

Bucket weighting defaults to treated-weighted (`n_treated`). Override with:
- `STACKED_BUCKET_WEIGHT=pairs`

## Quickstart: Custom Components
- Implement one or more of: `PopulationAssembler`, `CohortSelector`, `ExposureDetector`, `MatchingEngine`.
- Wire them into the pipeline with `CohortWorkflow::with_components`.
- Use `docs/component_contracts.md` to ensure required columns are present.

Example wiring:
```rust
let workflow = CohortWorkflow::with_components(builder, selector, matcher);
let outputs = workflow.run(sources, &detector, &registries, &plan, None)?;
```

## Stacked Event Study CLI
- Run the standalone stacked event-study on a parquet file:
  `cargo run -- --stacked-input path/to/stacked_inputs.parquet --did-outcome perindkialt13`
- Optional flags: `--stacked-samples`, `--stacked-chapter-col`, `--stacked-icd-col`,
  `--stacked-output-dir`, plus the existing `--stacked-*` config flags.

## Config Path Aliases
You can reference `[paths]` entries directly from `registry_pattern` to avoid repeating paths.
When a pattern equals a `*_path` key, it expands to that path and automatically appends
`/*.parquet` if no glob or `.parquet` suffix is provided. You can also set `base_path`
to resolve `/path/to/...` placeholders or relative patterns in covariates.

Example:
```toml
[paths]
base_path = "E:/workdata/708245/data/registers"
bef_path = "E:/workdata/708245/data/registers/bef"
akm_path = "E:/workdata/708245/data/registers/akm"

[[covariates]]
label = "employment"
registry_pattern = "akm_path"
column = "SOCIO13"

[[covariates]]
label = "education"
registry_pattern = "/path/to/uddf/*.parquet"
column = "HFAUDD"
```

## Docs
- Component contracts: `docs/component_contracts.md`
- Custom component example: `crates/pil/examples/custom_components.rs`
- Custom selector example: `crates/pil/examples/custom_selector.rs`
- Custom matcher example: `crates/pil/examples/custom_matcher.rs`
- Custom detector example: `crates/pil/examples/custom_detector.rs`
form-core-pygame 0.1.1
Form and widget core toolkit for Pygame
Requires Python: >=3.9
Keywords: pygame, gui, forms, widgets, formulario

# form_core_pygame

![License MIT](https://img.shields.io/badge/License-MIT-green.svg)

> **Note:** [Spanish README_es.md is available](https://github.com/acastr008/help_core_pygame/blob/main/README_ES.md)

## Description

**form_core_pygame** is a form management system for data entry within Pygame applications. It features a modular design that allows for easy expansion and the development of new container types and widgets.

The utility of some of the already developed widgets can, on its own, justify the use of this module.

## Project Status

A significant amount of functionality has been developed; however, less progress has been made regarding aesthetic aspects. These visual elements will receive much more attention in future versions.

## Documentation

- [Remaining documentation in English and Spanish](https://github.com/acastr008/help_core_pygame/blob/main/docs/README.md)


## Usage Examples

You can find a collection of programs demonstrating the various uses of **form_core_pygame** in the `examples/` directory.

## Quickstart: How to run example programs

A launcher is available in the project's root directory that displays a list of available example programs along with brief descriptions.

To execute a program, simply select it and click with your mouse. Use the following command to start the launcher:

```bash
python main.py
```