semvec/pypi-packages huggingface dataset:
PlaygroundMR01 0.1.0
PlaygroundMR0
Requires Python: >=3.9

[![Documentation Status](https://readthedocs.org/projects/mrzero-core/badge/?version=latest)](https://mrzero-core.readthedocs.io/en/latest/?badge=latest)

# MRzero Core

Test publishing package #2

The MRzero Core contains the core functionality of [MRzero](https://arxiv.org/abs/2002.04265) like MRI sequence building, simulation and reconstruction. MRzero Core does not force you to take any particular approach to e.g., reconstruction, as it targets easy integration in existing projects. Nevertheless, more tools can be added in the future if they helpful for the general application space.

## Usage

MRzero Core is written in [Python](https://www.python.org/), heavily relying on [PyTorch](https://pytorch.org/) for fast (GPU-) Tensor calculations.
To improve performance, parts of the simulation are written in [Rust](https://www.rust-lang.org/) and compiled for x86 Windows and Linux, other platforms are currently not supported.

Install with pip:
```
pip install MRzeroCore
```

The typical way of using it is like the following:
```python
import MRzeroCore as mr0
```

Examples on how to use can be found in the [Playground](https://mrzero-core.readthedocs.io/en/latest/playground_mr0/overview.html).

## Links

- Documentation: https://mrzero-core.readthedocs.io/
- Examples: [Playground](https://mrzero-core.readthedocs.io/en/latest/playground_mr0/overview.html)
- PyPI: https://pypi.org/project/mrzerocore/
- Original MRzero Paper: https://arxiv.org/abs/2002.04265

## Building from source

This assumes windows as host operating system. For building the python wheel, you need:
- the Rust toolchain: [rustup](https://rustup.rs/)
- the rust-python build tool tool: [pip install maturin](https://github.com/PyO3/maturin)
- for Linux crosscompilation: [docker](https://www.docker.com/)
- to build the documentation: [pip install jupyter-book](https://jupyterbook.org/en/stable/intro.html)

**Building for Windows**
```
maturin build --interpreter python
```
**Building for Linux**
```
docker run --rm -v <path-to-repo>/MRzero-Core:/io ghcr.io/pyo3/maturin build
```

To **build the documentation**, run
```
jupyter-book build documentation/
```
in the root folder of this project. This requires jupyter-book as well as MRzeroCore itself to be installed.


## Official builds

The [python wheels](https://pypi.org/project/mrzerocore/) hosted by [PyPI](https://pypi.org/) is built as described above, and uploaded as following:

```
maturin upload target/wheels/MRzeroCore-{ version }-cp37-abi3-win_amd64.whl target/wheels/MRzeroCore-{ version }-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl -u <pypi-user> -p <pypi-pwd>
```

The [documentation](https://mrzero-core.readthedocs.io/en/latest/intro.html) is built using [readthedocs](https://readthedocs.org/), which works the same as described above.
demetric 0.1.13
Simple and composable metric tracking and logging for ML
Requires Python: >=3.10

# Demetric

> Dead simple standard for metric logging

### Logging

```python
import demetric as dm

metrics = dm.Metrics.new('metrics/gpt2-3')

metrics.log('loss', value=loss, step=step)
metrics.log('accuracy', value=acc, step=step)
# ...
```


Creates:

```
runs/
  gpt2-3/
    loss.csv
    accuracy.csv
```

### Reading

```python
# single metrics
metrics = dm.Metrics('metrics/run1.0')
metrics.read('loss') # pd.DataFrame

# all metrics
metrics.read() # pd.DataFrame with a column per metric

# comparing runs
runs = { run: dm.Metrics(run) for run in ['metrics/version1', 'metrics/version2'] }
df = dm.compare(runs, 'loss') # pd.DataFrame with columns ("loss_run1.0", "loss_run1.1", ...)

# concatenating runs (i.e. they're the same experiment but trained by steps or something)
runs = [dm.Metrics(run) for run in ['metrics/part1', 'metrics/part2']]
df = dm.concat(runs, 'loss') # pd.DataFrame with cumulative step indices
```
thymus 0.1.8.1
Editor & browser for network configuration files
Requires Python: <4.0,>=3.9


![thymus_default_screen](https://github.com/blademd/thymus/assets/1499024/58f19ba5-2a04-410c-8e71-af8b92760cfa)

[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/thymus.svg)](https://img.shields.io/pypi/pyversions/thymus)
[![PyPI](https://img.shields.io/pypi/v/thymus.svg)](https://pypi.python.org/pypi/thymus)
[![Downloads](https://static.pepy.tech/badge/thymus)](https://static.pepy.tech/badge/thymus)
[![Downloads-per-month](https://img.shields.io/pypi/dm/thymus.svg)](https://img.shields.io/pypi/dm/thymus.svg)


# Thymus

[Thymus](https://en.wikipedia.org/wiki/Thymus_(plant)) — is a config browser and editor. Thymus understands the context of a network configuration file compared to popular text editors. It mimics the CLI of a selected platform. That allows you to navigate, display, and edit selected configuration parts based on their paths just like in your favorite network operation system. You can save edited versions many times, creating a history log. Thymus supports the diff among them and can roll back to any saved version.

Thymus does not require a connection to any network device but it can fetch a configuration from a remote machine via Telnet or SSH. Also, it can be used over SSH from a remote machine.

Thymus supports:

* Juniper JunOS (and probably other JunOS-like systems, e.g. SR-OS **with** MD-CLI)
* Cisco IOS/IOS-XE/NX-OS/XR-OS (and probably other IOS-like systems)
* Arista EOS

<details>
	<summary>Screenshots</summary>
	<hr>

 JunOS context screen

 ![thymus_junos_example](https://github.com/blademd/thymus/assets/1499024/de5709b0-44d4-4490-8a5b-c8f59dfb3ff9)

 IOS context screen

 ![thymus_ios_example](https://github.com/blademd/thymus/assets/1499024/51375ef1-f912-44eb-8432-13855f5d3920)

 Compare/diff between two configs (JunOS is just as an example)

 ![thymus_junos_compare_example](https://github.com/blademd/thymus/assets/1499024/a1f1cbbe-f45b-4830-bd58-fcccddcb79ca)


</details>

## Installation

Use `pip` or `pipx` to install the package (e.g., `pip install thymus` or `pipx install thymus`).

Requires Python **3.9**!

## Operations

Thymus operates in **TUI-based** mode thanks to the [Textual](https://textual.textualize.io/) library. This mode draws the full-scale user interface in your console with mouse support. From the Textual documentation:

	> On modern terminal software (installed by default on most systems), Textual apps can use **16.7 million** colors with mouse support and smooth flicker-free animation. A powerful layout engine and re-usable components makes it possible to build apps that rival the desktop and web experience.

	> Textual runs on Linux, macOS, Windows and probably any OS where Python also runs.


To run Thymus use the command:
```
python -m thymus
```

## Documentation

Please, refer to [Wiki](https://github.com/blademd/thymus/wiki).

## Feedback

[Telegram](https://t.me/blademd)
stnpy 0.3.1
Python port of R STN library
Requires Python: >=3.7

# stnpy
Python Library for Search Trajectory Networks

### Purpose

For the purposes of my Honours projecrt I have been using the following R library: [STNs](https://github.com/gabro8a/STNs)

However, it's not suited to my needs. For one, it's in R, which is horrible. Two, it assumes much that is not related to my work. For this reason I wish to port the R library to Python, which will allow me to both call it natively during my processing pipeline as well as cater it specifically to my needs.

#### Port Details

My port follows the same file conventions as the original, however, my port assumes there is only one run per file. I have also only ported the `create.py` and `metrics.py` files from the original for my purpose.