semvec/pypi-packages huggingface dataset:
cmdnote 0.1.1
Command line tool which stores your future commands
Requires Python: >=3.5

# cmdnote

`cmdnote` is a command line tool which stores your future commands. It can help you to save time in your next demo.

![demo](https://github.com/zianke/cmdnote/raw/master/demo.gif)

## Installation

```
pip3 install cmdnote
```

**Important**: Please add the following command to your `.bash_profile`, `.bashrc` or other startup script:

```
eval "$(cmdnote func)"
```

## Usage
```
usage: cmdnote [-h]
               {func,append,insert,list,next,prev,seek,clear,play,config} ...

cmdnote is a command line tool which stores your future commands.

optional arguments:
  -h, --help            show this help message and exit

sub-commands:
  {func,append,insert,list,next,prev,seek,clear,play,config}
                        cmdnote sub-commands
    func                print the cmdnote function for CLI initialization
    append              append commands to the end of note
    insert              insert commands to the beginning of note
    list                list future commands
    next                get the next command to run
    prev                get the previous command to run
    seek                set the note's current position
    clear               clear future commands
    play                run all future commands
    config              configure cmdnote
```
Kloudio 1.0.0
Kloudio APIs
Keywords: SDK,API,Kloudio APIs

# Kloudio Python Library

- API version: BETA
- Package version: 1.0.0

## Requirements.

Python 2.7 and 3.4+

## Installation & Usage
### pip install

```sh
pip install kloudio
```
(you may need to run `pip` with root permission: `sudo pip install kloudio`)

Then import the package:
```python
import kloudio
```

## Using Kloudio API

Documentation for the Python library can be found at https://github.com/Kloudio/sdk-python
deferred-result 0.1.1
Simple DeferredResult
Requires Python: >=3.7

DeferredResult
---

This library provides simple deferred result.

# Usage

Create deferred result:
```python
def_result = DeferredResult[str]()
``` 

Then you can wait for the result using optional timeout:
```python
result = def_result.wait(timeout=1)
```

While waiting for result other thread can set result:
```python
def_result.resolve('Hello World')
```

After resolving result all threads waiting for result will be resumed.

It is also possible to reject deferred result:
```python
def_result.reject(RuntimeError('Well....'))
```

In that case all threads waiting for result will be resumed and exception passed to `reject` will be thrown.
anna-lib 0.0.13
selenium interface

## anna-lib
The purpose of this package is to simplify the use of selenium.

### requirements
[selenium](https://pypi.org/project/selenium/)

### installation
```bash
$ pip install anna-lib
```

### usage
```python
from anna_lib.selenium import driver, events, assertions


result = []
firefox = driver.create(driver='firefox', headless=True)

firefox.get('http://example.com/')
events.click(driver=firefox, target='a[href="http://www.iana.org/domains/example"]')

result.append(assertions.current_url_is(firefox, 'http://www.iana.org/domains/example'))
```

#### driver
Use this module to create a webdriver based on a set of options:

| param  | type | required | values | default value |
|--------|------|----------|-------|----------------|
| driver | string | yes | 'firefox' or 'chrome' for now | 'firefox' |
| headless | bool | no | True or False | False |
| resolution | tuple | no | (width, height) | (1920, 1080) |

#### events
Use this module to interact with pages. Each event takes a driver, a target & a timeout which defaults to 16 seconds, with the exception being ```send_keys``` which also requires a value.
The target is treated as a css selector unless it starts with ```'$xpath'```, in which case it is of course treated as an xpath selector.
```python
from anna_lib.selenium import events, driver
firefox = driver.create('firefox', headless=True)

events.click(driver=firefox, target='#search')
events.send_keys(driver=firefox, target='#search', value='search terms')
events.submit(driver=firefox, target='#search')
events.hover(driver=firefox, target='$xpath//div.result/a')
events.scroll_to(driver=firefox, target='#thing')
events.switch_to(driver=firefox, target='iframe')
```

#### assertions
Use this module to check the state of a page, be it by the url or by the page's elements.
Each assertion takes a driver, some input & a timeout parameter which defaults to 16 seconds.
```python
from anna_lib.selenium import assertions, driver
firefox = driver.create('firefox', headless=True)

try:
	assertions.url_equals(driver=firefox, expected='about:blank')
	assertions.in_url(driver=firefox, part='blank')
	assertions.element_exists(driver=firefox, target='body')
except ValueError as e:
	print(str(e))
except TypeError as e:
	print(str(e))
```
iterprinter 0.1.2
An iteration history printer

# IterationPrinter: A simple iteration history printer
[![PyPI version](https://badge.fury.io/py/iterprinter.svg)](https://pypi.org/project/iterprinter/)

When using iterative numerical algorithms it is common
to print after each iteration a message so that a user
can monitor convergence and catch any bugs.
As an example, `demo.py` implements a simple bisection algorithm
for computing the square root of two. 
The following is the output using this library:

<p align="center"><img src="/demo.gif?raw=true"/></p>


# Usage 

```python
from iterprinter import IterationPrinter

# Initialize the printer by passing formatting information each column
printer = IterationPrinter(it = '4d', obj = '16.6e')

# Print a header for the table
printer.print_header(it = 'iter', obj = 'objective')

# Print a normal line of history
printer.print_iter(it = 0, obj = 5e3 )

# If a particular field is not provided, the column is left empty
printer.print_iter(it = 1)

```

For a more complete example, see `demo.py`.