semvec/pypi-packages huggingface dataset:
listele 1.0.2
Just a printing listed version function.
Requires Python: >=3.9

# listele function

Prints the given iterable in a listed format with columns and spacing.

---

```python
listele(li:list|dict, column:int, /, *, spaces:int=30, find:str="", reverse:bool=False)
"""
- li      : An iterable
- column  : Output column number
- spaces  : Spaces between elements
- find    : Filters the output with given string
- reverse : Prints elements top to bottom instead of left to right (disabled by default)
"""
```

```python
# Usage example:

from listele import listele

import sysconfig
li = dir(sysconfig)         # list type object
di = sysconfig.get_paths()  # dict type object

print("Output1:")
listele(li, 4)

print("\n\nOutput2:")
listele(li, 4, find="path")

print("\n\nOutput3:")
listele(di, 2, spaces=70)

print("\n\nOutput4:")
listele(di, 1, find="include")

print("\n\nOutput5:")
listele([1, 2, 3, 4, 5], 3, reverse=True)
```
hiclassy 3.3.4.1
Python interface to the Cosmological Boltzmann code hi_class

# hi_class: Horndeski in the Cosmic Linear Anisotropy Solving System

<!-- ![hi_class logo](docs/hi_class_logo.gif) -->
<!-- <img src="docs/hi_class_logo.gif" alt="hi_class logo" width="140" align="right"> -->
<!-- <img src="docs/hi_class_logo.gif" alt="hi_class logo" width="140"> -->

hi_class extends the CLASS Boltzmann code to cover Horndeski and related scalar-tensor models of dark energy and modified gravity. It is based on CLASS by Julien Lesgourgues, with major inputs from Thomas Tram and others.

- Website: http://hiclass-code.net
- CLASS website: http://class-code.net

## Authors

- Emilio Bellini
- Ignacy Sawicki
- Miguel Zumalacarregui

## Installation

### From PyPI/TestPyPI

```bash
pip install hiclassy
```

This installs the Python wrapper and builds the C core. You need a working C compiler (e.g. gcc) and, optionally, OpenMP support for parallel execution.

### From source

```bash
make clean
make class
```

To build the Python wrapper, run:

```bash
make
```

If compilation fails, check the Makefile for compiler, optimization flags, and OpenMP settings.

## Quick start

Use the Python interface:

```python
from hiclassy import HiClass
```

The HiClass object is the equivalent of the Class object for standard Class. All methods and attributes, plus additional HiClass specific, are shared between the two. Then, the usage of the two should be equivalent. 

If you want to use the C executable instead, you can run:

```bash
./class explanatory.ini
```

Parameter documentation and examples are available in `hi_class.ini` and `explanatory.ini`, plus the example files in `gravity_models/`.

## Citing hi_class

If you use hi_class, please cite:

- M. Zumalacarregui, E. Bellini, I. Sawicki, J. Lesgourgues, P. Ferreira, "hi_class: Horndeski in the Cosmic Linear Anisotropy Solving System", JCAP 1708 (2017) no.08, 019, http://arxiv.org/abs/arXiv:1605.06102
- E. Bellini, I. Sawicki, M. Zumalacarregui, "hi_class: Background Evolution, Initial Conditions and Approximation Schemes", http://arxiv.org/abs/arXiv:1909.01828

Please also cite the relevant CLASS papers, including:

- CLASS I: Overview, http://arxiv.org/abs/1104.2932
- CLASS II: Approximation schemes, http://arxiv.org/abs/1104.2933

## Plotting utilities

The package includes the Class Plotting Utility `CPU.py` for plotting Cl's, P(k), and related outputs, including model comparisons. Run:

```bash
python CPU.py --help
```

A MATLAB helper is available in `plot_CLASS_output.m`.

## Development

We recommend developing from the GitHub repository:

https://github.com/emiliobellini/hi_class_public

For hi_class-specific updates, see this repository and the `gravity_models/` examples.

## Support

For support, please open an issue in the repository or refer to the documentation at http://hiclass-code.net.
tally-cli 0.11.0
A fast, configurable linter for Dockerfiles and Containerfiles
Requires Python: >=3.9

# tally-cli

A fast, configurable linter for Dockerfiles and Containerfiles.

## Installation

```bash
pip install tally-cli
```

## Usage

```bash
tally lint Dockerfile
tally lint --max-lines 100 Dockerfile
```

## Documentation

See the [GitHub repository](https://github.com/wharflab/tally) for full documentation.
mm-pymac 0.0.1
macOS utilities: tray/status bar apps and dialog notifications
Requires Python: >=3.14

# mm-pymac

macOS utilities for Python CLI apps: tray/status bar and alert dialogs.

## Installation

```bash
uv add mm-pymac
```

## Usage

### Tray / Status Bar

```python
from mm_pymac import TrayApp, MenuItem, MenuSeparator

app = TrayApp(title="My App")
app.set_menu([
    MenuItem("Status: running", enabled=False),
    MenuSeparator(),
    MenuItem("Quit", callback=lambda _: app.quit()),
])
app.start_timer(1.0, lambda: print("tick"))
app.run()
```

### Alerts

```python
from mm_pymac import show_alert

result = show_alert(
    "Your task is complete.",
    title="Done",
    buttons=("Cancel", "OK"),
    default_button="OK",
)
if result == "OK":
    print("User confirmed")
```
python-ztidentity 0.0.3
Pythonic Implementation of the ZeroTier Identity Cryptography
Requires Python: >=3.9

# python-ztidentity
Pythonic implementation of the ZeroTier Identity Keys

This is very slow and will not be useful for large scale key generation

## Help needed

This version uses a python based Salsa20 encryption algorithm to closely match the go code
Waiting on better library support or compiled extensions, this code is EXTREMELY slow but matches expected output
ilum-job-api 6.6.1
Ilum job python API
Requires Python: >=3.9

# Ilum Job API Python Package

![PyPI - Python Version](https://img.shields.io/badge/python-3.9%20%7C%203.10-blue)
![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)

This package provides an interface for interacting with Ilum's Job API using Python. With this package, you can create your own interactive spark job.
## Installation
Use pip to install the ilum-job-api package:

```bash
pip install ilum-job-api
```

## Usage
Here's a simple example of how to use it:

```python
from ilum.api import IlumJob
from random import random
from operator import add


class SparkPiInteractiveExample(IlumJob):

    def run(self, spark, config):
        partitions = int(config.get('partitions', '5'))
        n = 100000 * partitions

        def f(_: int) -> float:
            x = random() * 2 - 1
            y = random() * 2 - 1
            return 1 if x ** 2 + y ** 2 <= 1 else 0

        count = spark.sparkContext.parallelize(range(1, n + 1), partitions).map(f).reduce(add)

        return "Pi is roughly %f" % (4.0 * count / n)
```

For more detailed usage instructions, see our [Documentation](https://ilum.cloud/docs/) and [API Reference](https://ilum.cloud/docs/api/).

## License
This project is licensed under the terms of the Apache License 2.0.

## Contact
If you have any issues or feature requests, please [create an idea](https://roadmap.ilum.cloud/boards/feature-requests) on our board. For general questions or discussions, post a question [here](https://roadmap.ilum.cloud/boards/questions).