semvec/pypi-packages huggingface dataset:
img-term 1.0.2
A small script to render images to an ANSI terminal
Keywords: terminal ansi fun

Image 2 ANSI
=
Converts an image to a representation in ANSI

Installation
-
1. 
```bash
pip install img_term
```

Usage
-

```
usage: img_term [-h] [-img IMG] [-width WIDTH] [-cam CAM] [-col {4,8,24}]

Display image to terminal

optional arguments:
  -h, --help     show this help message and exit
  -img IMG       Image file to display
  -width WIDTH   Character width of output
  -cam CAM       Show camera, this is the default
  -col {4,8,24}  Colour scheme to use
```

Display an image in terminal 
```bash
img_term -img dog.jpg 
```

Render your video capture device to terminal:
```bash
img_term
```

Select a colour palette:

```bash
./img_term.py -img lena.jpg -col 24
```

Example
-
Go from this:

![Dog](/dog.jpg)

To this:

![Screenshot](/screenshot.png)


Or this

![Lenna](/lena.jpg)

To this:

![LenaPixel](/screenshot2.png)

Or even render a video:

```bash
./img_term.py -col 24 -vid unrealset.mkv -width 78
```

https://gfycat.com/IdolizedSomeGemsbuck

Or simply stream your USB camera to terminal!:

https://gfycat.com/RemarkablePalatableKob
odc-pycommons 0.3.2
OculusD Python Commons Library
Keywords: cli library iot oculusd

# OculusD Client Libraries - Common Libraries

These libraries are supporting libraries for other OculusD.com Inc projects.

More details and documentation will follow in the near future. 

This is an initial development effort in very early stages (Alpha) and no 
guarantees are made in terms of production readiness at this stage.

## Installation

### Quick Install

Using pip:

```bash
$ pip install odc-pycommons
```

### Installation from Source

As with most other GitHub projects, the basic steps of clone, build and install 
should be followed. Below is a very simple example:

```bash
$ git clone https://github.com/oculusd/odc_pycommons.git
$ cd odc_pycommons
$ python3 setup.py sdist
$ pip3 install dist/odc_pycommons-0.0.1.tar.gz
```

## Debugging

You can enable debugging be setting the environment variable `DEBUG` to anything 
else than `'0'`. On Linux, you can accomplish this by running the following at 
the command prompt: `$ export DEBUG=1`.

Below is a simple example of the output that will now be printed to `STDOUT`:

```python
>>> from odc_pycommons.models import CommsRequest, CommsRestFulRequest, CommsResponse
* debug enabled
>>> from odc_pycommons.comms import get
>>> req = CommsRequest(uri='https://www.york.ac.uk/teaching/cws/wws/webpage1.html')
>>> resp = get(request=req)
* debugging GET request
send: b'GET /teaching/cws/wws/webpage1.html HTTP/1.1\r\nAccept-Encoding: identity\r\nHost: www.york.ac.uk\r\nUser-Agent: Python-urllib/3.7\r\nConnection: close\r\n\r\n'
reply: 'HTTP/1.1 200 OK\r\n'
header: Date header: Server header: Accept-Ranges header: Cache-Control header: Expires header: Vary header: X-Frame-Options header: Content-Length header: Connection header: Content-Type 
>>> resp.response_code
200
```

## Third Party Dependencies

The following third party libraries are used in this project:

