semvec/pypi-packages huggingface dataset:
daaf-plot 1.0.1
Personal python toolbox to make interactive plot in python notebooks
Requires Python: >=3.11
Keywords: interactive plots, notebooks, visualization

# daaf-plot

[![PyPI version](https://badge.fury.io/py/daaf-plot.svg)](https://badge.fury.io/py/daaf-plot)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

`daaf-plot` is a python toolbox to make interactive plot in python notebooks.

## Installation

Install using `pip`:

    $ pip install daaf-plot

## Usage

The primary goal of the present toolbox is to help the creation of interactive plots.
Nevertheless, it also provides a function to open a `matplotlib` figure from a given list
of settings (number of rows and columns, padding, etc.) as well as some stylistic options
which can be used outside python notebooks.

### Interactive plots

To make an interactive plot, you need:
1. to enable the `%matplotlib widget` magic in a notebook;
2. an `xarray.DataArray` containing the data to plot.

Import `InteractiveLinePlot` or `InteractivePColorMesh` from `daaf_plot.figure`, instantiate with:

    >>> fig = InteractiveLinePlot(
    ...     data_array,
    ...     x_dim='the_x_dim',
    ...     line_dim='the_line_dim',
    ...     facet_dim=...,
    ...     open_figure_kwargs=dict(...),
    ... )

for a line plot and with:

    >>> fig = InteractivePColorMesh(
    ...     data_array,
    ...     x_dim='the_x_dim',
    ...     y_dim='the_y_dim',
    ...     facet_dim=...
    ...     open_figure_kwargs=dict(...),
    ... )

for a pcolormesh. This creates an abstract figure object, which you can then open using:

    >>> fig.interactive_show()

Have at look at the examples in the `examples/` repository!

### Open a matplotlib figure

The `daaf_plot.geometry.open_figure()` function can be used to open a `matplotlib` figure,
even outside python notebooks.

### Stylistic options

Some `matplotlib` stylistic options are provided when importing `daaf_plot.style`:
- scale `linlogp`;
- color map `deep` (from `seaborn`) and its reversed counterpart;
- a unified function `daaf_plot.style.set_font_size()` to set font size in figures;
- ...

In addition, my custom style sheet is stored in `src/daaf_plot/style/laptop.mplstyle`
and can be used as follows:

    >>> import matplotlib.pyplot as plt
    >>> plt.style.use('daaf_plot.style.laptop')

## Todo-list

- write docstrings
- write documentation
- add type hints
plumpy 0.25.1
A Python workflow library.
Requires Python: >=3.9
Keywords: workflow, multithreaded, rabbitmq

## plumpy

<img src="https://github.com/aiidateam/plumpy/blob/master/docs/source/_static/logo.svg" width="64px" height="auto">

[![Build status][github-ci]][github-link]
[![Docs status][rtd-badge]][rtd-link]
[![Latest Version][pypi-badge]][pypi-link]
[![PyVersions][pyversions-badge]][pyversions-link]
[![License][license-badge]][license-link]

A python workflows library that supports writing Processes with a well defined set of inputs and outputs that can be
strung together.

RabbitMQ is used to queue up, control and monitor running processes via the
[kiwipy](https://pypi.org/project/kiwipy/) library.

Features:

* Processes can be remotely controlled by sending messages over RabbitMQ all from a simple interface
* Progress can be saved between steps and continued later
* Optional explicit specification of inputs and outputs including their types, validation functions, help strings, etc.

## Installation

```bash
pip install plumpy
```

or

```bash
conda install -c conda-forge plumpy
```

## Development

This package utilises [tox](https://tox.readthedocs.io) for unit test automation, and [pre-commit](https://pre-commit.com/) for code style formatting and test automation.

To install these development dependencies:

```bash
pip install tox pre-commit
```

To run the unit tests:

```bash
tox
```

For the `rmq` tests you will require a running instance of RabbitMQ.
One way to achieve this is using Docker and launching [`test/rmq/docker-compose.yml`](test/rmq/docker-compose.yml).

To run the pre-commit tests:

```bash
pre-commit run --all
```

To build the documentation:

```bash
tox -e docs-clean
```

Changes should be submitted as Pull Requests (PRs) to the `develop` branch.

## Publishing Releases

1. Create a release PR/commit to the `develop` branch, updating `plumpy/version.py` and `CHANGELOG.md`.
2. Fast-forward merge `develop` into the `master` branch
3. Create a release on GitHub (<https://github.com/aiidateam/plumpy/releases/new>), pointing to the release commit on `master`, named `v.X.Y.Z` (identical to version in `plumpy/version.py`)
4. This will trigger the `continuous-deployment` GitHub workflow which, if all tests pass, will publish the package to PyPi. Check this has successfully completed in the GitHub Actions tab (<https://github.com/aiidateam/plumpy/actions>).

(if the release fails, delete the release and tag)

[github-ci]: https://github.com/aiidateam/plumpy/workflows/continuous-integration/badge.svg?branch=develop&event=push
[github-link]: https://github.com/aiidateam/plumpy/actions
[rtd-badge]: https://readthedocs.org/projects/plumpy/badge
[rtd-link]: http://plumpy.readthedocs.io/
[pypi-badge]: https://img.shields.io/pypi/v/plumpy.svg
[pypi-link]: https://pypi.python.org/pypi/plumpy/
[pyversions-badge]: https://img.shields.io/pypi/pyversions/plumpy.svg
[pyversions-link]: https://pypi.python.org/pypi/plumpy/
[license-badge]: https://img.shields.io/pypi/l/plumpy.svg
[license-link]: https://pypi.python.org/pypi/plumpy/
ast-transforms 0.2.0
A collection of AST-based transformations
Requires Python: >=3.9

# AST Transforms

A collection of AST-based Python transformations for manipulating code programmatically.

## Installation

```bash
pip install ast_transforms
```

## Usage

```python
import ast
import ast_transforms as at

code = '''
@mydecorator
def foo():
    print("foo")
'''

# Parse code into an AST
tree = ast.parse(code)

# Apply transformations
tree = at.remove_func_decorator(tree)  # removes all function decorators

# Convert AST back to source code
new_code = ast.unparse(tree)
print(new_code)
```

**Output:**

```python
def foo():
    print("foo")
```

---

## Passes

* `remove_func_decorator(tree)` – removes all decorators from functions.
* More passes are to be added ...