semvec/pypi-packages huggingface dataset:
PyNeuro 1.3.1
Library for connect with Neurosky's Mindwave EEG headset via TCP Socket
License: MIT

PyNeuro
=======

PyNeuro is designed to connect NeuroSky's MindWave EEG device to Python
and provide Callback functionality to provide data to your application
in real time. The library is tested with Mindwave Mobie2 Headset, and
runs stably.

Installation
------------

Run the following command: ``pip install PyNeuro``

Usage
-----
1. Before you start, make sure you have downloaded `Nuerosky Mindware Developer Tools <https://store.neurosky.com/collections/developer-tools>`__  and turned on Thinkgear Connecter. Please keep Thinkgear Connecter on while the program is running.
2. Importing the module: ``from PyNeuro.PyNeuro import PyNeuro``
3. Initializing: ``pn = PyNeuro()``
4. After initializing, if required the callbacks can be set
5. Then call ``pn.connect()`` method, it will connect with TCP Socket
   server.
6. Then call ``pn.start()`` method, it will be start fetching data.
7. To stop call ``pn.close()``

Obtaining Data from Device
~~~~~~~~~~~~~~~~~~~~~~~~~~

-  **Obtaining value:** ``attention = pn.attention`` #to get value of
   attention\_ >\ **Other Variable** attention, meditation,
   blinkStrength, delta, theta, lowAlpha, highAlpha, lowBeta, highBeta, lowGamma, highGamma.

-  **Setting callback:** A call back can be associated with all the
   above variables so that a function is called when the variable is
   updated. Syntax:

   ::

       pn.set_attention_callback(callback_function1)
       pn.set_meditation_callback(callback_function2)
       pn.set_blinkStrength_callback(callback_function3)
       ....

       You can add any number of callback functions to a variable..

Access via callback
--------------------------------------

.. code:: python

    from PyNeuro.PyNeuro import PyNeuro
    from time import sleep

    pn = PyNeuro() 

    def attention_callback(attention_value):
        """this function will be called everytime NeuroPy has a new value for attention"""
        print ("Value of attention is: ", attention_value)
        return None

    pn.set_attention_callback("attention", attention_callback)
    pn.connect()
    pn.start()



Access via object
------------------------------------

.. code:: python

    from PyNeuro.PyNeuro import PyNeuro
    from time import sleep

    pn = PyNeuro() 
    pn.start()

    while True:
        if pn.meditation > 70: # Access data through object
            pn.close() 
        sleep(0.2) 

Python Compatibility
--------------------

-  `Python <http://www.python.com>`__ -v3.\*

Reference
~~~~~~~~~

`lihas/NeuroPy <https://github.com/lihas/NeuroPy>`__ - A library based
on native Bluetooth serial connection
roid 0.8.1
A fast, stateless http slash commands framework for scale. Built by the Crunchy bot team.
License: MIT
Requires Python: >=3.8.0

<h1 align="center">Roid 🤖</h1>
<p align="center">A fast, stateless http slash commands framework for scale. Built by the Crunchy bot team.</p>
<br/>
<br/>

## 🚀 Installation
You can install roid in it's default configuration via:
```
pip install roid
```

You  can install with the optional speedups e.g. orjson with:
```
pip install roid[speedups]
```

## 📚 Getting Started
You can get started with the following options, most of the public API is type hinted
and a lot of the framework depends around this so you should be able to stand on your
own two feet reasonable quickly.

- **[Examples](https://github.com/ChillFish8/roid/tree/master/examples)** are the best / only place to start.

## ✨ Basic Example
```py
import os
import uvicorn

import roid

application_id = os.getenv("APPLICATION_ID")
public_key = os.getenv("PUBLIC_KEY")
token = os.getenv("BOT_TOKEN")

app = roid.SlashCommands(application_id, public_key, token)

# We can create async commands
@app.command("echo", "Echo a message.", guild_id=675647130647658527)
async def echo(message: str):
    return Response(content=message, flags=ResponseFlags.EPHEMERAL)


# Or sync commands which are ran in another thread.
# While this is not advised for everything, we do provide threadsafe interfaces
# to the state management system.
@app.command("echo-sync", "Echo a message with threading.", guild_id=675647130647658527)
def echo_sync(message: str):
    return Response(content=message, flags=ResponseFlags.EPHEMERAL)


if __name__ == "__main__":
    app.register_commands_on_start()
    uvicorn.run("app:app", port=8000)

```

## ❤️ Developer Note
Please note that this library is largely designed around what we need the framework to do
rather than strictly as a general API framework.

You may notice rather opinionated things e.g. how we work command groups. Which are
a trait of that. These things are generally subject to change with Discord but right
now we thing the standard command groups look rather poor.

This framework is not for everyone, if you need the gateway or general REST api calls
this is probably not the framework for you.
(Although if you would like to add some more of the slash commands REST api then feel free to PR.)
 
This is also why there generally arent any forms of online docs for this, i'll get
around to it, eventually.