semvec/pypi-packages huggingface dataset:
ixc-whitenoise 0.6.1
Improvements to WhiteNoise.
License: MIT

What is this?
=============

Improvements to `WhiteNoise <https://github.com/evansd/whitenoise/>`__:

-  Serve media as well as static files.
-  Save media with hashed filenames, so they can be cached forever by a
   CDN.
-  Do not crash the ``collectstatic`` management command when a
   referenced file is not found or has an unknown scheme.
-  Add
   `django-pipeline <https://github.com/jazzband/django-pipeline/>`__
   integration.
-  Add support for Django 1.6 via monkey patching.
-  Strip the ``Vary`` header for static file responses via middleware,
   to work around an IE bug. This should come *before*
   ``SessionMiddleware`` in ``MIDDLEWARE_CLASSES``. See:
   http://stackoverflow.com/a/23410136
watchedserial 1.0.1
Module for handling pySerial Serial objects connecting and disconnecting
License: MIT

=============
watchedserial
=============

|build-status| |pypi|

Installation
============

.. code-block:: bash

        $ pip install watchedserial


Description
===========
``WatchedReaderThread`` is a subclass of pySerial's
``serial.threaded.ReaderThread``. Similar to ``ReaderThread``,
``WatchedReaderThread`` implements a serial port read loop in it's own thread but
instead of killing the thread on a serial disconnection, it calls a callback and
waits for the port to become available again before attempting a reconnect. On
reconnect it calls a reconnect callback. This should make writing apps that need to
deal with unreliable serial connections more seamless and make it easier to write
apps that should allow the user to disconnect and reconnect a serial device safely.

Usage
=====
Subclass ``watchedserial.WatchedReaderThread`` to implement the
``handle_reconnect()`` and ``handle_disconnect()`` callbacks. Both of these
functions should be non-blocking (similar to an ISR).

.. code-block:: python

	import time

	import serial
	from watchedserial import WatchedReaderThread


	PORT = "COM3"

	class MyPacket(serial.threaded.FramedPacket):
	    def handle_packet(self, packet):
		print(packet)


	class MyWatchedReaderThread(WatchedReaderThread):
	    def handle_reconnect(self):
		print("Reconnected")

	    def handle_disconnect(self, error):
		print("Disconnected")


	ser = serial.Serial(PORT, baudrate=115200)
	with MyWatchedReaderThread(ser, MyPacket) as protocol:
	    while True:
		time.sleep(1)



.. |build-status| image:: https://travis-ci.org/eoswald/watchedserial.svg?branch=master

.. |pypi| image:: https://img.shields.io/pypi/v/watchedserial.svg?style=flat-square&label=latest%20stable%20version
    :target: https://pypi.python.org/pypi/watchedserial
    :alt: Latest version released on PyPi
openedoo 1.1.0.19
openedoo is backend service for education base on flask
License: MIT

# WELCOME TO OPENEDOO

## openedoo-beta in pip
```
pip install openedoo

and run in your terminal

openedoo install

```
## how to use

```bash
git clone https://github.com/openedoo/openedoo

pip install -r requirements.txt
```

### Migrate Database
```bash
python manage.py db init
python manage.py db migrate
python manage.py db upgrade
python manage.py --help
```

### Create New Module
```bash
python manage.py module create -n "module_name"
```
```bash
python manage.py module create -n "module_name" --remote "github_repo_url"
```

### Runserver
```bash
python manage.py run
```

## Docker Compose

### Setup
```bash
$ docker-compose up -d
$ curl
```

### Stop Services
```bash
$ docker-compose stop
```

### Run And Play
```bash
$ docker-compose start
```

### Create Module
```bash
$ docker-compose exec od python manage.py create "test"
```

### Manage Module
```bash
$ docker-compose stop od
$ docker-compose run od bash
[from_od]$ openedoo module create -n "test"
[from_od]$ opendoo module remove test
[from_od]$ opendoo module install https://github.com/openedoo/module_hello
```
kafka-logger 0.3.0
A simple Kafka logger in Python.
License: MIT
Keywords: python,kafka,logstash,logging

## Kafka Logger for Python

### Why this exists?

There's an existing python package that can send log to logstash through Kafka,
but it has two problems:

1. It's built on top of a specific python kafka package and it's outdated,
which left user no choice on which Kafka they can use.
2. It only uses default log formatting from python logging package,
which doesn't provide much useful information.

### Install

    pip install kafka-logger

### Usage

    import logging
    import KafkaLoggingHandler
    logger = logging.getLogger('python-logstash-logger')
    logger.setLevel(logging.INFO)
    log_producer = KafkaProducer(bootstrap_servers=KAFKA_BROKER)
    logger.addHandler(KafkaLoggingHandler(log_producer, 'app-log'))