semvec/pypi-packages huggingface dataset:
parallel-adb 0.0.1
Enable adb command parallel run in all connected devices.
Requires Python: >=3.6
Keywords: adb command parallel

ParallelADB
=============
Enable adb command parallel run in all connected devices.


Install
-------
``` sh
$ pip install parallel-adb
```

Example
-------
``` python
from paralleladb import ParallelADB

outputs = ParallelADB.run('pm list packages')

for o in outputs:
    print(o)

# Output: ADBOutputs(serial='emulator-x', results=['...'])

outputs = ParallelADB.run('forward tcp:4274 tcp:4724', is_shell_cmd=False, print_result=True)

for o in outputs:
    print(o)

outputs = ParallelADB.run('cd /sdcard && ls', serials=['emulator-5554'])

for o in outputs:
    print(o)
```
django-prepost 2.0.0
This package provides a framework for surveys and questionnaires
Keywords: test,pre-post,questionnaire,survey

[![Build Status](https://travis-ci.org/CSDTs/Django-pre-post.svg?branch=master)](https://travis-ci.org/CSDTs/Django-pre-post)[![Updates](https://pyup.io/repos/github/CSDTs/Django-pre-post/shield.svg)](https://pyup.io/repos/github/CSDTs/Django-pre-post/)


# Django-pre-post
This Django app provides the ability to create pre-post questions and answers. It was developed by the CSDTs team at RPI to embed pre-post tests for students in their website and to ease data collection.

# Installation & Integration

## Download and install:
Either use pip in terminal: `pip install django_pre_post`
Or add django_pre_post to your requirements / libraries file and run `pip install -r requirements.txt`

## Add the application to your site:
Include it in settings.py
```
INSTALLED_APPS = (
... your apps here ...
'django_pre_post',
)
```
Include it in URLS.py
```
urlpatterns = [
... your pages here...
url(r'^questionnaire/', include('django_pre_post.urls')),
]
```
# Testing

## Prerequisites
* * VirtualBox
* Linux: sudo apt-get install virtualbox
* Windows & Mac: https://www.virtualbox.org/wiki/Downloads
* * Vagrant
* Linux: sudo apt-get install vagrant
* Windows & Mac: https://www.vagrantup.com/downloads.html
* * Git
* Linux: sudo apt-get install git
* Windows & Mac: https://git-scm.com/downloads
* * * For windows Make sure C:\Program Files\Git\usr\bin [is in your path variable](http://www.computerhope.com/issues/ch000549.htm)

## Setup
```shell
git clone https://github.com/CSnap/Django-pre-post #get the code
cd Django-pre-post
vagrant up #build the system in a virtual machine
vagrant ssh #enter the virtual machine
cd /vagrant
python manage.py runserver 0.0.0.0:8000  #run the server
```
Navigate to localhost:8002/admin/
django-2gis-maps 1.0.3
Plugs 2gis maps for Django admin

### <In English>
# Django 2GIS maps

`django_2gis_maps` is a simple application that provides the basic
hooks into django_2gis_maps V2 api for use in Django models from Django
version 1.11+.  

Starting with `django_2gis_maps` version (0.7.0), Django 1.11+ is
required because Django changed their widget template rendering system. 

I'm using this to allow someone from the admin panels to type a
freeform address, have the address geocoded on change and plotted
on the map. If the location is not 100% correct, the user can
drag the marker to the correct spot and the geo coordinates will
update.
###
-----
![alt tag](http://info.2gis.com/img/2gis_logo.png)
-----
INSTALLATION
-----
- `pip install git+https://github.com/NursErgesh/django_2gis_maps.git`
- `pip install django_2gis_maps`
------
USAGE:
------
- include the `django_2gis_maps` app in your `settings.py`
- create a model that has both an address field and geolocation field

  ```python
  from django.db import models
  from django_2gis_maps import fields as map_fields
  from django_2gis_maps.mixins import DoubleGisMixin
  class Rental(DoubleGisMixin,models.Model):
      address = map_fields.AddressField(max_length=200)
      geolocation = map_fields.GeoLocationField()
  ```

- in the `admin.py` include the following as a formfield_override

  ```python
  from django.contrib import admin
  from django_2gis_maps.admin import DoubleGisAdmin

  class RentalAdmin(DoubleGisAdmin):
      multiple_markers = False        # Here is your option
  ```
- in template include `{% load doublegis  %}` and use `{% render_map instanse %}` wherever you need
---
That should be all you need to get started.

I also like to make the geolocation field readonly in the admin so a user
(myself) doesn't accidentally change it to a nonsensical value. There is
validation on the field so you can't enter an incorrect value, but you could
enter something that is not even close to the address you intended.

When you're displaying the address back to the user, just request the map
using the geocoordinates that were saved in your model. Maybe sometime when
I get around to it I'll see if I can create a method that will build that
into the model.
yalice 0.1
Python library for writing applications on yandex voice assistant
Requires Python: >=3.6

# yalice
Python library for writing applications on yandex voice assistant


# Getting started
```
pip install yalice
```


This library is a wrapper for Yandex Alice, not independent library for writing web based applications, so initialization takes in an object of the type Flask
```python
from flask import Flask
from yalice import AliceBot, Message, Chat

app = Flask(__name__)
bot = AliceBot(app)
```

Your bot is going to be located on page '/post'
If you would like to change this, you can change this by adding str parameter page
```python
bot = AliceBot(app, page='/alice')
```

Also Yandex Alice can store user state and session state, pyalice give you abbility to save all that data automatically, but you can remove this abbility by adding bool parameter remember_state (to read more about states [click here](https://yandex.ru/dev/dialogs/alice/doc/session-persistence-docpage/))
```python
bot = AliceBot(app, page='/alice', remember_state=False)
```


# message handler
To hangle messages you can use decorator ```message_handler```
```python
@bot.message_handler(start_handler=True)
def start(chat: Chat, message: Message):
    chat.send_message('Hello, I am annoying Alice. I will repeat each your word!')


@bot.message_handler(tokens=['stop'], filter_func=lambda message: message.request.type == 'ButtonPressed')
def stop(chat: Chat, message: Message):
    chat.send_message('It was a fun game!')
    chat.end_session()


@bot.message_handler(unknown_handler=True)
def echo(chat: Chat, message: Message):
    chat.send_message(message.request.original_utterance)
    chat.send_button('Stop!')
```


# images
You can initialise images at the start to access easily
There is 3 ways to initialise images
```python
# 1 image at a time
bot.set_image('fox', '123456/123456')
bot.set_image('cat', '654321/654321')

# several images at a time
images = {
    'fox': '123456/123456',
    'cat': '654321/654321'
}
bot.set_images(images)

# several images at a time by using bot.images variable
bot.images = {
    'fox': '123456/123456',
    'cat': '654321/654321'
}
```

To send BigImage you can just use
```python
chat.send_image('fox')
```

But if you would like to send ItemsList
```python
chat.send_images('fox')
chat.send_images('cat')
chat.edit_images(header_text='Animals')
```


# AliceBot object
AliceBot object stores information about images, sessions states and message_handlers. Now it has methods
- ```set_image()```
- ```set_images()```
- ```message_handler()```


# Chat object
Chat object stores request to return. Now is has methods
- ```send_message()```
- ```send_button()```
- ```send_image()```
- ```send_images()```
- ```edit_images()```
- ```end_session()```
- ```set_session_state()```
- ```set_user_state()```

# Message object
Message object is parsed json, to see json structure [click here](https://yandex.ru/dev/dialogs/alice/doc/protocol-docpage/)

# Links
Telegram [@cutefluffyfox](https://t.me/cutefluffyfox)<br>
VK [@cutefluffyfox](https://vk.com/cutefluffyfox)<br>
Expired by [pyTelegramBotAPI](https://github.com/eternnoir/pyTelegramBotAPI)