semvec/pypi-packages huggingface dataset:
sphinxcontrib-httpdomain 2.0.0
Sphinx extension that provides a domain for documenting HTTP APIs.
Requires Python: >=3.10
Keywords: Sphinx, extension, documentation, contrib, HTTP, API, domain

``sphinxcontrib.httpdomain``
============================

.. image:: https://img.shields.io/pypi/v/sphinxcontrib-httpdomain
    :target: https://pypi.org/project/sphinxcontrib-httpdomain/
    :alt: Latest PyPI version

.. image:: https://img.shields.io/pypi/pyversions/sphinxcontrib-httpdomain
    :target: https://pypi.org/project/sphinxcontrib-httpdomain/
    :alt: Supported Python versions

.. image:: https://app.readthedocs.org/projects/sphinxcontrib-httpdomain/badge/
    :target: https://sphinxcontrib-httpdomain.readthedocs.io/en/stable/
    :alt: Documentation status

.. image:: https://github.com/sphinx-contrib/httpdomain/actions/workflows/tests.yml/badge.svg?branch=main
    :alt: Build status
    :target: https://github.com/sphinx-contrib/httpdomain/actions/workflows/tests.yml

.. image:: https://img.shields.io/pypi/dm/sphinxcontrib-httpdomain
    :alt: PyPI monthly downloads

.. image:: https://img.shields.io/github/sponsors/stevepiercy
    :target: https://github.com/sponsors/stevepiercy
    :alt: GitHub Sponsors

This contrib extension, ``sphinxcontrib.httpdomain``, provides a Sphinx
domain for describing HTTP APIs.

You can find the documentation at the following URL:

https://sphinxcontrib-httpdomain.readthedocs.io/en/stable/
ardupyrpc 1.0.0
Python client for an Arduino RPC bridge using MsgPack over serial.
Requires Python: >=3.8
Keywords: arduino, teensyduino, rpc, serial, msgpack

# pyrpc

A tiny RPC bridge between Arduino and Python using MsgPack over serial.

It lets you expose C++ functions on an Arduino board and call them directly from Python, with automatic (de)serialization of basic types, containers, and structs.

## Arduino side

Install `pyrpc` from the Arduino Library Manager.

```cpp
#include <pyrpc.h>

double sum(int i, float d) {
	return i + d;
}

void setup() {
	Serial.begin(115200);

	pyrpc::begin();  

	// register an onConnect procedure (called when Python connects)
	pyrpc::registerOnConnect([]() {
		// do whatever you need here
	});

	pyrpc::registerRpc(
		"sum",
		sum,
		F("@brief sum two numbers @return double @arg i integer @arg d float")
	);
}

void loop() {
	pyrpc::process();  // handle incoming RPC calls
}
```

Upload this sketch to your Arduino (baudrate must match the Python side).

## Python side

Install the Python package:

```bash
pip install ardupyrpc
```

Call your Arduino procedures from Python:

```python
from ardupyrpc import Rpc

# on_connect=True sends an onConnect message to the Arduino after connecting
rpc = Rpc("/dev/ttyACM0", baudrate=115200, on_connect=True)

print(rpc.help)  # shows all available remote procedures

result = rpc.call("sum", 3, 1.5)
print("sum result:", result)

rpc.close()
```

A more complete example is available in the `examples/` folder.

## Current limitations
When STL containers are not supported, there is a limation of 128 bytes for the serialized data. This means that complex nested structures may not work as expected and the `help` command may fail to retrieve the full documentation.
doplcommunicator 1.0.23
Communicates data between dopl and devices

# Data Communicator Client

Sends and receives data between clients connected to Dopl

## Usage

```python
# Robot
import threading
import time

from doplcommunicator import DoplCommunicator, ControllerData, RobotData

def on_joined_session(session_id: int):
    print('Joined session id', session_id)

def on_controller_data(controller_data: ControllerData):
    print('Controller data received', controller_data.toDict())

def run_loop(communicator):
    while(True):
        # Use sparingly as this causes a read lock
        controller_data = communicator.controller_data

        # Send pressure data to remote clients
        communicator.robot_data = RobotData(True, 0.4)

        # Apply controller data to robot

        time.sleep(0.01)

communicator = DoplCommunicator("http://localhost:3000")
communicator.on_joined_session(on_joined_session)
communicator.on_controller_data(on_controller_data)
communicator.connect()

threading.Thread(target=run_loop, args=(communicator))
```

```python
# Robot Controller
import time
from doplcommunicator import DoplCommunicator, ControllerData, RobotData

def on_joined_session(session_id: int):
    print('Joined session id', session_id)

def run_loop(communicator):
    while(True):
        # Send controller data to clients
        x = y = z = rx = ry = rz = rw = 0
        communicator.controller_data = ControllerData(x, y, z, rx, ry, rz, rw)

        # Apply pressure data to controller
        pressure = communicator.robot_data.pressure
        # controller.apply_force(pressure)

        time.sleep(0.01)

communicator = DoplCommunicator("http://localhost:3000")
communicator.on_joined_session(on_joined_session)
communicator.connect()

threading.Thread(target=run_loop, args=(communicator))
```