semvec/pypi-packages huggingface dataset:
arxivpy 0.0.2
Finds (and downloads) all journals from arXiv by given search criteria.
License: MIT
Keywords: arXiv science beautifulsoup search

ArXiVPy
-----------------------

.. image:: https://github.com/monzita/arXivPy/blob/master/arxivpy.png

.. image :: https://img.shields.io/badge/0.0.1-arXivPy-green?style=flat-square

Find all papers from arXiv based on some query ( + option for downloading them ) 

.. image:: https://github.githubassets.com/images/icons/emoji/unicode/1f4f0.png


Installation
**********************

>>> pip install arxivpy

Documentation
**********************

Official documentation can be found `here <https://github.com/monzita/arxivpy/wiki>`_

Example usage
**********************

>>> from arxivpy.client import ArXivPyClient
>>>
>>> client = ArXivPyClient()
>>>
>>> quantum = client.simple(query='quantum computing', page=2, download=True,
>>>                         path='path', downloadonly=10)
>>>
>>>
>>> algorithms = client.advanced(term='algorithms',
>>>                              classification='computer_science', size=200)
>>>
>>>
>>>
>>> alg_ds = client.advanced(terms=[{term: 'algorithms', field: 'title'},
>>>                                 {term: 'data structures', field: 'title'}],
>>>                      classification='computer_science', size=200)
>>>

Licence
**********************

`MIT <https://github.com/monzita/arxivpy/LICENSE>`_
django-websocket-redis 0.6.0
Websocket support for Django using Redis as datastore
License: MIT
Keywords: django,websocket,redis

django-websocket-redis
======================

Project home: https://github.com/jrief/django-websocket-redis

Detailed documentation on [ReadTheDocs](http://django-websocket-redis.readthedocs.org/en/latest/).

Online demo: http://django-websocket-redis.awesto.com/

Websockets for Django using Redis as message queue
--------------------------------------------------
This module implements websockets on top of Django without requiring any additional framework. For
messaging it uses the [Redis](http://redis.io/) datastore and in a production environment, it is
intended to work under [uWSGI](http://projects.unbit.it/uwsgi/) and behind [NGiNX](http://nginx.com/)
or [Apache](http://httpd.apache.org/docs/2.4/mod/mod_proxy_wstunnel.html) version 2.4.5 or later.


Features
--------
* Largely scalable for Django applications with many hundreds of open websocket connections.
* Runs a separate Django main loop in a cooperative concurrency model using [gevent](http://www.gevent.org/),
  thus only one thread/process is required to control *all* open websockets simultaneously.
* Full control over this separate main loop during development, so **Django** can be started as usual with
  ``./manage.py runserver``.
* No dependency to any other asynchronous event driven framework, such as Tornado, Twisted or
  Socket.io/Node.js.
* Normal Django requests communicate with this separate main loop through **Redis** which, by the way is a good
  replacement for memcached.
* Optionally persisting messages, allowing server reboots and client reconnections.

If unsure, if this proposed architecture is the correct approach on how to integrate Websockets with Django, then
please read Roberto De Ioris (BDFL of uWSGI) article about
[Offloading Websockets and Server-Sent Events AKA “Combine them with Django safely”](http://uwsgi-docs.readthedocs.org/en/latest/articles/OffloadingWebsocketsAndSSE.html).

Please also consider, that whichever alternative technology you use, you always need a message queue,
so that the Django application can “talk” to the browser. This is because the only link between the browser and
the server is through the Websocket and thus, by definition a long living connection. For scalability reasons you
can't start a Django server thread for each of these connections.

Release History
---------------
Refer to [changelog.rst](docs/changelog.rst)

Build status
------------
[![Build Status](https://travis-ci.org/jrief/django-websocket-redis.png?branch=master)](https://travis-ci.org/jrief/django-websocket-redis)
[![Downloads](http://img.shields.io/pypi/dm/django-websocket-redis.svg?style=flat-square)](https://pypi.python.org/pypi/django-websocket-redis/)

Questions
---------
Please use the issue tracker to ask questions.

License
-------
Copyright &copy; 2015 Jacob Rief.

MIT licensed.
newstldr 0.2.0
NewsTLDR
License: MIT

# NewsTLDR

A Flasik extension to fetch and summarize the news. 

It provides an API `https://url/newstldr/`


You will also need **newstldr-admin**


### Requirements

- AWS Account for S3
- Google API Account for youtube

## Install

Add in Flasik application requirements.txt `newstldr`

## Config

```
    # NTLDR/Newsroom
    NTLDR_AWS_ACCESS_KEY_ID = AWS_ACCESS_KEY_ID
    NTLDR_AWS_SECRET_ACCESS_KEY = AWS_SECRET_ACCESS_KEY
    NTLDR_AWS_REGION_NAME = AWS_REGION_NAME
    NTLDR_IMAGES_STORAGE_PREFIX = "ntldr.imgs"
    NTLDR_SQS_MQ_NAME = "Newsroom"
    NTLDR_GOOGLE_API_KEY = GOOGLE_API_KEY
```

## __flasik__.py 

```
import newstldr.cli

projects = {
  "main": [
    "newstldr"
  ]
}
```

## Setup

`flasik news:setup`

## Run workers

To automatically import and process articles

### Import Posts
`flasik news:worker:import-posts`

### Run Task Q

`flasik news:worker:run-taskq`
PySGP30 0.1.8
Library for reading data from the Sensirion SGP30
License: MIT
Keywords: sgp30 i2c smbus smbus2

SGP30
=========

Library to read eCO2 and TVOC from the [SGP30 sensor](https://www.sensirion.com/fileadmin/user_upload/customers/sensirion/Dokumente/9_Gas_Sensors/Sensirion_Gas_Sensors_SGP30_Datasheet_EN.pdf). Based on the _smbus2_ i2c library for ease of use.

It should be compatible with both Python 2 and 3

Quick usage-example:
--------------------

    from smbus2 import SMBusWrapper
    from sgp30 import SGP30
    import time
    
    with SMBusWrapper(1) as bus:
        sgp = SGP30(bus, baseline_filename=BASELINE_FILENAME+".TESTING")
        print("resetting all i2c devices")
        sgp.i2c_general_call()
        print(sgp.read_features())
        print(sgp.read_serial())
        sgp.init_sgp()
        for i in range(300):
			print(sgp.read_measurements())
			time.sleep(0.1)
		sgp.store_baseline()
        bus.close()

Current design considerations:
------------------------------
The class strives to to be light-weight and portable. It is currently a bit to tightly bound to the smbus2 class. In most cases I try to ease of readability rather than purity or speed.

Features that are known to be missing (listing in rough order of importance):
-----------------------------------------------------------------------------
* The handing of baseline values is not that great, it should probably be up to the end user to save and restore them as needed.
* Write doc-strings for all or at least most methods.
* reading raw-values.
* A more "driver like" class that takes care of all chip identification, polling at regular intervals, restoring baseline and so on.
* Run real hardware tests under Python3

Hardware notices:
-----------------
If you have the Adafruit board with built in level shifters and voltage regulator it is should work if you just plug in [SDA to pin 3, SCL to pin 5, VCC to pin 17 and GND to pin 20](https://pinout.xyz/pinout/i2c). You should then be able to find the SGP30 an address 0x58 using `i2cdetect -y 1`. If you get an error message  you probably need to enable i2c in the kernel using  [raspi-config and reboot](https://learn.sparkfun.com/tutorials/raspberry-pi-spi-and-i2c-tutorial>)


Feel free to contact me with bugs, questions or issues.