semvec/pypi-packages huggingface dataset:
LocationWebApp 3.1.2
API to show your current location on a Google Map & to obtain location data such as latitude, longitude, zip-code & much more
License: MIT

- An asynchronous web-application to fetch current physical location & display it on Google Maps
- Provides relevant location data such as latitude, longitude, zip code for a given physical address
- Capable of resolving keywords, "Eg. Statue of Liberty" into address coordinates & zip code
- REST API that currently provides address-to-coordinate-mapping
- Asynchronous I/O to ensure multiple REST calls are answered (outformat JSON/XML)
- Used Google Maps, Google Geolocation, Google Geocoding, Custom APIs to build the application
- Runs on Tornado & Flask web-framework
- Virtual Environment to build Python 3.4 sandbox 
- HTTP load testing using Apache Benchmarking tool

Beta-Tested (More features coming soon)
fntools 1.1.2
Functional programming tools for data processing
License: MIT
Keywords: functional programming tools data processing

fntools
=======


.. image:: https://readthedocs.org/projects/fntools/badge/?version=master

:target: https://readthedocs.org/projects/fntools/?badge=master
:alt: Documentation Status

**fntools** provides functional programming tools for data processing. This
module is a set of functions that I needed in my work and found useful.


Installation
------------

::

    pip install fntools


Examples
--------

* Split a list of elements with factors with `split`::

    songs = ('Black', 'Even Flow', 'Amongst the waves', 'Sirens')
    albums = ('Ten', 'Ten', 'Backspacer', 'Lightning Bolt')
    print split(songs, albums)
    {'Lightning Bolt': ['Sirens'], 'Ten': ['Black', 'Even Flow'], 'Backspacer': ['Amongst the waves']}


* Determine whether any element of a list is included in another list with `any_in`::

    print any_in(['Oceans', 'Big Wave'], ['Once', 'Alive', 'Oceans', 'Release'])
    True

    print any_in(['Better Man'], ['Man of the Hour', 'Thumbing my way'])
    False


* Apply many functions on the data with `dispatch`::

    # Suppose we want to know the mean, the standard deviation and the median of
    # a distribution (here we use the standard normal distribution)

    import numpy as np
    np.random.seed(10)
    x = np.random.randn(10000)

    print dispatch(x, (np.mean, np.std, np.median))
    [0.0051020560019149385, 0.98966401277169491, 0.013111308495186252]


Many more useful functions are available. For more details, go to the
documentation_.


Inspirations
------------

* The excellent toolz_ by `Matthew Rocklin`_
* `A pratical introduction to functional programming`_ by `Mary Rose Cook`_
* A bit of `R`_ (multimap, use, use_with)


.. _documentation: http://fntools.readthedocs.org/en/latest
.. _toolz: https://github.com/mrocklin/toolz
.. _`A pratical introduction to functional programming`: http://maryrosecook.com/blog/post/a-practical-introduction-to-functional-programming
.. _`Matthew Rocklin`: https://github.com/mrocklin
.. _`Mary Rose Cook`: https://github.com/maryrosecook
.. _R: http://www.r-project.org
li 0.1.3
A tool to quickly fetch a license.
License: MIT
Keywords: li projects

**
li
**

.. image:: https://badge.fury.io/py/li.svg
    :target: http://badge.fury.io/py/li

.. image:: https://img.shields.io/github/license/mashape/apistatus.svg
	:target: http://goldsborough.mit-license.org

.. image:: http://img.shields.io/gratipay/goldsborough.svg
	:target: https://gratipay.com/~goldsborough/

.. image:: https://travis-ci.org/goldsborough/li.svg?branch=master
    :target: https://travis-ci.org/goldsborough/li

\

\

*li* is a tool to quickly fetch a license.

When finishing up a project, you had two choices to fetch your license:

1. Go to some previous projects of yours and get the license you used there. Then check if the year of the license is still valid, else change it. Estimated time: ~30 seconds.

2. Go online and use a search engine to find the license of your choice, in plain-text. Naturally, you click on the wrong link about 13 times before you find a simple plain-text version of the license, for you to copy. Then replace the <year> and <author> fields with your data. Estimated time: ~1-2 minutes.

I propose the following solution:

.. code-block:: bash

    $ li -k mit -a "Your Name" > LICENSE

Estimated time: ~5 seconds.

You can also pass a year with ``-y``, but I reckon you'll be happy with the
default value being the current year. The best thing is: your input is cached under
``$HOME/.license``, so next time, all you need to type is:

.. code-block:: bash

    $ li > LICENSE

Estimated time: ~1 second. Estimated happiness: over 9000. You're welcome.

Installing
==========

You can grab *li* off PyPI:

.. code-block:: bash

    $ pip install li

`License <goldsborough.mit-license.org>`_
=========================================

This project is licensed under the MIT-License.

Authors
=======

Peter Goldsborough & `cat <https://goo.gl/IpUmJn>`_ :heart:
cfautodoc 0.1.3
Tool to document CloudFormation templates in Markdown.
License: MIT

# cloudformation-autodoc
[![Circle CI](https://circleci.com/gh/Linuturk/cloudformation-autodoc.svg?style=svg)](https://circleci.com/gh/Linuturk/cloudformation-autodoc)

## Install

`pip install cfautodoc`

## Usage

```
usage: cfautodoc [-h] [--output OUTPUT] [--timestamp TIMESTAMP]
                 [--insert INSERT]
                 template

Document CloudFormation templates in Markdown.

positional arguments:
  template              the JSON template to document

optional arguments:
  -h, --help            show this help message and exit
  --output OUTPUT       Output the Markdown
  --timestamp TIMESTAMP
                        Add a timestamp to the end of the output.
  --insert INSERT       Block of Markdown to insert into the output.
```

## Ansible Module

To install place `ansible/library/cloudformation_autodoc.py` in the [library path](http://docs.ansible.com/ansible/intro_configuration.html#library) for Ansible.
dockerfactory 0.1
Control the context of your docker builds.
License: MIT

Dockerfactory
=============

Control the context of your docker builds.

Dockerfactory makes ``docker build`` easier by using a config file
(``Dockerfactory.yml``) instead of command line arguments to build.
``Dockerfactory.yml`` also lets you specify the build context so you can pick and
choose the exact directories or files that get added to your Docker build
context.


Dockerfactory.yml
-----------------

.. code-block:: yaml

    # Automatically tag built images
    tag: six8/dockerfactory
    # Can override the Dockerfile
    dockerfile: ./Dockerfile.prod
    # Most `docker build` parameters work (use '_' instead of '-')
    force_rm: True
    memory: 100m
    context:
      # Relative directories are relative to Dockerfactory.yml
      # Must specify current directory if you want it. Dockerfactory
      # does not assume you want the current directory.
      .: /
      # Dockerfactory allows paths outside of current directory
      ../foobar:/foobar

See `docker build <https://docs.docker.com/engine/reference/commandline/build/>`_
for full set of parameters.


Usage
-----

You can either install as a Python package with ``pip install dockerfactory`` or
run as a docker image.

.. code-block:: shell

    docker run -it --rm \
        -v /var/run/docker.sock:/var/run/docker.sock \
        -v ${PWD}:/project \
        six8/dockerfactory:0.1 \
        /project/Dockerfactory.yml

.. code-block:: shell

    Dockerfactory building:
      With command: docker build --force-rm --memory 100m --no-cache --tag six8/dockerfactory:0.1 -
      With Dockerfile: /project/Dockerfile
      With context:
        - /project: /

    Sending build context to Docker daemon 97.28 kB
    ....