semvec/pypi-packages huggingface dataset:
pyplotdesigner 0.5.0
A set of tools to help format matplotlib figures

# pyplotdesigner

Design matplotlib figure layouts visually, then reuse them in Python.

PyPI package: https://pypi.org/project/pyplotdesigner/

## Quickstart (recommended: PyPI)

## 1) Install with pip
```bash
pip install -U pip
pip install pyplotdesigner
```

## 2) Start the GUI
```bash
python -m pyplotdesigner.gui.main
```

This opens your browser automatically. If it does not, open:
- `http://127.0.0.1:8080/ui`

Optional:
- `python -m pyplotdesigner.gui.main --no-browser` (disable auto-open)
- `python -m pyplotdesigner.gui.main --reload` (enable auto-reload for dev)

## 3) Build a layout in the GUI
1. Click **Add Axis**.
2. Drag boxes into place.
3. Add constraints (align, match size, aspect ratio, spacing, etc.).
4. Click **Import/Export** and copy the base64 layout string.

## 4) Use the exported layout in Python
```python
from pyplotdesigner.core.design_loader import make_figure_from_b64

layout_b64 = "PASTE_EXPORTED_STRING"
fig, axes = make_figure_from_b64(layout_b64)

# Example:
# left_panel = axes['left_panel']
# left_panel.plot([0, 1], [0, 1])
```

## If you need to: clone and install locally
```bash
git clone git@github.com:gnwong/pyplotdesigner.git
cd pyplotdesigner
pip install -U pip
pip install -e .
```

## Run tests
```bash
pip install pytest
pytest
```

## Frontend E2E tests (Playwright)
These tests exercise the real browser UI against the FastAPI app.

Install once:
```bash
npm install
npx playwright install chromium
```

Run E2E suite:
```bash
npm run e2e
```

Useful variants:
```bash
npm run e2e:headed
npm run e2e:ui
```

## Contributing
Contributions are welcome.

Expected workflow:
1. Open an issue (or reference an existing one) describing the change.
2. Create a focused branch and implement the change.
3. Add or update tests for any new feature or behavior change.
4. Run tests locally (`pytest`) and make sure they pass.
5. Open a PR with a clear summary and testing notes.

Guidelines:
- Keep changes focused and minimal.
- Preserve existing behavior unless your PR intentionally changes it.
- If behavior changes, document it and include regression coverage.

## License
MIT (see `LICENSE`).
zelos-sdk 0.0.9
Use the Zelos SDK to push data into the Zelos App, Zelos Agent or directly to Zelos Cloud.
Requires Python: >=3.10

# Zelos SDK

Zelos is the data platform for mission‑critical systems. We help teams observe, control, and test their system on a collaborative platform – from prototype to production.

Use the Zelos SDK to push data into the Zelos App, Zelos Agent or directly to Zelos Cloud.

# Example: Logging Random Data

Install `uv` and save the file below as `zelos_random.py` and run `uv run zelos_random.py` to start streaming data live.

```python
#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.10"
# dependencies = [ "zelos-sdk" ]
# ///
import random
import time

import zelos_sdk

zelos_sdk.init()

src = zelos_sdk.TraceSource("example_source")
while True:
    src.log("example/message", {"value": random.randint(0, 10)})
    time.sleep(0.01)
```

# Example: Logging Thermal Zones on Linux

Linux supports reading temperature sensors via sysfs. On a linux system, install `uv` and save the file below as
`temp_linux.py` and run `uv run temp_linux.py` to start streaming data live.

