semvec/pypi-packages huggingface dataset:
spplot 0.0.2
command-line serial plotter
License: MIT
Requires Python: >=3.6

# spplot

This utility is a text mode implementation of what can be done in Arduino IDE
when choosing `Serial Plotter` option, i.e. it plots the numbers received on
the serial port in real time.

![](https://i.imgur.com/37MfwQr.png)

## spemu

There's also a helper utility included, called `spemu` which is a serial port
emulator. It's useful for testing when no real device is nearby.

#### Usage

Run `spemu`. The program will print file descriptor and PTY device path.
You can write directly to the `spemu` stdin or open file descriptor with some
script and write to it. The things you write will be outputted by the virtual
COM port.

## Installation

#### spplot

Install from PyPI:
```bash
python3 -m pip install spplot
```

Install locally:
```bash
python3 -m pip install . --upgrade
```

#### spemu

To compile it, just run `make`.

## Requirements

#### spplot

* Python 3 with f-strings
* POSIX-compliant, color-supporting terminal
* Font with Braille characters
* Modules from `requirements.txt`

#### spemu

* C compiler
* UNIX-like system

## Disclaimer: Work in Progress

This is a dirty draft of what I want it to be. I'll try to optimize it in my
free time and add some colors to differentiate the plots. As for now, it is
what it is.

The initial menu is made in TUI style but if you provide port and baudrate as
CLI args, you won't see it.

## Roadmap

- [ ] colored lines for different subplots
- [ ] total average / current buffer average and other stats
- [ ] better error handling
- [ ] buffer, display and calculation optimizations
- [ ] proper handling of negative values
- [x] set y axis range option
- [x] plot on n-th readout option
- [x] command line args
- [x] dynamic resizing
- [x] human menu keymapping
- [x] make a python package
- [x] make a PyPI release
tx-functional 0.1.2
A pickleable generic functional programming library
License: MIT
Requires Python: >=3.6

[![Build Status](https://travis-ci.com/RENCI/tx-functional.svg?branch=master)](https://travis-ci.com/RENCI/tx-functional)

# tx-functional
Generic functional programming library for Python

The goal of this is
 * Close to Haskell.
 * Work with mypy
 * Pickleable

We choose functions in uncurried form because mypy doesn't support type variable that only appear in return type of a function signature.

## classes

### Functor

The `Functor` class is defined in `tx.functional.functor`.
It takes in a `_map` argument. A functor `F` is a higer-kinded type `* -> *`. 
A functor is defined by a `map` function
```
map: (S -> T, F[S]) -> F[T]
```

### Applicative

The `Applicative` class is defined in `tx.functional.applicative`.
It takes in `_map`, `_pure`, and `_ap`. An applicative `F` is a functor.
An applicative is defined by additional `pure` and `ap` functions
```
pure: S -> F[S]
ap: (F[S -> T], F[S]) -> F[T]
```

### Monad

The `Monad` class is defined in `tx.functional.monad`.
It takes in `_pure` and `_bind`. A monad `F` is an applicative and a functor.
A monad is defined by an additional `bind` function
```
bind: (F[S], S -> F[T]) -> F[T]
```

### Traversable

The `Traversable` class is defined in `tx.functional.traversable`.
It takes in `_sequenceA`. A traversable `F` is a functor. 
A traversable is defined by an additional `sequenceA` function
```
sequenceA: F[G[S]] -> G[F[S]]
```
where `G` is an applicative

## instances

### Maybe
`Maybe` is defined in `tx.functional.maybe`. It has two constructors, `Just` and `_Nothing`. An object `Nothing` is defined.

We should always use `== Nothing` to test equality and not `is Nothing`.

The `Functor` instance `maybe_functor`, `Applicative` instance `maybe_applicative`, and `Monad` instance `maybe_monad` are defined. 

```
Just(1)
Nothing
maybe_applicative.pure(1)
a.bind(lambda x: Nothing)
a.map(lambda x: 1)
```

### Either 
`Either` is defined in `tx.functional.either`.  It has two constructors, `Left` and `Right`. 

The `Functor` instance `either_functor`, `Applicative` instance `either_applicative`, and `Monad` instances `either_monad` are defined.

```
Left(1)
Right(1)
either_applicative.pure(1)
a.bind(lambda x: Left(1))
a.map(lambda x: 1)
```

### List
The python builtin types are used. The `Functor` instance `list_functor` and `Traversable` instance `list_traversable` are defined in `tx.functional.list`.

The `list_traversable` instance is a function that takes in an applicative.

```
list_traversable(maybe_applicative).sequenceA([Just(1)])
```
score-scraper 0.1.0
Package to scrape pre-game informations and scores from various websites
License: MIT
Requires Python: >=3.6

# score-scraper
Scrape game informations and scores from:
* flashscore
* kicker

Support planned for:
* sofascore

**Caution: No safety checks implemented.**

## How to install
```
pip install score-scraper
```

## License
MIT