phyelds-webots 8.2.0__tar.gz

phyelds_webots-8.2.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.1
+Name: phyelds-webots
+Version: 8.2.0
+Summary: Webots integration for phyelds: aggregate programs on the robots of a Webots simulation
+Home-page: https://github.com/phyelds/phyelds
+License: Apache-2.0
+Author: Davide Domini
+Author-email: davide.domini@unibo.it
+Requires-Python: >=3.12,<3.14
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: phyelds (>=8.2.0,<9.0.0)
+Project-URL: Repository, https://github.com/phyelds/phyelds
+Description-Content-Type: text/markdown
+
+# phyelds-webots
+
+[Webots](https://cyberbotics.com) integration for [phyelds](https://pypi.org/project/phyelds/):
+run aggregate programs on the robots of a Webots simulation.
+
+## Installation
+
+Install it in the Python that Webots runs the controllers with (Python 3.12 or later):
+
+```bash
+pip install phyelds-webots
+```
+
+The `controller` module comes with Webots.
+
+## Usage
+
+Give each robot an `Emitter`, a `Receiver` and, for the `position` sensor, a `GPS`; the range
+of the emitter decides who the neighbors are. Then, in the controller:
+
+```python
+from controller import Robot
+
+from phyelds.calculus import aggregate
+from phyelds.libraries.device import sense
+from phyelds.libraries.distances import hops_distance
+from phyelds.libraries.spreading import distance_to
+from phyelds.webots import AggregateController
+
+
+@aggregate
+def hops_to_source():
+    return distance_to(sense("source"), hops_distance())
+
+
+robot = Robot()
+aggregate_controller = AggregateController(
+    robot, hops_to_source, gps="gps", sensors=lambda: {"source": robot.getName() == "source"}
+)
+while robot.step(int(robot.getBasicTimeStep())) != -1:
+    hops = aggregate_controller.run_round()   # one round per step
+```
+
+See the [documentation](https://phyelds.github.io/phyelds/integration/webots/).
+

phyelds_webots-8.2.0/README.md

@@ -0,0 +1,44 @@
+# phyelds-webots
+
+[Webots](https://cyberbotics.com) integration for [phyelds](https://pypi.org/project/phyelds/):
+run aggregate programs on the robots of a Webots simulation.
+
+## Installation
+
+Install it in the Python that Webots runs the controllers with (Python 3.12 or later):
+
+```bash
+pip install phyelds-webots
+```
+
+The `controller` module comes with Webots.
+
+## Usage
+
+Give each robot an `Emitter`, a `Receiver` and, for the `position` sensor, a `GPS`; the range
+of the emitter decides who the neighbors are. Then, in the controller:
+
+```python
+from controller import Robot
+
+from phyelds.calculus import aggregate
+from phyelds.libraries.device import sense
+from phyelds.libraries.distances import hops_distance
+from phyelds.libraries.spreading import distance_to
+from phyelds.webots import AggregateController
+
+
+@aggregate
+def hops_to_source():
+    return distance_to(sense("source"), hops_distance())
+
+
+robot = Robot()
+aggregate_controller = AggregateController(
+    robot, hops_to_source, gps="gps", sensors=lambda: {"source": robot.getName() == "source"}
+)
+while robot.step(int(robot.getBasicTimeStep())) != -1:
+    hops = aggregate_controller.run_round()   # one round per step
+```
+
+See the [documentation](https://phyelds.github.io/phyelds/integration/webots/).

phyelds_webots-8.2.0/pyproject.toml

@@ -0,0 +1,37 @@
+[tool.poetry]
+name = "phyelds-webots"
+version = "8.2.0"
+description = "Webots integration for phyelds: aggregate programs on the robots of a Webots simulation"
+license = "Apache-2.0"
+authors = [
+  "Davide Domini <davide.domini@unibo.it>",
+  "Gianluca Aguzzi <gianluca.aguzzi@unibo.it>"
+]
+homepage = "https://github.com/phyelds/phyelds"
+repository = "https://github.com/phyelds/phyelds"
+readme = "README.md"
+
+packages = [
+    { include = "phyelds/webots", from = "src" },
+]
+
+classifiers = [
+    "Operating System :: OS Independent",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[tool.poetry.dependencies]
+python = ">=3.12,<3.14"
+phyelds = "^8.2.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0.0"
+pylint = "^3.0.0"
+flake8 = "^7.0.0"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

phyelds_webots-8.2.0/src/phyelds/webots/__init__.py

@@ -0,0 +1,103 @@
+"""
+Run phyelds programs on the robots of a [Webots](https://cyberbotics.com) simulation.
+
+Each robot runs its own controller, so each robot is a device: its messages travel as bytes
+from its ``Emitter`` to the ``Receiver`` of the robots in range.
+"""
+import json
+from collections.abc import Callable, Mapping
+from typing import Any
+
+from phyelds.vm.device import Device
+
+__all__ = ["AggregateController"]
+
+
+class AggregateController:
+    """
+    Runs an aggregate program on a Webots robot, one round per simulation step.
+
+    The device id is the name of the robot, so robots must have unique names. The neighbors
+    of a robot are the robots its ``Emitter`` reaches; Webots delivers a message in the step
+    after it was sent, so with a round at every step of every robot the rounds are
+    synchronous.
+
+    Args:
+        robot: The ``controller.Robot`` of this controller.
+        program: The ``@aggregate`` function to run.
+        emitter: The name of the ``Emitter`` device of the robot.
+        receiver: The name of the ``Receiver`` device of the robot.
+        gps: The name of a ``GPS`` device, whose values become the ``position`` sensor.
+        sensors: Extra sensors, read at each round, added to ``time`` (the simulation time)
+            and ``position``.
+        paths: The path mode of the engine, ``"debug"`` or ``"compact"``: the same on
+            every robot.
+
+    Raises:
+        ValueError: If the robot has no device with one of the given names.
+    """
+
+    def __init__(  # pylint: disable=too-many-arguments
+        self,
+        robot: Any,
+        program: Callable[[], Any],
+        *,
+        emitter: str = "emitter",
+        receiver: str = "receiver",
+        gps: str | None = None,
+        sensors: Callable[[], Mapping[str, Any]] | None = None,
+        paths: str = "debug",
+    ):
+        self.robot = robot
+        self.sensors = sensors
+        self._device = Device(robot.getName(), program, paths=paths)
+        self._emitter = _get_device(robot, emitter)
+        self._receiver = _get_device(robot, receiver)
+        self._gps = None if gps is None else _get_device(robot, gps)
+        time_step = int(robot.getBasicTimeStep())
+        self._receiver.enable(time_step)
+        if self._gps is not None:
+            self._gps.enable(time_step)
+
+    @property
+    def result(self) -> Any:
+        """The value the program computed in the last round."""
+        return self._device.result
+
+    @property
+    def outputs(self) -> dict[str, Any]:
+        """What the program stored with ``store`` in the last round."""
+        return self._device.outputs
+
+    def run_round(self) -> Any:
+        """
+        Run the program once: read the messages received, compute, and send.
+
+        Call it after each ``robot.step``.
+
+        Returns:
+            The value the program computed.
+        """
+        while self._receiver.getQueueLength() > 0:
+            sender, _, payload = self._receiver.getBytes().partition(b"\n")
+            self._device.receive(json.loads(sender), payload)
+            self._receiver.nextPacket()
+        payload = self._device.run_round(self._sense())
+        self._emitter.send(json.dumps(self._device.device_id).encode() + b"\n" + payload)
+        return self.result
+
+    def _sense(self) -> dict[str, Any]:
+        """The sensors of this round."""
+        position = None if self._gps is None else tuple(self._gps.getValues())
+        sensors = {"position": position, "time": self.robot.getTime()}
+        if self.sensors is not None:
+            sensors.update(self.sensors())
+        return sensors
+
+
+def _get_device(robot: Any, name: str) -> Any:
+    """The device ``name`` of ``robot``."""
+    device = robot.getDevice(name)
+    if device is None:
+        raise ValueError(f"robot {robot.getName()!r} has no device named {name!r}")
+    return device