semvec/pypi-packages huggingface dataset:
ed25519sha3 1.4.1
Ed25519 public-key signatures
License: MIT

Python bindings to the Ed25519 public-key signature system.

This offers a comfortable python interface to a C implementation of the
Ed25519 public-key signature system (http://ed25519.cr.yp.to/), using the
portable 'ref' code from the 'SUPERCOP' benchmarking suite.

This system provides high (128-bit) security, short (32-byte) keys, short
(64-byte) signatures, and fast (2-6ms) operation. Please see the README for
more details.
test-travis-pypi 0.1.10
My short description for my project.
License: MIT
Requires Python: >=3.6.0

�� setup.py (for humans)
=======================

This repo exists to provide [an example setup.py] file, that can be used
to bootstrap your next Python project. It includes some advanced
patterns and best practices for `setup.py`, as well as some
commented–out nice–to–haves.

For example, this `setup.py` provides a `$ python setup.py upload`
command, which creates a *universal wheel* (and *sdist*) and uploads
your package to [PyPi] using [Twine], without the need for an annoying
`setup.cfg` file. It also creates/uploads a new git tag, automatically.

In short, `setup.py` files can be daunting to approach, when first
starting out — even Guido has been heard saying, "everyone cargo cults
thems". It's true — so, I want this repo to be the best place to
copy–paste from :)

**If you're interested in financially supporting Kenneth Reitz open source, consider [visiting this link](https://cash.me/$KennethReitz). Your support helps tremendously with sustainability of motivation, as Open Source is no longer part of my day job.**

[Check out the example!][an example setup.py]

![image]

To Do
-----

