semvec/pypi-packages huggingface dataset:
quick-plot 0.0.2
convenience wrapper around matplotlib
Requires Python: >=3.6

# quick plot

The scripting interface of matplotlib is stateful, therefore
dangerous. The object oriented interface to the plotting library is
polluted. This tiny library combines the two interfaces into one
context manager.

## fundament

If this file is somewhere in your =$PYTHONPATH=, the following code
should produce a plot.

´´´python
import numpy as np
import quick

with quick.Plot() as qp:
    qp.plot(np.sin(np.linspace(0, 2 * np.pi)))
´´´

The =Plot= class is the only available class in the =quick= module. It
should be instantiated exactly once. Its instance can do everything
the matplotlib axis object can do. For some methods, a default
configuration is supplied. There are some methods, that are not
contained in the axis object, for example =trajectory=, =field=, =points=,
=remove_border=, =remove_xticks=. When a method is called, that is neither
a method of the =axis= object, nor one of the additional methods of this
module, then the module =matplotlib.pyplot= is searched for a function
with that name, and, if it exists, it is called. When the context
manager is left, the plot shows up.

### arguments

=Plot= takes optional arguments.
| =filename= | given that, the plot is not shown interactively, but saved as a file, default =None= |
| =figsize=  | a tuple, representing (width, height), default =(3, 3)=                              |
| =grid=     | if =True= shows a grid, default =False                                               |
all other optional arguments are directly passed to =matplotlib.pyplot.subplot=.

## short form

If you just want to quickly see some of your data, and you do not want
to do any customization of the plotting result, the context manager is
a bit of a boilerplate. So there is the following shorthand for the
previous script.

´´´python
import numpy as np
import quick

quick.plot(np.sin(np.linspace(0, 2 * np.pi)))
´´´

The context manager is called implicitly.

## more convenience

The quick module additionally provides a few methods that are not
directly related to the =matplotlib= plotting facility, e.g.  
- =colored=: takes a list of array and return an iterator with tuple,
  with the data and a color, that can be past to the color argument of
  plotting methods. Optional argument is the name of a colormap
- =landscape=, =portrait=: they return tuples that can be past to the
  =figsize= argument of =Plot=, internally using the golden ratio.
- =tex=: surround a string by dollar signs.

## drawback

There is no interactive workflow anymore with this approach. I like
that way of working, because due to script restarts you eliminate all
errors in your script, that may occur from state changes from the
past, that confuses the (fragile) python module system.
pycommands 0.1.0
Handle a list of commands that should be executed easily and with undo support.
Requires Python: >=3.7

# pycommands
[![CircleCI](https://circleci.com/gh/rafaelcassau/pycommands.svg?style=shield)](https://circleci.com/gh/rafaelcassau/pycommands)
[![Codecov](https://codecov.io/gh/rafaelcassau/pycommands/branch/master/graph/badge.svg)](https://codecov.io/gh/rafaelcassau/pycommands)

Handle a list of commands that should be executed easily and with undo support.

# How to use

## Install
pycommands is available on PyPI

```bash
pip install pycommands
```

## Basic usage

#### Definition of commands
```python
from commands.base import BaseCommand
from commands.exceptions import CommandException
from commands.invoker import Invoker


class Command1(BaseCommand):
    def build(self):
        return "touch content.txt"

    def build_undo(self):
        return "rm content.txt"


class Command2(BaseCommand):
    def build(self):
        return "mv content.txt content-replaced.txt"

    def build_undo(self):
        return "mv content-replaced.txt content.txt"


class InvalidCommand(BaseCommand):
    def build(self):
        raise CommandException()
```

#### Simple default execution with success commands

```python
from commands.invoker import Invoker


invoker = Invoker()

invoker.execute([
    Command1(),
    Command2(),
], run_undo=False)

# output
running command: touch content.txt
running command: mv content.txt content-replaced.txt


# If a invoker.undo() is called then all commands undo operation will be done in the LIFO order.

invoker.undo()

# output
running undo command: mv content-replaced.txt content.txt
running undo command: rm content.txt


# If a invoker.execute() is called with run_undo as True, then the undo operation will be done always
# that a command raise CommandException

invoker = Invoker()

invoker.execute([
    Command1(),
    Command2(),
    InvalidCommand(),
], run_undo=True)

# output
running command: touch content.txt
running command: mv content.txt content-replaced.txt
running command: touch content.txt
running command: mv content.txt content-replaced.txt
running undo command: mv content-replaced.txt content.txt
running undo command: rm content.txt
```
## How to contribute

We welcome contributions of many forms, for example:
- Code (by submitting pull requests)
- Documentation improvements
- Bug reports and feature requests

## Setting up for local development

We use pipenv to manage dependencies, so make sure you have it installed.

Creating environment
```bash
/<project-path>/pipenv install --python=3
```

Activing environment
```bash
/<project-path>/pipenv shell
```

Install pre-commit hooks:
```bash
pre-commit install
```

Run tests by evoking pytest:
```
pytest
```

That's it! You're ready from development