```python
#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.10"
# dependencies = [ "zelos-sdk" ]
# ///
from pathlib import Path
import time

import zelos_sdk

zelos_sdk.init()

# Find all of our thermal zones from sysfs
thermal_zones = list(Path("/sys/class/thermal").glob("thermal_zone*"))

# Once per second, read the zone info and log it
src = zelos_sdk.TraceSource("linux_thermal")
while True:
    for zone_path in thermal_zones:
        # Read the zone info from sysfs
        zone_type = (zone_path / "type").read_text().strip()
        zone_temp_c = int((zone_path / "temp").read_text().strip()) / 1000.0

        # Log to the zelos sdk
        src.log(zone_path.name, {"type": zone_type, "temp_c": zone_temp_c})

    time.sleep(1)
```
pymultio 2.8.0.11
A Python interface to multio.
Requires Python: >=3.9
Keywords: multio, multiopython, tools

multio
======

[![Build Status](https://img.shields.io/github/actions/workflow/status/ecmwf/multio/ci.yml?branch=develop)](https://github.com/ecmwf/multio/actions/workflows/ci.yml?query=branch%3Adevelop)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/ecmwf/multio/blob/develop/LICENSE)

multio is a package developed by ECMWF that provides an application programming interface (API) for

   * I/O-server functionality for distributed earth-system models,
   * post-processing pipelines of user-programmable list of actions.

The fundamental design principle behind multio is that data is decoupled from metadata, and that the
metadata is used for routing the data through the post-processing pipelines.


Documentation
-------------

The documentation can be found at https://multio.readthedocs.io.


Requirements
------------

Runtime dependencies:

- eccodes -- http://github.com/ecmwf/eccodes
- eckit -- http://github.com/ecmwf/eckit
- metkit -- http://github.com/ecmwf/metkit

Optional runtime dependencies:

- fdb -- http://github.com/ecmwf/fdb
- fckit -- http://github.com/ecmwf/fckit (for the fortran example code only)

Build dependencies:

- CMake -- For use and installation see http://www.cmake.org/
- ecbuild -- ECMWF library of CMake macros (available via apt or see https://github.com/ecmwf/ecbuild)
- MPI -- an implementation of MPI may be required for the I/O-server functionality, see https://www.mpi-forum.org/


Installation
------------

multio employs an out-of-source build/install based on CMake.

Make sure ecbuild is installed and the ecbuild executable script is found ( `which ecbuild` ).

Now proceed with installation as follows.

1. Set up environment as appropriate
   ```bash
   srcdir=$(pwd)
   builddir=build
   installdir=$HOME/local
   ```

2. Run Cmake/ecbuild
   ```bash
   ecbuild --prefix=$installdir -- -DCMAKE_PREFIX_PATH=<path/to/dependencies/install> $srcdir
   ```

   The package is in active development and the I/O-server functionality is not enabled by default, so
   it needs to be turned on explicitly. In addition, if built with FDB support, some compilers will
   require linking to be forced.
   ```bash
   ecbuild --prefix=$installdir -- -DCMAKE_PREFIX_PATH=<path/to/dependencies/install> -DECBUILD_EXE_LINKER_FLAGS=-Wl,--no-as-needed $srcdir
   ```

3. Compile, test and install
   ```bash
   make -j10
   ctest
   make install
   ```


GIT hooks
---------

Please run the following command in the project root to use our git hooks:
```bash
git config core.hooksPath .githooks
```


Copyright and license
---------------------

(C) Copyright 2005- ECMWF.

This software is licensed under the terms of the Apache Licence Version 2.0 which can be obtained at
http://www.apache.org/licenses/LICENSE-2.0.

In applying this licence, ECMWF does not waive the privileges and immunities granted to it by virtue
of its status as an intergovernmental organisation nor does it submit to any jurisdiction.
pygribjump 0.10.3.11
Python interface to GribJump
Requires Python: >=3.9

# GribJump

[![Static Badge](https://github.com/ecmwf/codex/raw/refs/heads/main/Project%20Maturity/incubating_badge.svg)](https://github.com/ecmwf/codex/raw/refs/heads/main/Project%20Maturity)

GribJump is a C++ library for extracting subsets of data from GRIB files, particularly data archived in the [FDB](https://github.com/ecmwf/fdb).

<!-- :warning: **This is a work in progress.** Expect bugs, and for interfaces and functionality to change. Consult the developers before using. -->

> \[!IMPORTANT\]
> This software is **Incubating** and subject to ECMWF's guidelines on [Software Maturity](https://github.com/ecmwf/codex/raw/refs/heads/main/Project%20Maturity).

## Installation

### Dependencies

Currently, GribJump has the following runtime dependencies:

- [eccodes](https://github.com/ecmwf/eccodes)
- [eckit](https://github.com/ecmwf/eckit)
- [metkit](https://github.com/ecmwf/metkit)
- [fdb5](https://github.com/ecmwf/fdb)
- [libaec](https://github.com/MathisRosenhauer/libaec)

as well as [ecbuild](https://github.com/ecmwf/ecbuild) for building.

### C++ Library

Building and installing:

```bash
   # Environment --- Edit as needed
   srcdir=$(pwd)
   builddir=build
   installdir=$HOME/local  
   
   # 1. Create the build directory:
   mkdir $builddir
   cd $builddir

   # 2. Run ecbuild
   ecbuild --prefix=${installdir} -- \
   -DENABLE_MEMFS=ON \
   -DENABLE_ECCODES_THREADS=ON \
   -DENABLE_AEC=ON \
   -DCMAKE_INSTALL_PREFIX=$</path/to/installations> ${srcdir}
   
   # 3. Compile / Install
   make -j10
   make install
```

A clientside build (which cannot extract data but talks to a server which can) is built using the flag `-DENABLE_GRIBJUMP_LOCAL_EXTRACT=OFF`. This requires only eckit and metkit to be installed.

### Python Library

The python interface, `pygribjump`, can be installed with pip:

```bash
python3 -m pip install --upgrade git+ssh://git@github.com/ecmwf/gribjump.git@master
```

`pygribjump` uses [findlibs](https://github.com/ecmwf/findlibs) to find an installed `libgribjump` library. You can use `export GRIBJUMP_HOME=/path/to/gribjump/install` to help with finding the library.

See the `docs/examples/` files for simple use cases.


## Acknowledgements

Past and current funding and support is listed in the [Acknowledgements](./ACKNOWLEDGEMENTS.rst).
odclib 1.6.2.11
"odclib"

# odc

[![Build Status](https://img.shields.io/github/workflow/status/ecmwf/odc/Continuous%20Integration/develop)](https://github.com/ecmwf/odc/actions/workflows/ci.yml)
[![Documentation Status](https://readthedocs.org/projects/odc/badge/?version=latest)](https://odc.readthedocs.io/en/latest/?badge=latest)
[![Licence](https://img.shields.io/github/license/ecmwf/odc)](https://github.com/ecmwf/odc/blob/develop/LICENSE)
[![PyPI](https://img.shields.io/pypi/v/odclib)](https://pypi.org/project/odclib/)

C, C++ and Fortran libraries providing encoders and decoders and interrogation of meteorological data encoded in ODB-2 format as well as command line tools for investigation and manipulation of ODB-2 data.

[Documentation]

## Dependencies

### Required

* C or C++ compiler
* [CMake]
* [ecbuild]
* [eckit]

### Optional

* Fortran compiler
* [Doxygen]

## Installation

```sh
git clone https://github.com/ecmwf/odc
cd odc

# Setup environment variables (edit as needed)
SRC_DIR=$(pwd)
BUILD_DIR=build
INSTALL_DIR=$HOME/local
export eckit_DIR=$INSTALL_DIR # set to eckit install prefix

# Create the the build directory
mkdir $BUILD_DIR
cd $BUILD_DIR

# Run ecbuild (CMake)
ecbuild --prefix=$INSTALL_DIR -- $SRC_DIR

# Build and install
make -j10
make test # optional
make install

# Check installation
$INSTALL_DIR/bin/odc --version
```

## Usage

Include the `odc` headers like so:

```c
// odc_test.c
#include "odc/api/odc.h"

int main() {
   odc_initialise_api();
   return 0;
}
```

Make sure to reference the linked library when compiling:

```sh
gcc -lodccore odc_test.c
```

## Build Documentation

The documentation is generated using Sphinx.

First, make sure that `Doxygen` module is available, and then install Python dependencies in your environment:

```sh
cd docs
pip install -r requirements.txt
```

You can then build the documentation by using **make**:

```sh
cd docs
make html
```

The built HTML documentation will be available under the `docs/_build/html/index.html` path.

## Licence

This software is licensed under the terms of the Apache Licence Version 2.0 which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.

In applying this licence, ECMWF does not waive the privileges and immunities granted to it by virtue of its status as an intergovernmental organisation nor does it submit to any jurisdiction.

[Documentation]: https://odc.readthedocs.io/en/latest/
[CMake]: https://cmake.org
[ecbuild]: https://github.com/ecmwf/ecbuild
[eckit]: https://github.com/ecmwf/eckit
[Doxygen]: https://www.doxygen.nl
multiolib 2.8.0.11
"multiolib"

multio
======

[![Build Status](https://img.shields.io/github/actions/workflow/status/ecmwf/multio/ci.yml?branch=develop)](https://github.com/ecmwf/multio/actions/workflows/ci.yml?query=branch%3Adevelop)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/ecmwf/multio/blob/develop/LICENSE)

multio is a package developed by ECMWF that provides an application programming interface (API) for

   * I/O-server functionality for distributed earth-system models,
   * post-processing pipelines of user-programmable list of actions.

The fundamental design principle behind multio is that data is decoupled from metadata, and that the
metadata is used for routing the data through the post-processing pipelines.


Documentation
-------------

The documentation can be found at https://multio.readthedocs.io.


Requirements
------------

Runtime dependencies:

- eccodes -- http://github.com/ecmwf/eccodes
- eckit -- http://github.com/ecmwf/eckit
- metkit -- http://github.com/ecmwf/metkit

Optional runtime dependencies:

- fdb -- http://github.com/ecmwf/fdb
- fckit -- http://github.com/ecmwf/fckit (for the fortran example code only)

Build dependencies:

- CMake -- For use and installation see http://www.cmake.org/
- ecbuild -- ECMWF library of CMake macros (available via apt or see https://github.com/ecmwf/ecbuild)
- MPI -- an implementation of MPI may be required for the I/O-server functionality, see https://www.mpi-forum.org/


Installation
------------

multio employs an out-of-source build/install based on CMake.

Make sure ecbuild is installed and the ecbuild executable script is found ( `which ecbuild` ).

Now proceed with installation as follows.

1. Set up environment as appropriate
   ```bash
   srcdir=$(pwd)
   builddir=build
   installdir=$HOME/local
   ```

2. Run Cmake/ecbuild
   ```bash
   ecbuild --prefix=$installdir -- -DCMAKE_PREFIX_PATH=<path/to/dependencies/install> $srcdir
   ```

   The package is in active development and the I/O-server functionality is not enabled by default, so
   it needs to be turned on explicitly. In addition, if built with FDB support, some compilers will
   require linking to be forced.
   ```bash
   ecbuild --prefix=$installdir -- -DCMAKE_PREFIX_PATH=<path/to/dependencies/install> -DECBUILD_EXE_LINKER_FLAGS=-Wl,--no-as-needed $srcdir
   ```

3. Compile, test and install
   ```bash
   make -j10
   ctest
   make install
   ```


GIT hooks
---------

Please run the following command in the project root to use our git hooks:
```bash
git config core.hooksPath .githooks
```


Copyright and license
---------------------

(C) Copyright 2005- ECMWF.

This software is licensed under the terms of the Apache Licence Version 2.0 which can be obtained at
http://www.apache.org/licenses/LICENSE-2.0.

In applying this licence, ECMWF does not waive the privileges and immunities granted to it by virtue
of its status as an intergovernmental organisation nor does it submit to any jurisdiction.
mirlib 1.27.10.11
"mirlib"

mir
===

[![codecov](https://codecov.io/gh/ecmwf/mir/branch/develop/graph/badge.svg)](https://app.codecov.io/gh/ecmwf/mir)
[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/ecmwf/mir/blob/develop/LICENSE)
metkitlib 1.16.1.11
"metkitlib"


[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/ecmwf/metkit/blob/develop/LICENSE)
[![Static Badge](https://github.com/ecmwf/codex/raw/refs/heads/main/Project%20Maturity/graduated_badge.svg)](https://github.com/ecmwf/codex/raw/refs/heads/main/Project%20Maturity#graduated))

> \[!IMPORTANT\]
> This software is **Graduated** and subject to ECMWF's guidelines on [Software Maturity](https://github.com/ecmwf/codex/raw/refs/heads/main/Project%20Maturity).

# metkit

## Requirements

Runtime dependencies:

- eckit -- http://github.com/ecmwf/eckit

Build dependencies:

- CMake --- For use and installation see http://www.cmake.org/
- ecbuild --- ECMWF library of CMake macros ()

## Installation

metkit employs an out-of-source build/install based on CMake.

Make sure ecbuild is installed and the ecbuild executable script is found ( `which ecbuild` ).

Now proceed with installation as follows:

```bash
# Environment --- Edit as needed
srcdir=$(pwd)
builddir=build
installdir=$HOME/local  

# 1. Create the build directory:
mkdir $builddir
cd $builddir

# 2. Run CMake
ecbuild --prefix=$installdir -- -DECKIT_PATH=<path/to/eckit/install> $srcdir

# 3. Compile / Install
make -j10
make install
```

## Release

Config files should be updated before releasing a new version.
Please refer to the documentation available on [Confluence](https://confluence.ecmwf.int/display/METK/MetKit+configuration)


## License

Copyright 2021 European Centre for Medium-Range Weather Forecasts (ECMWF)

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
> http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

In applying this licence, ECMWF does not waive the privileges and immunities granted to it by virtue of its status as an intergovernmental organisation nor does it submit to any jurisdiction.
gribjumplib 0.10.3.11
"gribjumplib"

# GribJump

[![Static Badge](https://github.com/ecmwf/codex/raw/refs/heads/main/Project%20Maturity/incubating_badge.svg)](https://github.com/ecmwf/codex/raw/refs/heads/main/Project%20Maturity)

GribJump is a C++ library for extracting subsets of data from GRIB files, particularly data archived in the [FDB](https://github.com/ecmwf/fdb).

<!-- :warning: **This is a work in progress.** Expect bugs, and for interfaces and functionality to change. Consult the developers before using. -->

> \[!IMPORTANT\]
> This software is **Incubating** and subject to ECMWF's guidelines on [Software Maturity](https://github.com/ecmwf/codex/raw/refs/heads/main/Project%20Maturity).

## Installation

### Dependencies

Currently, GribJump has the following runtime dependencies:

- [eccodes](https://github.com/ecmwf/eccodes)
- [eckit](https://github.com/ecmwf/eckit)
- [metkit](https://github.com/ecmwf/metkit)
- [fdb5](https://github.com/ecmwf/fdb)
- [libaec](https://github.com/MathisRosenhauer/libaec)

as well as [ecbuild](https://github.com/ecmwf/ecbuild) for building.

### C++ Library

Building and installing:

```bash
   # Environment --- Edit as needed
   srcdir=$(pwd)
   builddir=build
   installdir=$HOME/local  
   
   # 1. Create the build directory:
   mkdir $builddir
   cd $builddir

   # 2. Run ecbuild
   ecbuild --prefix=${installdir} -- \
   -DENABLE_MEMFS=ON \
   -DENABLE_ECCODES_THREADS=ON \
   -DENABLE_AEC=ON \
   -DCMAKE_INSTALL_PREFIX=$</path/to/installations> ${srcdir}
   
   # 3. Compile / Install
   make -j10
   make install
```

A clientside build (which cannot extract data but talks to a server which can) is built using the flag `-DENABLE_GRIBJUMP_LOCAL_EXTRACT=OFF`. This requires only eckit and metkit to be installed.

### Python Library

The python interface, `pygribjump`, can be installed with pip:

```bash
python3 -m pip install --upgrade git+ssh://git@github.com/ecmwf/gribjump.git@master
```

`pygribjump` uses [findlibs](https://github.com/ecmwf/findlibs) to find an installed `libgribjump` library. You can use `export GRIBJUMP_HOME=/path/to/gribjump/install` to help with finding the library.

See the `docs/examples/` files for simple use cases.


## Acknowledgements

Past and current funding and support is listed in the [Acknowledgements](./ACKNOWLEDGEMENTS.rst).
fckitlib 0.14.1.11
"fckitlib"

FCKit
=====

[![fckit release version](https://img.shields.io/github/release/ecmwf/fckit.svg)](https://github.com/ecmwf/fckit/releases/latest)
[![travis master](https://img.shields.io/travis/ecmwf/fckit/master.svg?label=master&logo=travis)](http://travis-ci.org/ecmwf/fckit "master")
[![travis develop](https://img.shields.io/travis/ecmwf/fckit/develop.svg?label=develop&logo=travis)](http://travis-ci.org/ecmwf/fckit "develop")
[![codecov](https://codecov.io/gh/ecmwf/fckit/branch/develop/graph/badge.svg)](https://codecov.io/gh/ecmwf/fckit)

Fortran toolkit for interoperating Fortran with C/C++.

In addition useful algorithms from ecKit are wrapped with Fortran.

Project website and reference documentation on released versions:
https://confluence.ecmwf.int/display/FCKIT

## fctest

Unit Testing Framwork for Fortran, made easy.

- C Preprocessor Macros are used to make writing tests extremely fast
- Tests in one file are bundled in a Test Suite (Fortran Module)
- Python script generates a main program for a Test Suite
- Driven by CMake build system ( and ctest )

### To use in your ecbuild project

Simply add following line to your project's CMakeLists.txt

```
ecbuild_add_option( FEATURE FCTEST  DEFAULT ${ENABLE_TESTS}
                    DESCRIPTION "Fortran Unit Testing Framework"
                    REQUIRED_PACKAGES "NAME fckit" )
```

See src/examples folder how to add and create the unit-tests.

## fckit

Various Fortran modules helpful to create mixed-language applications

- MPI
- Logging

### Offline build of fckit Python virtual environment

An offline build/installation of the fckit Python virtual environment can be completed as follows:

1. Download all necessary Python dependencies of src/fckit/fckit_yaml_reader. `ruamel.yaml.clib`
is not a pure Python package, so we have to ensure a wheel compatible with the target platform is
downloaded. pip compatibility tags for any system can be displayed using `python3 -m pip debug --verbose`,
and buit-distributions (i.e. wheels) for ruamel.yaml.clib can be found [here](https://pypi.org/project/ruamel.yaml.clib/#files).
For a linux installation based on an x86 architecture using Python3.10, the following command can be used:

```
FCKIT_WHEEL_ARCH=manylinux_2_17_x86_64 FCKIT_WHEEL_PYTHON_VERSION=310 ./populate
```

This will download all the wheels to `<source-dir>/artifacts.` It should
be noted that if `FCKIT_WHEEL_ARCH` and `FCKIT_WHEEL_PYTHON_VERSION`
are not specified then the wheels are downloaded for the calling system's Python interpreter.

2. scp/rsync/copy the directory containing the dependencies to the offline system.

3. Add the path to the `artifacts` directory to the fckit CMake configuration step, i.e. `-DARTIFACTS_DIR=<path-to-artifacts-dir>`.

### License

Please read LICENSE.

---------------------------------------------------------------------

ECMWF