semvec/pypi-packages huggingface dataset:
proteas-lib 1.0.0
A Rasperry Pi robot library for educators.
Keywords: Robot,STEM,Educational robot,3D Printed Robot

## GSOC 2019 - A DIY robot kit for educators

The proteas library is a python robotics library for 
Raspberry Pi. This library created for the "GSOC 2019 - A DIY robot kit for educators" 
by Christos Chronis. This library mainly designed to work along the Jupyter Notebook
but works fine direct from any python script. You can easly control all the electronics
parts of a robot with minimun requirement the GPIO pin number. In the library you can also find 
some applications of computer vision with OpenCV, such as face detection, arruco artifact detection
e.t.c.. More informations on https://github.com/eellak/gsoc2019-diyrobot.
conf 0.4.1
Facilitates a convenient use of configuration files

|PyPI version| |Build Status|

conf
====

A *very* simple and *lightweight* configuration loader and parser for Python.

Supports:

-  ini files (``*.ini``)
-  json files (``*.json``)
-  yaml files (``*.yml``, ``*.yaml``)

Installation
''''''''''''

Bare installation:
::

    pip install conf

Installation with support for YAML:
::

    pip install "conf[yaml]"


Usage
'''''

Starting your app
"""""""""""""""""

Start your app with your configuration file:

::

    python your_app.py --config your_config.yml

Or:

::

    python your_app.py --config config_env_var

The ``--config`` argument can be:

- a relative path to a file;
- an absolute path to a file;
- the name of an environment variable which value holds one of the above.

You are allowed to provide multiple configuration names (separated by a single space), in which case any setting of a former
configuration file can be overwritten by a setting of a later configuration file (if the name of that setting is identical).

Once you have supplied your application with some configuration, you can fetch the settings of that configuration. There are
three options of how to do that.

Fetching your setting (option 1)
""""""""""""""""""""""""""""""""

Simply get your setting from the ``conf`` module:

.. code:: python

    import conf
    your_setting = conf.your_setting

Fetching your setting (option 2)
""""""""""""""""""""""""""""""""
Import your setting directly:

.. code:: python

    from conf import your_setting

Fetching your setting (option 3)
""""""""""""""""""""""""""""""""
You can provide a default value if you are not sure the setting will be present:

.. code:: python

    import conf
    your_setting = conf.get('your_setting', 'your default value')

Note: If you use an ArgumentParser in your own application for other purposes, you must use the ``parse_known_args()`` method of the parser.

Fetching your setting (option 4)
""""""""""""""""""""""""""""""""
You can get the configuration as a dictionary and get your setting as you would get any value from a ``dict``:

.. code:: python

    import conf
    conf_dict = conf.asdict()
    your_setting = conf_dict.get('your_setting', 'your default value')


Meta
''''
This lib was designed and written in 2018 by `finetuned89 <https://github.com/finetuned89>`_ and `ramonhagenaars <https://github.com/ramonhagenaars>`_.

.. |PyPI version| image:: https://badge.fury.io/py/conf.svg
   :target: https://badge.fury.io/py/conf

.. |Build Status| image:: https://api.travis-ci.org/ramonhagenaars/conf.svg?branch=master
   :target: https://travis-ci.org/ramonhagenaars/conf
supportr 1.2
supportr
Requires Python: >=3.6

# Supportr

## Intro
supportr is a package used to predict the value of support of texts.

It is based on a fine tuned BERT model.
## Install 

### Use pip
If `pip` is installed, supportr could be installed directly from it:

    pip install supportr

### Dependencies
	python>=3.6.0
	torch>=0.4.1
	numpy
	pandas
	unidecode
	pytorch-pretrained-bert
	pytorch-transformers



## Usage and Example

### Notes: During your first usage, the package will download a model file automatically, which is about 400MB.

### `predict`
`predict` is the core method of this package, 
which takes a single text of a list of texts, and returns a list of raw values in `[1,5]` (higher means more support, while lower means less).

### Simplest usage

You may directly import `supportr` and use the default predict method, e.g.:

    >>> import supportr
    >>> supportr.predict(["I am totally agree with you"])
    [3.8364935]

### Construct from class
Alternatively, you may also construct the object from class, where you could customize the model path and device:

	>>> from supportr import Supportr
	>>> sr = Supportr()

	# Predict a single text
	>>> sr.predict(["I am totally agree with you"])
	[3.8364935]

	# Predict a list of texts
	>>> preds = sr.predict(['I am totally agree with you','I hate you'])
    >>> f"Raw values are {preds}"
    [3.836493  1.7458204]