-   Tests via `$ setup.py test` (if it's concise).

Pull requests are encouraged!

More Resources
--------------

-   [What is setup.py?] on Stack Overflow
-   [The Hitchhiker's Guide to Packaging]
-   [Cookiecutter template for a Python package]

License
-------

This is free and unencumbered software released into the public domain.

Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled
binary, for any purpose, commercial or non-commercial, and by any means.

✨��✨

  [an example setup.py]: https://github.com/kennethreitz/setup.py/blob/master/setup.py
  [PyPi]: https://docs.python.org/3/distutils/packageindex.html
  [Twine]: https://pypi.python.org/pypi/twine
  [image]: https://farm1.staticflickr.com/628/33173824932_58add34581_k_d.jpg
  [What is setup.py?]: https://stackoverflow.com/questions/1471994/what-is-setup-py
  [The Hitchhiker's Guide to Packaging]: https://the-hitchhikers-guide-to-packaging.readthedocs.io/en/latest/creation.html
  [Cookiecutter template for a Python package]: https://github.com/audreyr/cookiecutter-pypackage
tapedeck 0.0.5
A music player
License: MIT

Tapedeck
========

Tapedeck finds and plays music across muiltiple sources and devices::

   $ pip install tapedeck


One way to use it
-----------------

Perform a search::

   $ tdsearch Music
     1. Elegant Gypsy
     2. Exile On Main St. (Remastered)
     3. Highwayman
     4. Roll On (Bonus Track Version)
     5. Sleepless Nights
     6. The Essential Donovan
     7. Townes Van Zandt
     8. Skull Fu^H^H and Roses
   $ tdplay -m 7 -o icecast

Play the stream remotely::

   ~> tdplay http://192.168.1.100:8777/asdf  # ip address of your machine here

View the cached search::

   $ tdsearch -m
     1. Elegant Gypsy
     2. Exile On Main St. (Remastered)
     3. Highwayman
     4. Roll On (Bonus Track Version)
     5. Sleepless Nights
     6. The Essential Donovan
     7. Townes Van Zandt
     8. Skull Fu^H^H and Roses


**And the band keeps playing on...**
   -- John Perry Barlow


Motivation
----------

I have at least four avocado boxes of cd's in my basement, many of them
damaged by decades of shipping around the country without their cases.
A lot of them are ripped, and I also download live recordings thanks
to `bt.etree.org <http://bt.etree.org>`_ all the time.  All this data
has almost filled a terabyte cloud drive.  Plus it's scattered all over
a pile of old hard drives and home directory backups.  Finally, I want an
easy way to keep my old phone active as a stereo receiver via
`VLC <http://www.videolan.org/index.html>`_.

So, Tapedeck strives to organize this type of music collection and
provide a way for you to enjoy your music.


History
-------

I've had some scripts around for a while to manage my music, but I've never
built them into anything bigger partly because they require some complicated
programming techniques that I never really mastered.  Now that I have found
some `easier ways to program <http://github.com/python-trio/trio>`_ this
type of thing, I feel like I can put it all together into a nifty
`python <http://www.python.org>`_ package.


Requirements
------------

Mac
~~~

1. Install `Homebrew <http://brew.sh>`_ -
   "The missing package manager for macOS".

2. Install some handy programs that ``tapedeck`` requires::

   $ brew install python3 ffmpeg sox aria2 postgresql icecast2

Android
~~~~~~~

1. Install termux
2. Install deps

Windows
~~~~~~~

1. ``git clone http://github.com/zthompson47/tapedeck``
2. make it happen
3. let me know

iPhone
~~~~~~

1. refer
2. to
3. Windows


Sources
~~~~~~~

The source code for this project is hosted on both
`github <http://github.com/>`_ and `pypi <http://pypi.org>`_:

* `tapedeck on pypi <https://pypi.org/project/tapedeck/>`_
* `tapedeck on github <https://github.com/zthompson47/tapedeck>`_
* `reel on pypi <http://pypi.org/project/reel/>`_
* `reel on github <http://github.com/zthompson47/reel>`_
runigma 2019.3
RuNigma is a fictional cypher machine inspired by World War 2s Enigma Machines.
License: MIT

# periodic

RuNigma is a fictional cypher machine inspired by World War 2's Enigma Machines.

# Setup

```bash
pip install runigma
```


# Example usage

```python
from runigma import RuNigmaMachine

rotors = 'Ё Ь Д Н Й'
reflector = 'Ш'
ring_settings = 'a _ y g Б'
plugboard_settings = 'xЕ hЬ КМ Тn iЗ АЛ ЮЫ Бt z8 ОШ wЯ y0 a7 4Ъ СЖ p6 Эe g_ 2b dc'

machine = RuNigmaMachine.from_key_sheet(rotors=rotors, reflector=reflector, ring_settings=ring_settings,
                                        plugboard_settings=plugboard_settings)

machine.set_display('ЯХ3ОЪ')

crypted = machine.process_text('hello world')

print(crypted)
# displays: БЮУЦwЛgcЭЕМ
```

# Command line tools

## runigma

This tool can be used for encipher and decipher text.

```bash
runigma --key-file=enigma.keys -s ФСИАР -t HELLOXWORLDX
```

```bash
runigma -r A Б В Г Д -i a b c d -p AB CD EF GH IJ KL MN -u Ф -s АУГСД
```

## runigma-sheet

This tool can be used for generate new key sheet file.

```bash
runigma-sheet > keysheet.txt
```
burnlight 0.2.0
GPIO scheduler for Raspberry Pis
License: MIT

# Burnlight
Burnlight is a server and client for automating the control 
of the GPIO pins on a Raspberry Pi.

## Features
- Run custom schedules controlling one or more GPIO pins.
- Web API for remote management and monitoring.
- Paired input and output for feedback on controlled systems.

## Requirements
* [Flask](http://flask.pocoo.org/) - Serves the API.
* [gevent](http://www.gevent.org/) - Runs the scheduling threads.
* [Lark parser](https://github.com/lark-parser/lark) - Parses BSL programs.
* [gpiozero](https://gpiozero.readthedocs.io) - Controls GPIO outputs on Raspberry Pi computers.

## Getting started on Raspbian
Install Burnlight using pip:
```
$ pip install burnlight
```
Start the server:
```
$ burnlightd
```
Create a file `schedule.bsl` with the following contents:
```
{
    loop 10: {
        (On,1),
        (Off,1)
    }
}
```
Add and start the schedule using the client
```
$ burnlight schedules add schedule.bsl --start_time now
```


## Burnlight Scheduling Language (BSL)
Schedules are described with a simple language.

The following program will turn the on output for one second each minute for one hour.

```
{
    loop 60: {
        (On,1),
        (Off,59)
    }
}
```

BSL currently supports programs consisting of sequences of output statements
and loops.

The simplest program possible is `{}`, which will do absolutely nothing.
We can make it slightly more interesting by using _output statements_.
An output statement takes the for `(<state>,<duration>)` where `<state>` is
the desired output state, `On` or `Off`, and `<duration>` is the duration
the output should be in that state in seconds.

The following program turns the output on for ten seconds:
```
{
    (On, 10),
    (Off, 1)
}
```