semvec/pypi-packages huggingface dataset:
ahio 1.0.35
I/O Communication Library
Requires Python: <3.15,>=3.8
Keywords: I/O, data acquisition, hardware communication

ahio
====

ahio is a communication library whose goal
is to abstract the interfacing with various I/O hardwares, so that changing
hardware becomes possible with minimum code modification. It's desired that
an application that already works with an I/O hardware will only need pin
remapping and possibly initial setup change to work with another hardware, not
entire code rewrite.

It works with drivers, which are installed in the `ahio.drivers` package. Every
driver must implement the API described in the `ahio.abstract_driver` package.
If you plan to use this library or develop a driver, read the documentation
there.


Installation
------------

Simplest way is to use pip: `pip3 install ahio`
Alternatively you can checkout this repository and run
`python3 setup.py install`


Basic usage
-----------

```python
# Import the package:
import ahio

# You can see what drivers are available in this platform by calling
print(ahio.list_available_drivers())

# Instantiate the desired driver
with ahio.new_driver('Arduino') as arduino:
  # The driver can have a driver-specific setup function. Call it as/if needed.
  arduino.setup('/dev/tty.usbmodem1421')

  # Map the pins. From now on, when you use 1 in the API, it will have effects
  # on pin D3 in the Arduino. If you change hardware in the future, just change
  # the mapping.
  arduino.map_pin(1, arduino.Pins.D3)
  arduino.map_pin(2, arduino.Pins.D13)
  arduino.map_pin(3, arduino.Pins.A1)

  # Change a pin direction (Input or Output)
  arduino.set_pin_direction([1, 2], ahio.Direction.Output)
  arduino.set_pin_direction(3, ahio.Direction.Input)

  # Set the output of a pin
  arduino.write([1, 2], ahio.LogicValue.High)
  arduino.write(1, 0.4, pwm=True)

  # Read the input of a pin
  print(arduino.read(3))
```

Documentation
-------------

Documentation is hosted at [GitHub](https://acristoffers.github.io/ahio)
flatpak-pip-generator 25.0.0
this is an unofficial pypi distribution of the flatpak_pip_generator script

# Flatpak PIP Generator

this is an unofficial pypi distribution of the flatpak_pip_generator script

upstream - https://github.com/flatpak/flatpak-builder-tools/tree/master/pip

Tool to automatically generate `flatpak-builder` manifest json from a `pip`
package-name.

This requires `requirements-parser` which can be installed on your host with `pip3 install --user requirements-parser`.

## Usage

`flatpak-pip-generator --runtime='org.freedesktop.Sdk//22.08' foo` which generates `python3-foo.json` and can be included in a manifest like:

```json
"modules": [
  "python3-foo.json",
  {
    "name": "other-modules"
  }
]
```

You can also list multiple packages in single command:
```
flatpak-pip-generator --runtime='org.freedesktop.Sdk//22.08' foo\>=1.0.0,\<2.0.0 bar
```

If your project contains a [requirements.txt file](https://pip.readthedocs.io/en/stable/user_guide/#requirements-files) with all the project dependencies, you can use
```
flatpak-pip-generator --runtime='org.freedesktop.Sdk//22.08' --requirements-file='/the/path/to/requirements.txt' --output pypi-dependencies
```

You can use that in your manifest like
```json
"modules": [
  "pypi-dependencies.json",
  {
    "name": "other-modules"
  }
]
```

## Options

* `--python2`: Build with Python 2. Note that you will have to build [the Python 2 shared-module](https://github.com/flathub/shared-modules/tree/master/python2.7) as it is not in any runtime.
* `--build-isolation`: Enable build isolation with pip (recommended but not always work).
* `--cleanup=(scripts|all)`: Add `cleanup` to the manifest. This is used when the packages installed are only used at build time.
* `--build-only`: Alias to `--cleanup=all`.
* `--requirements-file=`, `-r`: Reads the list of packages from `requirements.txt` file.
* `--ignore-pkg=`: Ignore a specific package name in a requirements-file, otherwise ignored.
* `--checker-data`: This adds `x-checker-data` to modules so you will be notified when new releases happen. See [flatpak-external-data-checker](https://github.com/flathub/flatpak-external-data-checker) for more details.
* `--runtime=`: Runs `pip` inside of a specific Flatpak runtime instead of on your host. Highly recommended for reproducability and portability. Examples would be `org.freedesktop.Sdk//22.08` or `org.gnome.Sdk/aarch64/43`.
* `--ignore-errors=`: Allow the generation of empty or otherwise broken files when downloading packages fails.
* `--ignore-installed=`: Comma-separated list of package names for which pip should ignore already installed packages. Useful when the package is installed in the SDK but not in the runtime.
* `--output=`: Sets an output file.
* `--yaml`: Outputs a YAML file.
gitreporter 0.2.13
Git Analysis Tool
Requires Python: >=3.10

# GitReporter

You can execute `gitreporter` by simply calling

```
gitreporter
```

to get an overview about the options.

The recommended way is to create a configuration file with
```
gitreporter -c CONFIG --create-config
```

where you insert all necessary parameters. Then you can call
```
gitreporter -c CONFIG
```

to analyse a git repository.

> Note: the option `comments-and-coding-standard` is only supported for C-like languages at the moment.
whl-env 0.0.1
wheelos env tool
Requires Python: >=3.6
Keywords: whl_env, wheelos

# whl_env

Autonomous driving environments are inherently complex, involving a wide array of components such as hardware (compute units, vehicles, sensors) and software (operating systems, middleware, the autonomous driving application itself, configuration files).

Ensuring the **consistency** of these environments is paramount during testing. Environment-specific discrepancies are a frequent cause of strange and difficult-to-diagnose issues in system tests, leading to unreliable results.

`whl_env` is designed precisely to tackle this challenge. It acts as a tool to **capture and document the state of your autonomous driving test environment**, allowing you to verify its configuration and guarantee consistency across different test platforms and runs.

## Quick Start

Get `whl_env` installed and start collecting environment data in minutes.

### Installation

Install the package using pip:

```bash
pip install whl_env
```

### Collecting Environment Information

Run the `whl_env` command. Use the `-o` or `--output` option to specify the path where the collected system information should be saved in JSON format.

```bash
whl_env -o system_info.json
```

This command will execute the environment collection process and save the results to `system_info.json` in the current directory.

### Verifying Consistency

Once you have collected `system_info.json` files from different environments or test runs, you can compare them using any standard diff tool (command-line `diff`, graphical diff tools, or dedicated JSON diff comparison tools).

```bash
# Example using a command-line diff tool
diff environment_a_info.json environment_b_info.json

# Any differences highlighted indicate inconsistencies between the two environments.
```

By comparing these snapshots, you can quickly pinpoint configuration drift or variations that could be impacting your test results.