More detail on how to construct the object is available in docstrings.

### Model using multiprocessing when preprocessing a large dataset into BERT input features 
If you want to use several cpu cores via multiprocessing while preprocessing a large dataset, you may construct the object via

    >>> pr = Supportr(CPU_COUNT=cpu_cpunt, CHUNKSIZE=chunksize)

If you want to faster the code through multi gpus, you may construct the object via

    >>> pr = Supportr(is_paralleled=True, BATCH_SIZE = batch_size)


## Contact
Junjie Wu (wujj38@mail2.sysu.edu.cn)
politenessr 1.3
politenessr
Requires Python: >=3.6

# Politenessr

## Intro
Politenessr is a package used to predict the value of politeness of texts.

It is based on a fine tuned BERT model.
## Install 

### Use pip
If `pip` is installed, politenessr could be installed directly from it:

    pip install politenessr

### Dependencies
	python>=3.6.0
	torch>=0.4.1
	numpy
	pandas
	unidecode
	pytorch-pretrained-bert
	pytorch-transformers



## Usage and Example

### Notes: During your first usage, the package will download a model file automatically, which is about 400MB.

### `predict`
`predict` is the core method of this package, 
which takes a single text of a list of texts, and returns a list of raw values in `[1,5]` (higher means more politeness, while lower means less).

### Simplest usage

You may directly import `politenessr` and use the default predict method, e.g.:

    >>> import politenessr
    >>> politenessr.predict(["I am totally agree with you"])
    [4.3568916]

### Construct from class
Alternatively, you may also construct the object from class, where you could customize the model path and device:

	>>> from politenessr import Politenessr
	>>> pr = Politenessr()

	# Predict a single text
	>>> pr.predict(["I am totally agree with you"])
	[3.5638056]

	# Predict a list of texts
	>>> preds = pr.predict(['I am totally agree with you','I hate you'])
    >>> f"Raw values are {preds}"
    [3.5638053 2.2007465]



More detail on how to construct the object is available in docstrings.

### Model using multiprocessing when preprocessing a large dataset into BERT input features 
If you want to use several cpu cores via multiprocessing while preprocessing a large dataset, you may construct the object via

    >>> pr = Politenessr(CPU_COUNT=cpu_cpunt, CHUNKSIZE=chunksize)

If you want to faster the code through multi gpus, you may construct the object via

    >>> pr = Politenessr(is_paralleled=True, BATCH_SIZE = batch_size)


## Contact
Junjie Wu (wujj38@mail2.sysu.edu.cn)
agreementr 1.5
agreementr
Requires Python: >=3.6

# Agreementr

## Intro
Agreementr is a package used to predict the value of agreement of texts.

It is based on a fine tuned BERT model.
## Install 

### Use pip
If `pip` is installed, agreementr could be installed directly from it:

    pip install agreementr

### Dependencies
	python>=3.6.0
	torch>=0.4.1
	numpy
	pandas
	unidecode
	pytorch-pretrained-bert
	pytorch-transformers



## Usage and Example

### Notes: During your first usage, the package will download a model file automatically, which is about 400MB.

### `predict`
`predict` is the core method of this package, 
which takes a single text of a list of texts, and returns a list of raw values in `[1,5]` (higher means more agreement, while lower means less).

### Simplest usage

You may directly import `agreementr` and use the default predict method, e.g.:

    >>> import agreementr
    >>> agreementr.predict(["I am totally agree with you"])
    [4.3568916]

### Construct from class
Alternatively, you may also construct the object from class, where you could customize the model path and device:

	>>> from agreementr import Agreementr
	>>> ar = Agreementr()

	# Predict a single text
	>>> ar.predict(["I am totally agree with you"])
	[4.3568916]

	# Predict a list of texts
	>>> preds = ar.predict(['I am totally agree with you','I hate you'])
    >>> f"Raw values are {preds}"
    [4.3568916 2.42935]



More detail on how to construct the object is available in docstrings.

### Model using multiprocessing when preprocessing a large dataset into BERT input features 
If you want to use several cpu cores via multiprocessing while preprocessing a large dataset, you may construct the object via

    >>> ar = Agreementr(CPU_COUNT=cpu_cpunt, CHUNKSIZE=chunksize)

If you want to faster the code through multi gpus, you may construct the object via

    >>> ar = Agreementr(is_paralleled=False, BATCH_SIZE = batch_size)


## Contact
Junjie Wu (wujj38@mail2.sysu.edu.cn)