* [email-validator](https://github.com/JoshData/python-email-validator)
* [pyyaml](https://github.com/yaml/pyyaml/)

Please refer to the various third party suppliers home pages for specific 
licensing information.

Installation:

```bash
$ pip3 install email-validator pyyaml
```

## Need more help?

Try one of these resources:

* [The project Wiki](https://github.com/oculusd/odc_pycommons/wiki)
* And don't forget to [check/log issues](https://github.com/oculusd/odc_pycommons/issues)
* Also consider the [primary documentation](https://docs.oculusd.com/index.html)
* Finally, you can also reach us on [Discord](https://discord.gg/7utRC3X) or [Twitter](https://twitter.com/oculusdinc)
django-mysqlping 0.1.1
Ping to MySQL in Django middleware.

================
django-mysqlping
================

|build-status| |pypi| |docs|

Ping to MySQL in Django middleware.

This middleware ping to MySQL server before the request and auto reconnect to the server.

It supports PyMySQL(using MySQLdb mode) and mysqlclient in the database backend of Django(django.db.backends.mysql).

Usage
=====

1. Add to settings.INSTALLED_APPS

::

   INSTALLED_APPS = [
       ...
       'mysqlping',
   ]

2. Add to settings.MIDDLEWARE (For example, you want to ping before every processes, therefore insert the middleware to first.)

::

   MIDDLEWARE = [
       'mysqlping.middleware.MySQLPingMiddleware',
       ...
   ]

License
=======

This software is licensed under the MIT License.

Author
======

* Shinya Okano

.. |build-status| image:: https://travis-ci.org/tokibito/django-mysqlping.svg?branch=master
   :target: https://travis-ci.org/tokibito/django-mysqlping
.. |docs| image:: https://readthedocs.org/projects/django-mysqlping/badge/?version=latest
   :target: https://readthedocs.org/projects/django-mysqlping/
.. |pypi| image:: https://badge.fury.io/py/django-mysqlping.svg
   :target: http://badge.fury.io/py/django-mysqlping
pecyn 0.2.1
Simple, fast, and compact object serialization for humans.
Requires Python: >=3.5

## Pecyn

Simple, fast, compact Python object serialization for humans.

__EXPERIMENTAL__: Use at your own risk.

Requires Python 3.5 or better.

Legal
-----

Copyright 2018 by individual and corporate contributors as
noted in the individual source files.

Licensed under the Apache License, Version 2.0 (the "License"); you may
not use any portion of this software except in compliance with
the License. Contributors agree to license their work under the same
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.
koffie 0.1.0
Lightweight and minimalist framework for python web app

# koffie
Lightweight and minimalist framework for python web app

<p align="center">
<img src="koffie-logo.png" alt="koffie Logo" height="200"/>
</p>

## Installation
Install using ```pip```:
```sh
$ pip install koffie
```

## TIPS
```sh
cd development
pipenv install
CFLAGS="-I /usr/local/include -L /usr/local/lib" pipenv run python setup.py build_ext --inplace

```
aec 0.1.3
ActiveMQ Easy Config

# ActiveMQ Easy Config

This project aims a easy way to setup a network of ActiveMQ brokers. You can change easily the topology and this 
script will create the configurations based on your setup. ActiveMQ Easy Config will produce for you:

- An `activemq.xml` file for each broker with the specific configuration for the broker
- A Docker image for each broker to easy adapt in your container orchestrator.
- A script for run the docker image locally in order to test your network locally.


# How it works?

Let's take an example of a duplex connection between two ActiveMQ brokers: 

```

   +----------+                    +----------+
   |          |       Duplex       |          |  
   | Broker 1 | ---<-->----<-->--- | Broker 2 |
   |          |                    |          | 
   +----------+                    +----------+

```

First you have to define the `yaml` file with the configuration of your network:

```yaml
brokers:
  node1: "static:(tcp://node1:61616)"
  node2: "static:(tcp://node2:61616)"

networks:
  common_configuration:
    set_broker_name: "false"
    queue:
      conduit_subscriptions: "false"
      consumer_ttl: "1"
      duplex: "true"
      message_ttl: "-1"
      physical_name: ">"
      user_name: "admin"
    topic:
      conduit_subscriptions: "true"
      consumer_ttl: "1"
      duplex: "true"
      message_ttl: "-1"
      physical_name: ">"
      user_name: "admin"

  network_connector:
    node1:
      to:
        - node2
      config:
        queue:
          duplex: "false"
        topic:
          _ignore: "true"
    node2:
      to:
        - node1
``` 

The first topic in the yaml will define the broker and your respective connection. 
If you intend to use docker, the address can be the broker name. 

You can see a lot of examples of network of brokers in the directory `templates`. In the same directory
you have an `activemq.xml` file used as base also.

After create your template you can just run:

```bash
python aec.py \
    --config templates/simple-duplex-config.yaml \
    --activemq templates/activemq.xml \
    --save-to /my/path/project
```

And you'll get the follow files as result:

- node1.xml
- node2.xml

Optionally if you pass a path to a `Dockerfile` and a registry name, the system will create:

- run.sh
- build.sh
- Dockerfile

You can run `build.sh` to build the docker images and `run.sh` to run the containers in your local machine. 

The docker image created can easily adapted to run on Kubernetes, Docker Swarm or ECS.

In the folder `check` you can run a simple producer/consumer to check the communication.

# Installing


## Recommended:

```bash
pip install aec
```

## get from source

Just clone the repository.

```bash
git clone git@github.com:byjg/activemq-easy-config
```  

# To Do

Help here is appreciate :)

- This configuration can be expanded to other features on ActiveMQ.
- K8s implementation
- Docker swarm implementation
- ECS implementation