semvec/pypi-packages huggingface dataset:
fredo 0.0.2
Alfred alternative for linux
License: MIT
Requires Python: >=3.6.1

# Fredo
Fredo is an attempt to copy some of [Alfred's](https://www.alfredapp.com/) features to run on linux (X11).

![](https://media.giphy.com/media/otSTuknFf503Rvfzjg/giphy.gif)

Fredo was a POC project originally made to follow a book, but since It actually became useful to me I'm opening the repo with It's obvious flaws.

## How It Works
Fredo implements a simple interface written in kivy that receives input from the user. The input is then parsed at runtime by Fredo that resolves what plugin should be used to get options for the current query. Thus, Fredo works with prefixes. One can have a prefix 'p' for running python scripts for example, or the prefix 'y' to quickly search and open youtube.

Plugins are just python classes that implements two methods: `get_options` and `action`. The former takes in the current query and returns a list of options, the latter is a definition of the action to take when the user selects an option, like copying to the clipboard or opening a document.

## Writing a Plugin
This will propably change, but to write a plugin you should write a python class that inherit the `Plugin` class, from `fredo.plugins.base`. Your class should implement at least two methods:

### `action(command)`
This is the method that will run once the user selects an option. The command argument is a string defined in the option.

### `get_options(query)`
This is the method that gives the options to the user. It receives a query, and It should return a list of options. An option is defined as a dict with a `title` key, an optional `subtitle` key (that will be displayed in the gui) and with a `command` key that will be passed to the `action` method one the option is selected.

## Defining plugins and prefixes
For the moment, Alfredo gets Its configs from the conf.py file in the root of the project. There you can find simple examples on how the plugins and prefixes are set.

## Drawbacks
To aviod a frozen screen while expensive functions run to search for results (like searching for files in a disk or querying a slow api), every time the user types a new character a new process is spawned to handle the plugin's search for results, taking place of the previous process that is brutally killed. That means that It's not possible to cache the results, and that a lot of processes are created and killed while using Alfredo.
I don't really know how to handle this and would appreciate any help on the matter.

The executable app is built using PyInstaller and at the moment I couldn't find a simpler way to distribute It.

There is no decent dependency management yet (some default actions assume that the user has a certain package installed, like `xclip`).
eiscp-micropython 0.9.11
Micropython packages for the Onkyo EISCP protocol.
License: MIT
Requires Python: >=3.6

# EISCP Micropython #

[![PyPI](https://img.shields.io/pypi/v/eiscp-micropython)](https://pypi.org/project/eiscp-micropython/)

This is an implementation of the Onkyo EISCP protocol for running on Microcontrollers utilizing [MicroPython](http://www.micropython.org/).

It is a heavily stripped down version of the [Onkyo EISCP](https://github.com/miracle2k/onkyo-eiscp) library and supports
sending commands to connected devices in the same IP-Network.

Compared to the original library, this one is also utilizing [uasyncio](https://docs.micropython.org/en/latest/library/uasyncio.html) for being able to run the project easily with other code.


## Usage ##

As an example turning on the first device in the network and changing the audio input.

```python
import uasyncio
import network
from eiscp import discover

wifi = network.WLAN(network.STA_IF)
wifi.active(True)
wifi.connect('SSID', 'PW')

loop = uasyncio.get_event_loop()

clients = loop.run_until_complete(discover())

client = clients[0]

loop.run_until_complete(client.power_on())
loop.run_until_complete(client.command("SLI", "11"))
```


## Testing ##

The EISCP library has been real world tested with an ESP32 microcontroller inside of the [ESP32 IR Remote Protocol](https://github.com/cbrand/esp32-ir-remote).

It communicates successfully to a [SX-S30DAB](https://intl.pioneer-audiovisual.com/products/2ch_components/sx-s30dab/).


## License ##

The project has been published via the MIT license.
getwallpapers 0.1.1
download wallpaper collection from http://getwallpapers.com/
License: MIT

# getwallpaper-dl

Lets you download wallpaper collection from http://getwallpapers.com/

## ⚙️ Installation

You can install it from [PyPI](https://pypi.org/project/getwallpapers/)

## 💻 How to Use

You can run it as a module in a command line as `getwallpapers` followed by an `wallpaper collection url`. It will generate a folder in the particular location that you are running from and downloads all the collection wallpapers into it.

    $ python getwallpapers <wallpaper-url>

## 📑 Release History

* 0.1.1

    * First version - save all the wallpaper in a folder

## 🚧🚀 Contributing

Feel free to contribute with anything.

## ⚖️ License

Copyright (c) 2020 Shikrishna Joisa. <br />
<br />
Distributed under the MIT license. <br />
See [`LICENSE`](https://github.com/Diegoslourenco/skoopy/blob/main/LICENSE) for more information.