semvec/pypi-packages huggingface dataset:
tuxtrigger 0.9.0
TuxTrigger Project by Linaro
Requires Python: >=3.6

<div align="center">
  <img src="tuxtrigger.svg" alt="TuxTrigger Logo" width="40%" />
</div>

[![Pipeline Status](https://gitlab.com/Linaro/tuxtrigger/badges/main/pipeline.svg)](https://gitlab.com/Linaro/tuxtrigger/pipelines)
[![coverage report](https://gitlab.com/Linaro/tuxtrigger/badges/main/coverage.svg)](https://gitlab.com/Linaro/tuxtrigger/commits/main)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![PyPI - License](https://img.shields.io/pypi/l/tuxtrigger)](https://gitlab.com/Linaro/tuxtrigger/blob/main/LICENSE)

[Documentation](https://linaro.gitlab.io/tuxtrigger) - [Repository](https://gitlab.com/Linaro/tuxtrigger) - [Issues](https://gitlab.com/Linaro/tuxtrigger/-/issues)

TuxTrigger, by [Linaro](https://www.linaro.org/), is a command line tool for controlling changes in repositories.  
TuxTrigger is a part of
[TuxSuite](https://tuxsuite.com), a suite of tools and services to help with
Linux kernel development.

[[_TOC_]]

# About TuxTrigger

TuxTrigger allows to automatically track a set of git repositories and branches. When a change occurs, TuxTrigger will build, test and track the results using Tuxsuite and SQUAD.

# Installing TuxTrigger

There are several options for using TuxTrigger:

- [From PyPI](install-pypi.md)
- [Run uninstalled](run-uninstalled.md)

# Using TuxTrigger

!!! note
    - TuxTrigger requires TuxSuite and SQUAD accounts (TuxSuite and SQUAD tokens).

To use TuxTrigger:

1. Create [TuxSuite](https://tuxsuite.com) account and provide TUXSUITE_TOKEN as environment variable.
2. Create [SQUAD](https://qa-reports.linaro.org/) account and provide SQUAD_TOKEN and SQUAD_HOST as environment variable.
Example:
```shell
SQUAD_HOST=https://qa-reports.linaro.org
```
3. Install TuxTrigger
4. [Create configuration.yaml file](docs/run.md#create-configuration-file)
5. Provide [plan.yaml](https://docs.tuxsuite.com/plan/) file(s) from [TuxSuite](https://tuxsuite.com)
6. Run TuxTrigger

Call tuxtrigger:

```shell
tuxtrigger /path/to/config.yaml --plan /path/to/plan_directory
```

Tuxtrigger will automatically start.
revolve2-standards 1.2.4
Revolve2: Standard tools, parameters, terrains, robots and more for simulations and experiments.
Requires Python: <3.12,>=3.10

<img align="right" width="150" height="150"  src="./docs/source/logo_light.png">

# Revolve2

Revolve2 is a collection of Python packages used for researching evolutionary algorithms and modular robotics.
Its primary features are a modular robot framework, an abstraction layer around physics simulators, and evolutionary algorithms.

**Documentation: [ci-group.github.io/revolve2](https://ci-group.github.io/revolve2)**

**Installation: [ci-group.github.io/revolve2/installation](https://ci-group.github.io/revolve2/installation)**

**Get help: [github.com/ci-group/revolve2/discussions/categories/ask-for-help](https://github.com/ci-group/revolve2/discussions/categories/ask-for-help)**

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8355869.svg)](https://doi.org/10.5281/zenodo.8355869) [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](./LICENSE) [![CI](https://github.com/ci-group/revolve2/actions/workflows/main.yml/badge.svg)](https://github.com/ci-group/revolve2/actions)

## Sample
Here we create and simulate a modular robot, and then calculate how far it moved over the xy plane. This is a shortened version of `examples/evaluate_single_robot`.
```python
# (...) Omitted preamble

# Create a modular robot.
body = modular_robots_v1.gecko_v1()
brain = BrainCpgNetworkNeighborRandom(body=body, rng=rng)
robot = ModularRobot(body, brain)

# Create a scene.
scene = ModularRobotScene(terrain=terrains.flat())
scene.add_robot(robot)

# Create a simulator.
simulator = LocalSimulator(headless=False)

# Simulate the scene and obtain states sampled during the simulation.
scene_states = simulate_scenes(
    simulator=simulator,
    batch_parameters=make_standard_batch_parameters(),
    scenes=scene,
)

# Get the state at the beginning and end of the simulation.
scene_state_begin = scene_states[0]
scene_state_end = scene_states[-1]

# Retrieve the states of the modular robot.
robot_state_begin = scene_state_begin.get_modular_robot_simulation_state(robot)
robot_state_end = scene_state_end.get_modular_robot_simulation_state(robot)

# Calculate the xy displacement of the robot.
xy_displacement = fitness_functions.xy_displacement(
    robot_state_begin, robot_state_end
)
```
revolve2-modular-robot-simulation 1.2.4
Revolve2: Functionality to define scenes with modular robots in a terrain and simulate them.
Requires Python: <3.12,>=3.10

<img align="right" width="150" height="150"  src="./docs/source/logo_light.png">

# Revolve2

Revolve2 is a collection of Python packages used for researching evolutionary algorithms and modular robotics.
Its primary features are a modular robot framework, an abstraction layer around physics simulators, and evolutionary algorithms.

**Documentation: [ci-group.github.io/revolve2](https://ci-group.github.io/revolve2)**

**Installation: [ci-group.github.io/revolve2/installation](https://ci-group.github.io/revolve2/installation)**

**Get help: [github.com/ci-group/revolve2/discussions/categories/ask-for-help](https://github.com/ci-group/revolve2/discussions/categories/ask-for-help)**

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8355869.svg)](https://doi.org/10.5281/zenodo.8355869) [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](./LICENSE) [![CI](https://github.com/ci-group/revolve2/actions/workflows/main.yml/badge.svg)](https://github.com/ci-group/revolve2/actions)

## Sample
Here we create and simulate a modular robot, and then calculate how far it moved over the xy plane. This is a shortened version of `examples/evaluate_single_robot`.
```python
# (...) Omitted preamble

# Create a modular robot.
body = modular_robots_v1.gecko_v1()
brain = BrainCpgNetworkNeighborRandom(body=body, rng=rng)
robot = ModularRobot(body, brain)

# Create a scene.
scene = ModularRobotScene(terrain=terrains.flat())
scene.add_robot(robot)

# Create a simulator.
simulator = LocalSimulator(headless=False)

# Simulate the scene and obtain states sampled during the simulation.
scene_states = simulate_scenes(
    simulator=simulator,
    batch_parameters=make_standard_batch_parameters(),
    scenes=scene,
)

# Get the state at the beginning and end of the simulation.
scene_state_begin = scene_states[0]
scene_state_end = scene_states[-1]

# Retrieve the states of the modular robot.
robot_state_begin = scene_state_begin.get_modular_robot_simulation_state(robot)
robot_state_end = scene_state_end.get_modular_robot_simulation_state(robot)

# Calculate the xy displacement of the robot.
xy_displacement = fitness_functions.xy_displacement(
    robot_state_begin, robot_state_end
)
```
revolve2-modular-robot-physical 1.2.4
Revolve2: Everything for physical modular robot control. This package is intended to be installed on the modular robot hardware.
Requires Python: <3.12,>=3.10

<img align="right" width="150" height="150"  src="./docs/source/logo_light.png">

# Revolve2

Revolve2 is a collection of Python packages used for researching evolutionary algorithms and modular robotics.
Its primary features are a modular robot framework, an abstraction layer around physics simulators, and evolutionary algorithms.

**Documentation: [ci-group.github.io/revolve2](https://ci-group.github.io/revolve2)**

**Installation: [ci-group.github.io/revolve2/installation](https://ci-group.github.io/revolve2/installation)**

**Get help: [github.com/ci-group/revolve2/discussions/categories/ask-for-help](https://github.com/ci-group/revolve2/discussions/categories/ask-for-help)**

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8355869.svg)](https://doi.org/10.5281/zenodo.8355869) [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](./LICENSE) [![CI](https://github.com/ci-group/revolve2/actions/workflows/main.yml/badge.svg)](https://github.com/ci-group/revolve2/actions)

## Sample
Here we create and simulate a modular robot, and then calculate how far it moved over the xy plane. This is a shortened version of `examples/evaluate_single_robot`.
```python
# (...) Omitted preamble

# Create a modular robot.
body = modular_robots_v1.gecko_v1()
brain = BrainCpgNetworkNeighborRandom(body=body, rng=rng)
robot = ModularRobot(body, brain)

# Create a scene.
scene = ModularRobotScene(terrain=terrains.flat())
scene.add_robot(robot)

# Create a simulator.
simulator = LocalSimulator(headless=False)

# Simulate the scene and obtain states sampled during the simulation.
scene_states = simulate_scenes(
    simulator=simulator,
    batch_parameters=make_standard_batch_parameters(),
    scenes=scene,
)

# Get the state at the beginning and end of the simulation.
scene_state_begin = scene_states[0]
scene_state_end = scene_states[-1]

# Retrieve the states of the modular robot.
robot_state_begin = scene_state_begin.get_modular_robot_simulation_state(robot)
robot_state_end = scene_state_end.get_modular_robot_simulation_state(robot)

# Calculate the xy displacement of the robot.
xy_displacement = fitness_functions.xy_displacement(
    robot_state_begin, robot_state_end
)
```
revolve2-simulation 1.2.4
Revolve2: Physics simulation abstraction layer.
Requires Python: <3.12,>=3.10

<img align="right" width="150" height="150"  src="./docs/source/logo_light.png">

# Revolve2

Revolve2 is a collection of Python packages used for researching evolutionary algorithms and modular robotics.
Its primary features are a modular robot framework, an abstraction layer around physics simulators, and evolutionary algorithms.

**Documentation: [ci-group.github.io/revolve2](https://ci-group.github.io/revolve2)**

**Installation: [ci-group.github.io/revolve2/installation](https://ci-group.github.io/revolve2/installation)**

**Get help: [github.com/ci-group/revolve2/discussions/categories/ask-for-help](https://github.com/ci-group/revolve2/discussions/categories/ask-for-help)**

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8355869.svg)](https://doi.org/10.5281/zenodo.8355869) [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](./LICENSE) [![CI](https://github.com/ci-group/revolve2/actions/workflows/main.yml/badge.svg)](https://github.com/ci-group/revolve2/actions)

## Sample
Here we create and simulate a modular robot, and then calculate how far it moved over the xy plane. This is a shortened version of `examples/evaluate_single_robot`.
```python
# (...) Omitted preamble

# Create a modular robot.
body = modular_robots_v1.gecko_v1()
brain = BrainCpgNetworkNeighborRandom(body=body, rng=rng)
robot = ModularRobot(body, brain)

# Create a scene.
scene = ModularRobotScene(terrain=terrains.flat())
scene.add_robot(robot)

# Create a simulator.
simulator = LocalSimulator(headless=False)

# Simulate the scene and obtain states sampled during the simulation.
scene_states = simulate_scenes(
    simulator=simulator,
    batch_parameters=make_standard_batch_parameters(),
    scenes=scene,
)

# Get the state at the beginning and end of the simulation.
scene_state_begin = scene_states[0]
scene_state_end = scene_states[-1]

# Retrieve the states of the modular robot.
robot_state_begin = scene_state_begin.get_modular_robot_simulation_state(robot)
robot_state_end = scene_state_end.get_modular_robot_simulation_state(robot)

# Calculate the xy displacement of the robot.
xy_displacement = fitness_functions.xy_displacement(
    robot_state_begin, robot_state_end
)
```
revolve2-mujoco-simulator 1.2.4
Revolve2: MuJoCo simulator.
Requires Python: <3.12,>=3.10

<img align="right" width="150" height="150"  src="./docs/source/logo_light.png">

# Revolve2

Revolve2 is a collection of Python packages used for researching evolutionary algorithms and modular robotics.
Its primary features are a modular robot framework, an abstraction layer around physics simulators, and evolutionary algorithms.

**Documentation: [ci-group.github.io/revolve2](https://ci-group.github.io/revolve2)**

**Installation: [ci-group.github.io/revolve2/installation](https://ci-group.github.io/revolve2/installation)**

**Get help: [github.com/ci-group/revolve2/discussions/categories/ask-for-help](https://github.com/ci-group/revolve2/discussions/categories/ask-for-help)**

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8355869.svg)](https://doi.org/10.5281/zenodo.8355869) [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](./LICENSE) [![CI](https://github.com/ci-group/revolve2/actions/workflows/main.yml/badge.svg)](https://github.com/ci-group/revolve2/actions)

## Sample
Here we create and simulate a modular robot, and then calculate how far it moved over the xy plane. This is a shortened version of `examples/evaluate_single_robot`.
```python
# (...) Omitted preamble

# Create a modular robot.
body = modular_robots_v1.gecko_v1()
brain = BrainCpgNetworkNeighborRandom(body=body, rng=rng)
robot = ModularRobot(body, brain)

# Create a scene.
scene = ModularRobotScene(terrain=terrains.flat())
scene.add_robot(robot)

# Create a simulator.
simulator = LocalSimulator(headless=False)

# Simulate the scene and obtain states sampled during the simulation.
scene_states = simulate_scenes(
    simulator=simulator,
    batch_parameters=make_standard_batch_parameters(),
    scenes=scene,
)

# Get the state at the beginning and end of the simulation.
scene_state_begin = scene_states[0]
scene_state_end = scene_states[-1]

# Retrieve the states of the modular robot.
robot_state_begin = scene_state_begin.get_modular_robot_simulation_state(robot)
robot_state_end = scene_state_end.get_modular_robot_simulation_state(robot)

# Calculate the xy displacement of the robot.
xy_displacement = fitness_functions.xy_displacement(
    robot_state_begin, robot_state_end
)
```
revolve2-modular-robot 1.2.4
Revolve2: Everything for defining modular robots.
Requires Python: <3.12,>=3.10

<img align="right" width="150" height="150"  src="./docs/source/logo_light.png">

# Revolve2

Revolve2 is a collection of Python packages used for researching evolutionary algorithms and modular robotics.
Its primary features are a modular robot framework, an abstraction layer around physics simulators, and evolutionary algorithms.

**Documentation: [ci-group.github.io/revolve2](https://ci-group.github.io/revolve2)**

**Installation: [ci-group.github.io/revolve2/installation](https://ci-group.github.io/revolve2/installation)**

**Get help: [github.com/ci-group/revolve2/discussions/categories/ask-for-help](https://github.com/ci-group/revolve2/discussions/categories/ask-for-help)**

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8355869.svg)](https://doi.org/10.5281/zenodo.8355869) [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](./LICENSE) [![CI](https://github.com/ci-group/revolve2/actions/workflows/main.yml/badge.svg)](https://github.com/ci-group/revolve2/actions)

## Sample
Here we create and simulate a modular robot, and then calculate how far it moved over the xy plane. This is a shortened version of `examples/evaluate_single_robot`.
```python
# (...) Omitted preamble

# Create a modular robot.
body = modular_robots_v1.gecko_v1()
brain = BrainCpgNetworkNeighborRandom(body=body, rng=rng)
robot = ModularRobot(body, brain)

# Create a scene.
scene = ModularRobotScene(terrain=terrains.flat())
scene.add_robot(robot)

# Create a simulator.
simulator = LocalSimulator(headless=False)

# Simulate the scene and obtain states sampled during the simulation.
scene_states = simulate_scenes(
    simulator=simulator,
    batch_parameters=make_standard_batch_parameters(),
    scenes=scene,
)

# Get the state at the beginning and end of the simulation.
scene_state_begin = scene_states[0]
scene_state_end = scene_states[-1]

# Retrieve the states of the modular robot.
robot_state_begin = scene_state_begin.get_modular_robot_simulation_state(robot)
robot_state_end = scene_state_end.get_modular_robot_simulation_state(robot)

# Calculate the xy displacement of the robot.
xy_displacement = fitness_functions.xy_displacement(
    robot_state_begin, robot_state_end
)
```
revolve2-experimentation 1.2.4
Revolve2: Tools for experimentation.
Requires Python: <3.12,>=3.10

<img align="right" width="150" height="150"  src="./docs/source/logo_light.png">

# Revolve2

Revolve2 is a collection of Python packages used for researching evolutionary algorithms and modular robotics.
Its primary features are a modular robot framework, an abstraction layer around physics simulators, and evolutionary algorithms.

**Documentation: [ci-group.github.io/revolve2](https://ci-group.github.io/revolve2)**

**Installation: [ci-group.github.io/revolve2/installation](https://ci-group.github.io/revolve2/installation)**

**Get help: [github.com/ci-group/revolve2/discussions/categories/ask-for-help](https://github.com/ci-group/revolve2/discussions/categories/ask-for-help)**

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.8355869.svg)](https://doi.org/10.5281/zenodo.8355869) [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](./LICENSE) [![CI](https://github.com/ci-group/revolve2/actions/workflows/main.yml/badge.svg)](https://github.com/ci-group/revolve2/actions)

## Sample
Here we create and simulate a modular robot, and then calculate how far it moved over the xy plane. This is a shortened version of `examples/evaluate_single_robot`.
```python
# (...) Omitted preamble

# Create a modular robot.
body = modular_robots_v1.gecko_v1()
brain = BrainCpgNetworkNeighborRandom(body=body, rng=rng)
robot = ModularRobot(body, brain)

# Create a scene.
scene = ModularRobotScene(terrain=terrains.flat())
scene.add_robot(robot)

# Create a simulator.
simulator = LocalSimulator(headless=False)

# Simulate the scene and obtain states sampled during the simulation.
scene_states = simulate_scenes(
    simulator=simulator,
    batch_parameters=make_standard_batch_parameters(),
    scenes=scene,
)

# Get the state at the beginning and end of the simulation.
scene_state_begin = scene_states[0]
scene_state_end = scene_states[-1]

# Retrieve the states of the modular robot.
robot_state_begin = scene_state_begin.get_modular_robot_simulation_state(robot)
robot_state_end = scene_state_end.get_modular_robot_simulation_state(robot)

# Calculate the xy displacement of the robot.
xy_displacement = fitness_functions.xy_displacement(
    robot_state_begin, robot_state_end
)
```
ximea-py 4.27.13.3
XIMEA camera API
Requires Python: <4.0,>=3.7

# ximea-py

This module provides a python interface to XIMEA cameras. It is simply a repackaging of XIMEA's python drivers available [at their page](https://www.ximea.com/downloads/recent/XIMEA_Linux_SP.tgz) (package/api/Python/v3/ximea) in order to allow for easier installation with pip, e.g. into virtual or conda environments. Windows support was added too by including xiAPI's Windows libraries.

# Prerequisites

## Windows

1. Download and install [XIMEA Windows Software Package](https://www.ximea.com/support/wiki/apis/XIMEA_Windows_Software_Package)
2. Make sure the camera is connected and recognized in xiCOP (XIMEA CameraControl Tool)

## Linux

1. Download and install [XIMEA Linux Software Package](https://www.ximea.com/support/wiki/apis/XIMEA_Linux_Software_Package)
2. Add users that will use the camera to the "plugdev" group:

    ```bash
    sudo usermod -aG plugdev <myuser>
    ```

# Installation

Install with:

```bash
pip install ximea-py
```

and use like so:

```python
import ximea.xiapi

ximea.xiapi.Camera()
...
```