semvec/pypi-packages huggingface dataset:
Toucan 0.0.0
A full stack Flask based framework that put structure in the file system. Features: Caching, Mailing, Storage, CSRF, recaptcha and more
License: MIT
Keywords: flask,toucan,templates,views,classy,framework,mvc,blueprint,toucan

Toucan

Toucan is a Flask based framework to help quickly develop web applications, by
adding structure to your views and templates.

Philosophy:

To create a framework that runs everywhere, regardless of the platform, by
providing cloud balh...

It made the following decisions for you: (of course you can change them)


It comes with pre-built components:


And it is still Flask.

http://pylot.io/
https://github.com/mardix/Toucan
lambda-project-creator 0.0.7
lambda-project-creator project
License: MIT
Keywords: aws lambda lambda-uploader

lambda-project-creator
===============

Easily and quickly command line utility creating Lambda Project for lambda-uploader(https://pypi.python.org/pypi/lambda-uploader).

Installation
~~~~~~~~~~~~

The latest release of lambda-project-creator can be installed via pip:

::

    pip install lambda-project-creator

An alternative install method would be manually installing it leveraging
``setup.py``:

::

    git clone https://github.com/cloudfish7/lambda-project-creator
    cd lambda-project-creator
    python setup.py install


Command Line Usage
~~~~~~~~~~~~~~~~~~

To create Lambda Project simply, run following command

.. code:: shell

    lambda-project-creator -p sampleprj

Get created following file and directory. Also get installed lambda-uploader.

.. code:: shell

   sampleprj
    ├── .venv_sampleprj
    ├── lambda.json
    ├── requirement.txt
    └── lambda.py
donut 0.2.2
Makes symlinks to dotfiles.
License: MIT

# donut

The purpose of this script is to update dot files somewhere.  It works in the
following way.  Two locations are set:

- `dothome`, absolute path to the set the dotfiles
- `dotarchive`, absolute path to the dot files (usually some git archive)

Then symlinks are made from dothome to dotarchive.  Simple as that.

## Installation

```
pip install donut
```

## Usage

```
donut ~ ~/repos/dotfiles
```

## Notes

- `setup.cfg` should be a flat list of files in `dotarchive`
- otherwise all files in `dotarchive` will be symlinked
canbeAny 0.0.4
An example short description.
License: MIT

Description
--------------------------------------------------------------------------------

If you followed the `Guide <http://www.wbh-doc.com.s3.amazonaws.com/Python-with-GitHub-PyPI-and-Readthedoc-Guide/index.html>`_ and did every steps correctly, then your package should be distributed on PyPI now. And you can use:

.. code-block:: console

	$ pip install <your package name>

to install your package.


Install ``canbeAny``
--------------------------------------------------------------------------------

Since this example package is on PyPI, you just need:

.. code-block:: console

	$ pip install canbeAny


Documentation
--------------------------------------------------------------------------------
Your online documentation website should looks like `This <http://www.wbh-doc.com.s3.amazonaws.com/Python-with-GitHub-PyPI-and-Readthedoc-Guide/index.html>`_
genericfuncs 0.2.0
Dynamic dispatch over arbitrary predicates
License: MIT
Keywords: generic functions utility programming development

genericfuncs
============

:code:`genericfuncs` allows you to create functions which execute different
implementations depending on the arguments.

This module can be seen as a powerful improvement over Python 3's :code:`singledispatch`:

* Allows dispatch over any boolean callable, not just type checks.
* Allows dispatch over any number of arguments, not just the first argument.


Basic usage
***********

    from genericfuncs import generic

    @generic
    def func(a):
        # default implementation
        raise ValueError()

    @func.when(lambda a: a.startswith('foo')):
    def _impl_1(a):
        return a.upper()

    @func.when(lambda a: a.startswith('bar')):
    def _impl_2(a):
        return a.lower()

The first predicate that returns True has its mapped implementation invoked.
Predicates are checked in order of definition.


Installation
************

:code:`pip install genericfuncs`


Advanced
********

Arguments are injected into predicates and implementations by their name.
This means a predicate or implementation is able to specify only the arguments it needs. For example::

    @generic
    def multiple_params_func(a, b, c):
        return a + b + c  # default implementation

    @multiple_params_func.when(lambda b: b > 10)  # only inject argument `b` to the predicate
    def _when_b_greater_than_10(a):  # only inject `a` to the implementation
        return a * 10

    @multiple_params_func.when(lambda a, b: a % b == 0)  # only inject `a` and `b`
    def _when_a_divisible_by_c(a, b, c):  # use all arguments
        return a / b * c

However the call site must list all mandatory arguments, as usual in Python::

    multiple_params_func(10, 20, 30) --> 100  # _when_b_great_than_10() invoked
    multiple_params_func(4, 2, 'bla') --> 'blabla'  # _when_a_divisible_by_c() invoked
    multiple_params_func(0, 0, 0) --> 0  # default implementation invoked

When defining a predicate, one can list exception types that should not
propagate if raised inside the predicate. For example::

    @my_generic_func.when(lambda a: a > 10, ignored_errors=[TypeError])
    def _implementation(a):
        ...

When invoking :code:`my_generic_func(MyThing())`, a :code:`TypeError` will be raised inside the predicate
because :code:`MyThing` doesn't support :code:`>` operator.
Normally, the error would propagate and crash the program.
Specifying :code:`ignored_errors=[TypeError]` makes the error be silently ignored,
moving on to the next predicate.
cpmerge 1.0.5
A simple clipboard manager to synchronize the CLIPBOARD and PRIMARY selection under linux
License: MIT

# Description

cpmerge is a simple clipboard manager to synchronize CLIPBOARD and PRIMARY.

Linux has two types of clipboards:
- PRIMARY: Copy by selecting text, paste by middle mouse click
- CLIPBOARD: Copy by using the copy command (usually: CTRL+c), paste by using the paste command (usually: CTRL+v)

cpmerge merges these two clipboards into one. Whenever you copy something into the CLIPBOARD it will automatically be copied into PRIMARY. However when you select something into PRIMARY it waits until you've moved the mouse a little bit before copying it into CLIPBOARD. The reason for this that a lot of people select some text and press CTRL+v to overwrite the selected text. If PRIMARY got copied into CLIPBOARD straight away this would just replace the selected text with itself.

If run with GUI it also keeps track of the last 10 clipboard entries. A taskbar icon allows to copy those old values into the clipboard again.

# Installation

Python 2.7 should already be installed on most systems.
wxPython and pip need to be installed as well. On my Ubuntu machine (with Universe activated) this can be done with:

```
sudo apt-get install python-pip -y
sudo apt-get install python-wxgtk2.8 -y
```

After those requirements are installed, just run:

```
sudo pip install cpmerge
```

cpmerge can be started by simply running: 

```
cpmerge
```

# Configuration

To run it without tray icon and history: 

```
cpmerge --nogui
```

Depending on your screen resolution (and how nervous your mouse hand is) you may need to tweak the distance the mouse needs to be moved before copying from PRIMARY to CLIPBOARD. You can do this with:

```
cpmerge --distance=20
```

For debugging information regarding the mouse distance, run:

```
cpmerge -vv
```

# Other stuff

Py_mem.py tells me that cpmerge uses 35.8 MB of memory. While this is not a huge amount by todays standard I still consider it a lot for the simple task. If you know a tool with similar features which uses less resources, please let me know.

Similar tools (none of them supports the mouse movement before PRIMARY -> CLIPBOARD as far as I'm aware) are listed on: https://wiki.archlinux.org/index.php/clipboard

- Homepage: http://jonaspfannschmidt.com/cpmerge
- Code: http://github.com/jonaspf/cpmerge
- Icon from: http://led24.de/iconset/
anythumbnailer 0.1
Generic Thumbnailer library
License: MIT

anythumbnailer
=======================

A CLI utility/Python library to create thumbnails for different file types
(including PDF, mp4 videos and Microsoft Office documents aka docx/xlsx/pptx).

All the heavy-lifting is done by commonly-used tools such as LibreOffice/unoconv,
ffmpeg, poppler and ImageMagick so format support is limited by what these tools
can process.

I built the library as I could not find a project which satisfied my needs
(as detailed in my question on StackOverflow [1]). However as I wrote something
from scratch the project has quite a few limitations:
- I'm using it only on Linux (Fedora, CentOS 6+7 to be exact). Paths to other
  programs are hard-coded.
- I never tried running this on any other system such as Windows or OS X.

Very likely you will have to tweak the code in case this project is useful for
anyone but me. That being said I'm interested in making the configuration less
hard-coded (e.g. by introducing a config file with sensible syntax) and
automated tests.


Installation / Usage
-----------------------

 $ python setup.py develop
 $ anythumbnail SOURCEFILE [OUTPUTFILE]


[1] http://stackoverflow.com/questions/21511974/is-there-a-python-library-to-create-thumbnails-for-various-document-file-formats
pyloudness 1.1.2
Find out how loud that file is
License: MIT
Keywords: loudness audio ebu r128

pyLoudness
==========

.. image:: https://badge.fury.io/py/pyloudness.svg
    :target: https://badge.fury.io/py/pyloudness


How loud is that file? Sounds simple, right? Check out
http://www.r128audio.com for information about loudness standards.

Usage
-----

Give pyLoudness an audio file and it will give you a dictionary.

::

    import pyloudness
    loudness_stats = pyloudness.get_loudness("test.wav")

Result:

::

    {
        'True Peak': {
            'Peak': 0.4
        }, 
        'Loudness Range': {
            'LRA': 8.4, 
            'Threshold': -39.8, 
            'LRA High': -16.9, 
            'LRA Low': -25.3
        }, 
        'Integrated Loudness': {
            'I': -19.2,
            'Threshold': -29.8
        }
    }

Prerequisities
~~~~~~~~~~~~~~

pyLoudness requires ffmpeg

::

    sudo apt-get install ffmpeg

Installing
~~~~~~~~~~

::

    pip install pyloudness

Miscellania
~~~~~~~~~~

::

ffmpeg -nostats -i file_location -filter_complex ebur128=peak=true -f null -

Authors
-------

-  **Jason Rigden**

License
-------

This project is licensed under the MIT License