semvec/pypi-packages huggingface dataset:
statikomand 0.0.3
Python static command parser. Like argparse, but without connection to CLI.
Requires Python: >=3.10

# Statikomand

Python static command parser.

> Like argparse, but without connection to CLI.

All CLI parsers interacts with user terminal in order to parse a command (python argparse calls sys.argv for example).

This python module provides tools for doing the same job, without any interaction with the user terminal. It just parses a raw string into a structured object.

It also provides a way to declare completion of arguments names and parameters.

## Getting Started

```bash
pip install statikomand
```

### Command parser

```python
from statikomand.komand_parser import KomandParser

parser = KomandParser()

parser.add_argument("-f", "--flag1", label="flag")
parser.add_argument("-d", "--delete", label="del")
parser.add_argument("POS1", label="pos1")
parser.add_argument("POS2")

code = "param1 param2 -f 'flag1 parameter' -d delete_param"
args = parser.parse(code)

print(args.pos1)  # value for POS1 positional argument : 'param1'
print(args.POS2)  # value for POS2 positional argument : 'param2'
```

### Command completion

> Each argument can have a completer method, which is a function that take one string argument, and returns a list of strings (proposition of completions)

The 'do_complete' method of the parser tries to complete the flag names, and calls the do_complete method of positional and / or flag arguments; according to the position of the last caracter.

Here is an example :

```python
from statikomand.komand_parser import KomandParser
def completer_1(code: str):
    return ["completion1", "completion2"]


def completer_2(code: str):
    return [code + code + code]


parser = KomandParser()

parser.add_argument("-f", "--flag1", label="flag", completer=completer_1)
parser.add_argument("-d", "--delete", label="del", completer=completer_2)
parser.add_argument("POS1", completer=completer_1)
parser.add_argument("POS2", completer=completer_2)

# completes positional parameter 1 with completer_1
code = "this-code-will-be-replaced-by-completer-1"
res = parser.do_complete(code)
print(res)  # proposition of completions for code : ['completion1', 'completion2']


# completes flag's name
code2 = "param1 param2 --fl"
res2 = parser.do_complete(code2)
print(res2)  # proposition of completions for code : ['--flag1']

# completes flag1 parameter with flag1 completer
code3 = "param1 param2 --flag1 blabla"
res3 = parser.do_complete(code3)
print(res3)  # proposition of completions for code : ['completion1', 'completion1']
```
carmapy 0.6.3
A python wrapper of the CARMA cloud aerosol model

[![Documentation Status](https://readthedocs.org/projects/carmapy/badge/?version=latest)](https://carmapy.readthedocs.io/en/latest/?badge=latest)

CARMApy is a python wrapper of the Community Aerosol and Radiation Model for Atmospheres (CARMA), originally developed by Turco et al. (1979) and Toon et al. (1979).  carmapy specifically wraps ExoCARMA, a version of CARMA developed by Gao et al. (2018) and Powell et al. (2018) to model clouds on exoplanets.  Note that this repository is in beta.

Read the documentation (including install instructions) here: [https://carmapy.readthedocs.io](https://carmapy.readthedocs.io)

## Roadmap
- [x] 2D CARMApy
    - [x] Finish Documentation
- [x] Microphysical Process rates in output
- [ ] Boundary Conditions
- [x] Viscosity 
- [x] Thermal Conductivity
- [x] Vertical Winds
- [ ] Benchmark CARMApy vs CARMA
- [ ] Test suite
- [ ] calculate mucos
kinobi 0.0.1
GTM intelligence engine — structured data for AI agents. Coming soon.
Requires Python: >=3.11

# kinobi

GTM intelligence engine — structured data for AI agents.

Warm paths, technographics, hiring signals, and relationship graphs — structured JSON for Claude Code, your scripts, or any MCP client.

**Coming soon at [kinobi.so](https://kinobi.so)**
colliderml 0.3.1
A modern machine learning library for high-energy physics data analysis
Requires Python: <3.12,>=3.10

# ColliderML

[![Tests](https://github.com/OpenDataDetector/ColliderML/actions/workflows/tests.yml/badge.svg?branch=main)](https://github.com/OpenDataDetector/ColliderML/actions/workflows/tests.yml)
![Coverage](./coverage.svg)
[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

A modern machine learning library for high-energy physics data analysis.

## Installation

```bash
pip install colliderml
```

For development: `pip install -e ".[dev]"`

## Getting the data

**Option 1 — CLI (download to local cache, then load with the library):**

```bash
colliderml download --channels ttbar --pileup pu0 --objects particles,tracker_hits,calo_hits,tracks --max-events 200
```

Cache location: default `~/.cache/colliderml`, or set `COLLIDERML_DATA_DIR`. List downloaded configs: `colliderml list-configs`.

**Option 2 — HuggingFace only:**

```python
from datasets import load_dataset
dataset = load_dataset("CERN/ColliderML-Release-1", "ttbar_pu0_particles", split="train")
```

## Using the library

The notebook [notebooks/colliderml_loader_exploration.ipynb](notebooks/colliderml_loader_exploration.ipynb) shows how to use the convenience functions: loading local Parquet with `load_tables`, exploding event tables, pileup subsampling, calibration, and plotting.

Full docs: <https://opendatadetector.github.io/ColliderML>

## Development

```bash
pytest -v -m "not integration"
```

Docs are built with VitePress: `npm ci --prefix docs && npm run --prefix docs docs:build`.

## License

[MIT License](LICENSE)