semvec/pypi-packages huggingface dataset:
alpha-dbw 1.0
Python API to Alpha | OSCAR Project
Requires Python: >=2.6
Keywords: alpha,vehicle,api,oscar,drive-by-wire

### Alpha_py

Репозиторий содержит API низкоуровневой системы управления автомобилем [Alpha](alpha.starline.ru), разрабатываемой в рамках проекта [OSCAR](https://gitlab.com/starline/oscar), для беспилотных транспортных средств.


#### Установка с PyPI

```
pip3 install --user alpha_py
```


#### Установка из исходников

```
git clone https://gitlab.com/starline/alpha_py.git && cd alpha_py
pip3 install --user -e .
```


#### Использование

```
import alpha
vehicle = alpha.Vehicle(“/dev/ttyACM0”)
vehicle.drive()
vehicle.steer(20)
vehicle.move(10)
vehicle.manual()
vehicle.led_blink()
vehicle.emergency_stop()
vehicle.recover()
vehicle.left_turn_signal()
vehicle.right_turn_signal()
vehicle.emergency_signals()
vehicle.turn_off_signals()
vehicle.get_vehicle_speed()
```
caenhv 0.0.1
An unofficial Python package 🐍📦 to interface with CAEN high voltage power supplies
Requires Python: >=3.8

# caenhv

[![PyPI version](https://badge.fury.io/py/caenhv.svg)](https://badge.fury.io/py/caenhv)
[![Build and Test](https://github.com/lobis/caen-hv/actions/workflows/build-test.yml/badge.svg)](https://github.com/lobis/caen-hv/actions/workflows/build-test.yml)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/caen-hv)

## 🤔 What is this?

This is an unofficial Python package to interface with CAEN high voltage power supplies over USB (RS232 protocol).

## ⚠️ Disclaimer

The features of this package are based on my needs at the time of writing.
I have done very limited testing on a single model (DT1471ET) but it should also work for other CAEN power supplies also
supporting RS232.

If you use this package, it is very possible you find a bug or some oversight.
You are encouraged to make a [pull request](https://github.com/lobis/caen-hv/pulls) or to create
an [issue](https://github.com/lobis/caen-hv/issues) to report a bug, to request additional features or to suggest
improvements.

## ⚙️ Installation

Installation via `pip` is supported.
To install the latest [published version](https://github.com/lobis/lecroy-scope/releases), run:

```bash
pip install caenhv
```

To install the package from source, including test dependencies, clone the repository and run:

```bash
pip install .[test]
```

## 👨‍💻 Usage

```python
from caenhv import CaenHV

# automatically detect serial port and baudrate (can be manually set)
caen = CaenHV()
# get the first module. CAEN supports multiple modules over the same connection
# typically only one module should be present
module = caen[0]

# get channel number 2
channel = module.channel(2)

# print current 'vset' and 'vmon' values
print(f"vset: {channel.vset}")
print(f"vmon: {channel.vmon}")

# switch channel off and off
channel.off()
channel.on()

# set a new value of 'vset'
channel.vset = 300.0  # 300 V
```
advanced-dtypes 0.0.2
Data types not found in the standard library that are cool in various different ways ;)
Requires Python: >=3.6

# advanced-dtypes
Advanced DataTypes is a package for Python that provides access faster, feature-rich data types not provided in the standard library, motivated by my thoughts of "why is that not a thing?"
The aim of the project is to fill out the holes in the standard library data types' feature-set while improving upon the performance of the existing feature-set.

## Constant Store
Constant Store is a class that provides a namespace within which to store constants on a class attribute basis. Class definition is very simple:
```py
from advanced_dtypes import ConstStore


class Example(ConstStore):
    NAME_1 = "some_value"
    NAME_2 = 23
```

The class is built to populate a set and dictionary on import, which drives many of the features of the class, as well as the \_\_slots\_\_ attribute, which helps boost performance.
Since the class attributes are maintained, names can be directly dot-referenced.
```py
>> Example.NAME_1 == "some_value"
True
>> type(Example.NAME_1) == str
True
```

`ConstStore` also provides an interface for the following functionality:
```py
>> len(Example)
2
>> 23 in Example
True
>> Example(23)
NAME_2
>> Example["NAME_2"]
23
>> [value for value in Example]
["some_value", 23]
```

You should be aware, however, that non-hashable objects will have slower performance in lookups such as `in`, `Class(value)` and `Class[name]`.


## Fast Enum
`FastEnum` is simply a faster implementation of the existing standard library `Enum`.

Definition is exactly the same as a standard enum:
```py
from advanced_dtypes import FastEnum


class Example(FastEnum):
    NAME_1 = "some_value"
    NAME_2 = 23
```

Similarly, standard enum functionality remains:
```py
>> Example.NAME_1
<Example.NAME_1: some_value>
>> Example.NAME_1.name
NAME_1
>> Example.NAME_1.value
some_value
>> Example("some_value")
<Example.NAME_1: some_value>
>> Example["NAME_1"]
<Example.NAME_1: some_value>
>> len(Example)
2
>> [item for item in Example]
[<Example.NAME_1: some_value>, <Example.NAME_2: 23>]
>> Example.NAME_1 == Example.NAME_1
True
```

The only functional addition in this instance is equality checking of members against values directly:
```py
>> Example.NAME_1 == "some_value"
True
```


## How To Install
```sh
pip install advanced-dtypes
```
qtido 0.9.7
Tracer de figure et d'animatons, pour l'apprentissage de Python, et plus.


**qtido** est une bibliothèque Python(3) pour tracer des figures géométrique et faire des petits jeux.
Une sorte de documentation est disponible sur https://learn.heeere.com/python/reference-qtido/

Elle est basée sur les principes de conception et buts suivants :

- offrir une version de la biblothèque dans la langue de l'apprenant (le français ici, mais qtido est conçue pour être traduite),
- offrir une interface de programmation impérative sans "callback" ni asynchronisme apparent,
- permettre, entre autre, de faire des animations à interval de temp constant (si l'ordinateur est assez rapide),
- créer une abstraction qui permette un exécution des programmes aussi bien sur desktop (avec PyQt) que dans un navigateur (brython + implémentation en javascript de la bibliothèque)

Le nom est un mélange de *Qt* (composant graphiques utilisés par défaut) et de *ido* (langue universelle).

## Installation

~~~
pip install qtido
~~~

## Exemple simple

~~~python
from qtido import *

def mickey(fen, x, y, rayon):
    """Cette fonction trace un mickey"""
    couleur(fen, 1, 1, 1)     # Blanc
    disque(fen, x, y, rayon)  # cX, cY, rayon
    
    couleur(fen, 1, 0, 0)     # Rouge
    disque(fen, x+rayon/2, y-rayon, rayon/2 - 1)
    disque(fen, x-rayon/2, y-rayon, rayon/2 - 1)
    
    couleur(fen, 0, 0.7, 0)   # Vert
    disque(fen, x, y, rayon/5)


f = creer(400, 200)    # créer une fenêtre
mickey(f, 50, 50, 20)

mickey(f, 100, 50, 5)

mickey(f, 200, 50, 20)
mickey(f, 250, 50, 20)
mickey(f, 300, 50, 20)

mickey(f, 100, 120, 40)
mickey(f, 200, 120, 30)
mickey(f, 300, 120, 20)
mickey(f, 350, 120, 10)

attendre_fermeture(f)

~~~