semvec/pypi-packages huggingface dataset:
giig 0.3.2
CLI for gitignore.io
License: MIT
Requires Python: >=3
Keywords: gitignore git cli

# gitignore
Python 3 gitignore fetcher based on [gitignore.io](http://gitignore.io)

## Install

```
# pip3 install giig
```

## Usage

```
usage: giig [-h] [--list] [--search SEARCH] [--file [FILE]] [lang [lang ...]]

Download .gitignore files from gitignore.io

positional arguments:
  lang                  language, IDE or OS to include in the .gitignore file

optional arguments:
  -h, --help            show this help message and exit
  --list, -l            list all language, IDE or OS options
  --search SEARCH, -s SEARCH
                        search list of options and print matches
  --file [FILE], -f [FILE]
                        specify which file to write to
```

### Print list
Print list of all possible options for gitignore.io
```
giig -l
```

### Search
Search for specific term (e.g. python)
```
giig -s python
```

### Print to stdout
```
giig python
```

### Write .gitignore file
```
giig -f -- python
```

#### Use custom file
```
giig -f custom-file.txt python
```

### Use as library

```python
import giig

# get list of languages, IDEs, etc.
giig.get_list()

# get list of languages, IDEs, etc.
giig.search(term)

# get gitignore for one/several languages, IDEs, etc.
# where options is a list of terms
giig.get_ignore(options)
```

## Todo

* [x] make giig print to stdout without `-f`
* [ ] add cache (don't need to query gitignore.io everytime)
pwmled 1.6.11
Control LEDs connected to a micro controller using pwm.
License: MIT
Requires Python: >=3.6,<4.0
Keywords: pwm,light,gpio,pca9685

# python-pwmled [![PyPI version](https://badge.fury.io/py/pwmled.svg)](https://badge.fury.io/py/pwmled)

`python-pwmled` controls LEDs connected to a micro controller using pulse-width modulation. It supports one-color, RGB and RGBW leds driven by GPIOs of an Raspberry Pi or a PCA9685 controller.

# Installation
`python-pwmled` requires Python 3. It can be installed using pip:
```bash
pip install pwmled
```

When directly controlling the GPIOs of a Raspberry Pi using the `GpioDriver`(see [below](#configuration)), the [pigpio C library](https://github.com/joan2937/pigpio) is required. It can be installed with the following commands:
```bash
wget abyz.co.uk/rpi/pigpio/pigpio.zip
unzip pigpio.zip
cd PIGPIO
make
sudo make install
```
Besides the library, the `pigpiod` utility is installed, which starts `pigpio` as daemon. The daemon must be running when using the `GpioDriver`.
```bash
sudo pigpiod
```

# Usage
### Configuration
`python-pwmled` supports several possibilities for connecting LEDs to your micro controller:
- GPIO: LEDs can be connected directly to the GPIOs of a Raspberry Pi.
- PCA9885: A [PCA9685](https://cdn-shop.adafruit.com/datasheets/PCA9685.pdf) can be used as I2C-bus PWM controller.

```python
from pwmled.driver.gpio import GpioDriver
from pwmled.driver.pca9685 import Pca9685Driver

# GPIO driver, which controls pins 17, 22, 23
driver = GpioDriver([17, 22, 23])
driver = GpioDriver([17, 22, 23], freq=200)
# To control the pigpio on a other machine use the host and port parameter
driver = GpioDriver([17, 22, 23], host='other.host', port=8889)

# PCA9685 driver which controls pins 1, 2, 3
driver = Pca9685Driver([1, 2, 3])
driver = Pca9685Driver([1, 2, 3], freq=200, address=0x40)
```

### Control
Each LED needs a separated driver, which controls the corresponding pins. The number and order of pins depends on the led type:
- One-color: 1 pin
- RGB: 3 pins (`[R, G, B]`)
- RGBW: 4 pins (`[R, G, B, W]`)

The supported operations are shown in the following example:

```python
from pwmled import Color
from pwmled.led import SimpleLed
from pwmled.led.rgb import RgbLed
from pwmled.led.rgbw import RgbwLed
from pwmled.driver.gpio import GpioDriver

# One-color led
driver = GpioDriver([C])
led = SimpleLed(driver)
led.on()
led.brightness = 0.5
led.transition(5, brightness=0)
led.off()

# RGB led
driver = GpioDriver([R, G, B])
led = RgbLed(driver)
led.on()
led.color = Color(255, 0, 0)
led.set(color=Color(0, 255, 0), brightness=0.5) # set two properties simultaneously
led.transition(5, color=Color(0, 0, 255), brightness=1)
led.off()

# RGBW led
driver = GpioDriver([R, G, B, W])
led = RgbwLed(driver)
# RgbwLed has same interface as RgbLed
```

# Contributions
Pull-requests are welcome, especially for adding new drivers or led types.

# License
This library is provided under [MIT license](https://raw.githubusercontent.com/soldag/python-pwmled/master/LICENSE.md).
cola-plum-dispatch 0.1.4
Multiple dispatch in Python (with additional features for the CoLA library)
License: MIT
Requires Python: >=3.8
Keywords: multiple dispatch

# [Plum: Multiple Dispatch in Python](https://github.com/beartype/plum)

[![DOI](https://zenodo.org/badge/110279931.svg)](https://zenodo.org/badge/latestdoi/110279931)
[![CI](https://github.com/beartype/plum/workflows/CI/badge.svg?branch=master)](https://github.com/beartype/plum/actions?query=workflow%3ACI)
[![Coverage Status](https://coveralls.io/repos/github/beartype/plum/badge.svg?branch=master&service=github)](https://coveralls.io/github/beartype/plum?branch=master)
[![Latest Docs](https://img.shields.io/badge/docs-latest-blue.svg)](https://beartype.github.io/plum)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

Everybody likes multiple dispatch, just like everybody likes plums.

The design philosophy of Plum is to provide an implementation of multiple dispatch that is Pythonic, yet close to how [Julia](http://julia-lang.org/) does it.
[See here for a comparison between Plum, `multipledispatch`, and `multimethod`.](https://beartype.github.io/plum/comparison.html)

*Note:*
Plum 2 is now powered by [Beartype](https://github.com/beartype/beartype)!
If you notice any issues with the new release, please open an issue.

# Installation

Plum requires Python 3.8 or higher.

```bash
pip install cola-plum-dispatch
```

# [Documentation](https://beartype.github.io/plum)

See [here](https://beartype.github.io/plum).

# What's This?

Plum brings your type annotations to life:

```python
from numbers import Number

from plum import dispatch


@dispatch
def f(x: str):
    return "This is a string!"


@dispatch
def f(x: int):
    return "This is an integer!"


@dispatch
def f(x: Number):
    return "This is a general number, but I don't know which type."
```

```python
>>> f("1")
'This is a string!'

>>> f(1)
'This is an integer!'

>>> f(1.0)
'This is a number, but I don't know which type.'

>>> f(object())
NotFoundLookupError: For function `f`, `(<object object at 0x7fb528458190>,)` could not be resolved.
```

This also works for multiple arguments, enabling some neat design patterns:

```python
from numbers import Number, Real, Rational

from plum import dispatch


@dispatch
def multiply(x: Number, y: Number):
    return "Performing fallback implementation of multiplication..."


@dispatch
def multiply(x: Real, y: Real):
    return "Performing specialised implementation for reals..."


@dispatch
def multiply(x: Rational, y: Rational):
    return "Performing specialised implementation for rationals..."
```

```python
>>> multiply(1, 1)
'Performing specialised implementation for rationals...'

>>> multiply(1.0, 1.0)
'Performing specialised implementation for reals...'

>>> multiply(1j, 1j)
'Performing fallback implementation of multiplication...'

>>> multiply(1, 1.0)  # For mixed types, it automatically chooses the right optimisation!
'Performing specialised implementation for reals...'
```