TensorFlow — an open source software library for numerical computation using data flow graphs. Nodes in the graph represent mathematical operations, while the graph edges represent the multidimensional data arrays (tensors) that flow between them. This flexible architecture lets you deploy computation to one or more CPUs or GPUs in a desktop, server, or mobile device without rewriting code. TensorFlow also includes TensorBoard, a data visualization toolkit.
Supported: Python 2/3
Elizabeth - is a fast and easy to use Python library for generating dummy data for a variety of purposes. This data can be particularly useful during software development and testing. For example, it could be used to populate a testing database for a web application with user information such as email addresses, usernames, first names, last names, etc. Elizabeth uses a JSON-based datastore and does not require any modules that are not in the Python standard library. There are over eighteen different data providers available, which can produce data related to food, people, computer hardware, transportation, addresses, and more.
Basic Usage
>>> from elizabeth import Personal
>>> p = Personal('en')
>>>
>>> p.full_name(gender='female')
'Antonetta Garrison'
>>> p.blood_type()
'O-'
>>> p.occupation()
'Programmer'You can specify a locale when creating providers and they will return data that is appropriate for the language or country associated with that locale. Elizabeth currently includes support for 20 different locales:
| № | Flag | Code | Name | Native name |
|---|---|---|---|---|
| 1 | 🇨🇿 | cs |
Czech | Česky |
| 2 | 🇩🇰 | da |
Danish | Dansk |
| 3 | 🇩🇪 | de |
German | Deutsch |
| 4 | 🇺🇸 | en |
English | English |
| 5 | 🇬🇧 | en-gb |
British English | English |
| 6 | 🇪🇸 | es |
Spanish | Español |
| 7 | 🇮🇷 | fa |
Farsi | فارسی |
| 8 | 🇫🇮 | fi |
Finnish | Suomi |
| 9 | 🇫🇷 | fr |
French | Français |
| 10 | 🇭🇺 | hu |
Hungarian | Magyar |
| 11 | 🇮🇸 | is |
Icelandic | Íslenska |
| 12 | 🇮🇹 | it |
Italian | Italiano |
| 13 | 🇰🇷 | ko |
Korean | 한국어 |
| 14 | 🇳🇱 | nl |
Dutch | Nederlands |
| 15 | 🇳🇴 | no |
Norwegian | Norsk |
| 16 | 🇵🇱 | pl |
Polish | Polski |
| 17 | 🇵🇹 | pt |
Portuguese | Português |
| 18 | 🇧🇷 | pt-br |
Brazilian Portuguese | Português Brasileiro |
| 19 | 🇷🇺 | ru |
Russian | Русский |
| 20 | 🇸🇪 | sv |
Swedish | Svenska |
For another locales, exactly the same way (Icelandic) :
>>> from elizabeth import Personal
>>> user = Personal('is')
>>> for _ in range(0, 9):
user.full_name(gender='male')Karl Brynjúlfsson
Rögnvald Eiðsson
Vésteinn Ríkharðsson
Friðleifur Granason
Fjarki Arngarðsson
Hafsteinn Þrymsson
Sívar Kakalason
Grímnir Unason
Gýmir Þórðsson
Screenshot (integration with Flask):
The Numenta Platform for Intelligent Computing (NUPIC) is a machine intelligence platform that implements the HTM learning algorithms. HTM is a detailed computational theory of the neocortex. At the core of HTM are time-based continuous learning algorithms that store and recall spatial and temporal patterns. NuPIC is suited to a variety of problems, particularly anomaly detection and prediction of streaming data sources.
Supported: Python 2
Flask is a microframework for Python based on Werkzeug and Jinja2. It's intended for getting started very quickly and was developed with best intentions in mind.
Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design.
expynent is a tiny library that provides RegEx patterns. This can be useful if you don't want to write regular expression manually.
Examples:
import re
import expynent.patterns as expas
if re.match(expas.ZIP_CODE['RU'], '43134'):
print('match')
else:
print('not match')
# Output: 'not match'also you can use compiled patterns:
from expynent.compiled import username
u = input('Enter username: ')
if username.match(u):
print('valid')
else:
print('invalid')Universe is a software platform for measuring and training an AI’s general intelligence across the world’s supply of games, websites and other applications. This is the universe open-source library, which provides a simple Gym interface to each Universe environment.
Supported: Python 2/3
**Theano ** — a Python library that allows you to define, optimize, and evaluate mathematical expressions involving multi-dimensional arrays efficiently. It can use GPUs and perform efficient symbolic differentiation.
Supported: Python 2/3
http-prompt — an interactive command-line HTTP client featuring autocomplete and syntax highlighting.
Supported: Python 2/3
falcon — is a high-performance Python framework for building cloud APIs. It encourages the REST architectural style, and tries to do as little as possible while remaining highly effective.
Supported: Python 2/3
eve — an open source Python REST API framework designed for human beings. It allows to effortlessly build and deploy highly customizable, fully featured RESTful Web Services.
Supported: Python 2/3
Eve is powered by Flask, Redis, Cerberus, Events and offers support for both MongoDB and SQL backends.
Example:
from eve import Eve
app = Eve()
app.run()The API is now live, ready to be consumed:
$ curl -i http://example.com/people
HTTP/1.1 200 OK
plotly.py — an interactive, browser-based charting library for Python.
Supported: Python 2/3
cerberus — a lightweight and extensible data validation library for Python.
Supported: Python 2/3
>>> v = Validator({'name': {'type': 'string'}})
>>> v.validate({'name': 'john doe'})
True**Rainbow Stream ** — is a terminal-based Twitter Client. Realtime tweetstream, compose, search, favorite … and much more fun directly from terminal.
Supported: Python 2/3
the fuck — is a magnificent app which corrects your previous console command.
Supported: Python 2/3
pgcli — Postgres CLI with autocompletion and syntax highlighting. pgcli written in Python.
Supported: Python 2/3
mycli - a command line client for MySQL that can do auto-completion and syntax highlighting.
Pendulum — Python datetimes made easy.
Supported: Python 2/3
Example:
>>> import pendulum
>>> now_in_paris = pendulum.now('Europe/Paris')
>>> now_in_paris
'2016-07-04T00:49:58.502116+02:00'
# Seamless timezone switching
>>> now_in_paris.in_timezone('UTC')
'2016-07-03T22:49:58.502116+00:00'
>>> tomorrow = pendulum.now().add(days=1)
>>> last_week = pendulum.now().subtract(weeks=1)
>>> if pendulum.now().is_weekend():
... print('Party!')
'Party!'
>>> past = pendulum.now().subtract(minutes=2)
>>> past.diff_for_humans()
>>> '2 minutes ago'
>>> delta = past - last_week
>>> delta.hours
23
>>> delta.in_words(locale='en')
'6 days 23 hours 58 minutes'
# Proper handling of datetime normalization
>>> pendulum.create(2013, 3, 31, 2, 30, 0, 0, 'Europe/Paris')
'2013-03-31T03:30:00+02:00' # 2:30 does not exist (Skipped time)
# Proper handling of dst transitions
>>> just_before = pendulum.create(2013, 3, 31, 1, 59, 59, 999999, 'Europe/Paris')
'2013-03-31T01:59:59.999999+01:00'
>>> just_before.add(microseconds=1)
'2013-03-31T03:00:00+02:00'python-prompt-toolkit — a library for building powerful interactive command lines and terminal applications in Python.
Supported: Python 2/3
superset — a data exploration platform designed to be visual, intuitive and interactive.
Supported: Python 2/3
Pandas is a Python package providing fast, flexible, and expressive data structures designed to make working with "relational" or "labeled" data both easy and intuitive. It aims to be the fundamental high-level building block for doing practical, real world data analysis in Python. Additionally, it has the broader goal of becoming the most powerful and flexible open source data analysis / manipulation tool available in any language. It is already well on its way toward this goal.
astropy — a package intended to contain much of the core functionality and some common tools needed for performing astronomy and astrophysics with Python.
Supported: Python 2/3
httpie — a command line HTTP client. Its goal is to make CLI interaction with web services as human-friendly as possible. It provides a simple http command that allows for sending arbitrary HTTP requests using a simple and natural syntax, and displays colorized output. HTTPie can be used for testing, debugging, and generally interacting with HTTP servers.
Supported: Python 2/3
compose — a tool for defining and running multi-container Docker applications. With Compose, you use a Compose file to configure your application’s services. Then, using a single command, you create and start all the services from your configuration.
Supported: Python 2/3
keras — a high-level neural networks library, written in Python and capable of running on top of either TensorFlow or Theano. It was developed with a focus on enabling fast experimentation.
bokeh — a Python interactive visualization library, enables beautiful and meaningful visual presentation of data in modern web browsers. With Bokeh, you can quickly and easily create interactive plots, dashboards, and data applications.
Supported: Python 2/3
Records is a very simple, but powerful, library for making raw SQL queries to most relational databases.
Just write SQL. No bells, no whistles. This common task can be surprisingly difficult with the standard tools available. This library strives to make this workflow as simple as possible, while providing an elegant interface to work with your query results.
Supported: Python 2/3
Example:
import records
db = records.Database('postgres://...')
rows = db.query('select * from active_users')
>>> rows[0]
<Record {"username": "model-t", "active": true, "name": "Henry Ford", "user_email": "[email protected]", "timezone": "2016-02-06 22:28:23.894202"}>coala provides a unified command-line interface for linting and fixing all your code, regardless of the programming languages you use.
With coala, users can create rules and standards to be followed in the source code. coala has an user-friendly interface that is completely customizable. It can be used in any environment and is completely modular.
coala has a set of official bears (plugins) for several languages, including popular languages such as C/C++, Python, JavaScript, CSS, Java and many more, in addition to some generic language independent algorithms. To learn more about the different languages supported and the bears themselves, click here.
Supported: Python 2/3
Sanic is a Flask-like Python 3.5+ web server that's written to go fast. It's based on the work done by the amazing folks at magicstack, and was inspired by this article: https://magic.io/blog/uvloop-blazing-fast-python-networking/.
On top of being Flask-like, Sanic supports async request handlers. This means you can use the new shiny async/await syntax from Python 3.5, making your code non-blocking and speedy.
Supported: Python 2/3
Example:
from sanic import Sanic
from sanic.response import json
app = Sanic()
@app.route("/")
async def test(request):
return json({"hello": "world"})
if __name__ == "__main__":
app.run(host="0.0.0.0", port=8000)Locust is an easy-to-use, distributed, user load testing tool. It is intended for load-testing web sites (or other systems) and figuring out how many concurrent users a system can handle.
The idea is that during a test, a swarm of locusts will attack your website. The behavior of each locust (or test user if you will) is defined by you and the swarming process is monitored from a web UI in real-time. This will help you battle test and identify bottlenecks in your code before letting real users in.
Locust is completely event-based, and therefore it's possible to support thousands of concurrent users on a single machine. In contrast to many other event-based apps it doesn't use callbacks. Instead it uses light-weight processes, through gevent. Each locust swarming your site is actually running inside its own process (or greenlet, to be correct). This allows you to write very expressive scenarios in Python without complicating your code with callbacks.
Supported: Python 2/3
py.test framework makes it easy to write small tests, yet scales to support complex functional testing for applications and libraries.
Supported: Python 2/3
An example of a simple test:
def inc(x):
return x + 1
def test_answer():
assert inc(3) == 5uvloop is a fast, drop-in replacement of the built-in asyncio event loop. uvloop is implemented in Cython and uses libuv under the hood.
Supported: Python 2/3
Voltron is an extensible debugger UI toolkit written in Python. It aims to improve the user experience of various debuggers (LLDB, GDB, VDB and WinDbg) by enabling the attachment of utility views that can retrieve and display data from the debugger host. By running these views in other TTYs, you can build a customised debugger user interface to suit your needs.
Voltron does not aim to be everything to everyone. It's not a wholesale replacement for your debugger's CLI. Rather, it aims to complement your existing setup and allow you to extend your CLI debugger as much or as little as you like. If you just want a view of the register contents in a window alongside your debugger, you can do that. If you want to go all out and have something that looks more like OllyDbg, you can do that too.
Supported: Python 2/3
Built-in views are provided for:
- Registers
- Disassembly
- Stack
- Memory
- Breakpoints
- Backtrace
The author's setup looks something like this:
Any debugger command can be split off into a view and highlighted with a specified Pygments lexer:
More screenshots are here.
Maya. Datetimes are very frustrating to work with in Python, especially when dealing with different locales on different systems. This library exists to make the simple things much easier, while admitting that time is an illusion (timezones doubly so).
Supported: Python 3
>>> now = maya.now()
<MayaDT epoch=1481850660.9>
>>> tomorrow = maya.when('tomorrow')
<MayaDT epoch=1481919067.23>
>>> tomorrow.slang_date()
'tomorrow'
>>> tomorrow.slang_time()
'23 hours from now'
>>> tomorrow.iso8601()
'2016-12-16T15:11:30.263350Z'
>>> tomorrow.rfc2822()
'Fri, 16 Dec 2016 20:11:30 -0000'
>>> tomorrow.datetime()
datetime.datetime(2016, 12, 16, 15, 11, 30, 263350, tzinfo=<UTC>)
# Automatically parse datetime strings and generate naive datetimes.
>>> scraped = '2016-12-16 18:23:45.423992+00:00'
>>> maya.parse(scraped).datetime(to_timezone='US/Eastern', naive=True)
datetime.datetime(2016, 12, 16, 13, 23, 45, 423992)
>>> rand_day = maya.when('2011-02-07', timezone='US/Eastern')
<MayaDT epoch=1297036800.0>
# Note how this is the 6th, not the 7th.
>>> rand_day.day
6
# Always.
>>> rand_day.timezone
UTCCabot is a free, open-source, self-hosted infrastructure monitoring platform that provides some of the best features of PagerDuty, Server Density, Pingdom and Nagios without their cost and complexity. (Nagios, I'm mainly looking at you.)
It provides a web interface that allows you to monitor services (e.g. "Stage Redis server", "Production ElasticSearch cluster") and send telephone, sms or hipchat/email alerts to your on-duty team if those services start misbehaving or go down - all without writing a line of code. Best of all, you can use data that you're already pushing to Graphite/statsd to generate alerts, rather than implementing and maintaining a whole new system of data collectors.
Supported: Python 2/3
Glances is a cross-platform curses-based system monitoring tool written in Python.
hug aims to make developing Python driven APIs as simple as possible, but no simpler. As a result, it drastically simplifies Python API development.
Certbot is part of EFF’s effort to encrypt the entire Internet. Secure communication over the Web relies on HTTPS, which requires the use of a digital certificate that lets browsers verify the identify of web servers (e.g., is that really google.com?). Web servers obtain their certificates from trusted third parties called certificate authorities (CAs). Certbot is an easy-to-use client that fetches a certificate from Let’s Encrypt—an open certificate authority launched by the EFF, Mozilla, and others—and deploys it to a web server.
Anyone who has gone through the trouble of setting up a secure website knows what a hassle getting and maintaining a certificate is. Certbot and Let’s Encrypt can automate away the pain and let you turn on and manage HTTPS with simple commands. Using Certbot and Let's Encrypt is free, so there’s no need to arrange payment.
How you use Certbot depends on the configuration of your web server. The best way to get started is to use our interactive guide. It generates instructions based on your configuration settings. In most cases, you’ll need root or administrator access to your web server to run Certbot.
If you’re using a hosted service and don’t have direct access to your web server, you might not be able to use Certbot. Check with your hosting provider for documentation about uploading certificates or using certificates issues by Let’s Encrypt.
Certbot is a fully-featured, extensible client for the Let's Encrypt CA (or any other CA that speaks the ACME protocol) that can automate the tasks of obtaining certificates and configuring webservers to use them. This client runs on Unix-based operating systems.
Khal is a standards based CLI and terminal calendar program, able to synchronize with CalDAV servers through vdirsyncer.
asciinema is a terminal session recorder and the best companion of asciinema.org
Requests. Python HTTP Requests for Humans™
Requests allows you to send organic, grass-fed HTTP/1.1 requests, without the need for manual labor. There's no need to manually add query strings to your URLs, or to form-encode your POST data. Keep-alive and HTTP connection pooling are 100% automatic, powered by urllib3, which is embedded within Requests.
Besides, all the cool kids are doing it. Requests is one of the most downloaded Python packages of all time, pulling in over 7,000,000 downloads every month. You don't want to be left out!
Usage:
>>> r = requests.get('https://api.github.com/user', auth=('user', 'pass'))
>>> r.status_code
200
>>> r.headers['content-type']
'application/json; charset=utf8'
>>> r.encoding
'utf-8'
>>> r.text
u'{"type":"User"...'
>>> r.json()
{u'disk_usage': 368627, u'private_gists': 484, ...}Mail-in-a-Box helps individuals take back control of their email by defining a one-click, easy-to-deploy SMTP+everything else server: a mail server in a box.
schema is a library for validating Python data structures, such as those obtained from config-files, forms, external services or command-line parsing, converted from JSON/YAML (or something else) to Python data-types.
Usage:
>>> from schema import Schema, And, Use, Optional
>>> schema = Schema([{'name': And(str, len),
... 'age': And(Use(int), lambda n: 18 <= n <= 99),
... Optional('sex'): And(str, Use(str.lower),
... lambda s: s in ('male', 'female'))}])
>>> data = [{'name': 'Sue', 'age': '28', 'sex': 'FEMALE'},
... {'name': 'Sam', 'age': '42'},
... {'name': 'Sacha', 'age': '20', 'sex': 'Male'}]
>>> validated = schema.validate(data)
>>> assert validated == [{'name': 'Sue', 'age': 28, 'sex': 'female'},
... {'name': 'Sam', 'age': 42},
... {'name': 'Sacha', 'age' : 20, 'sex': 'male'}]sqlmap is an open source penetration testing tool that automates the process of detecting and exploiting SQL injection flaws and taking over of database servers. It comes with a powerful detection engine, many niche features for the ultimate penetration tester and a broad range of switches lasting from database fingerprinting, over data fetching from the database, to accessing the underlying file system and executing commands on the operating system via out-of-band connections.
SciPy (pronounced "Sigh Pie") is open-source software for mathematics, science, and engineering. It includes modules for statistics, optimization, integration, linear algebra, Fourier transforms, signal and image processing, ODE solvers, and more. It is also the name of a very popular conference on scientific programming with Python.
The SciPy library depends on NumPy, which provides convenient and fast N-dimensional array manipulation. The SciPy library is built to work with NumPy arrays, and provides many user-friendly and efficient numerical routines such as routines for numerical integration and optimization. Together, they run on all popular operating systems, are quick to install, and are free of charge. NumPy and SciPy are easy to use, but powerful enough to be depended upon by some of the world's leading scientists and engineers. If you need to manipulate numbers on a computer and display or publish the results, give SciPy a try!
SymPy is a Python library for symbolic mathematics. It aims to become a full-featured computer algebra system (CAS) while keeping the code as simple as possible in order to be comprehensible and easily extensible. SymPy is written entirely in Python.
matplotlib is a Python 2D plotting library which produces publication-quality figures in a variety of hardcopy formats and interactive environments across platforms. matplotlib can be used in Python scripts, the Python and IPython shell (ala MATLAB or Mathematica), web application servers, and various graphical user interface toolkits.
Sovereign is a set of Ansible playbooks that you can use to build and maintain your own personal cloud based entirely on open source software, so you’re in control.
If you’ve never used Ansible before, you might find these playbooks useful to learn from, since they show off a fair bit of what the tool can do.
The original author's background and motivations might be of interest. tl;dr: frustrations with Google Apps and concerns about privacy and long-term support.
Sovereign offers useful cloud services while being reasonably secure and low-maintenance. Use it to set up your server, SSH in every couple weeks, but mostly forget about it.
Kivy is an open source, cross-platform Python framework for the development of applications that make use of innovative, multi-touch user interfaces. The aim is to allow for quick and easy interaction design and rapid prototyping whilst making your code reusable and deployable.
Kivy is written in Python and Cython, based on OpenGL ES 2, supports various input devices and has an extensive widget library. With the same codebase, you can target Windows, OS X, Linux, Android and iOS. All Kivy widgets are built with multitouch support.
tqdm - a fast, extensible progress bar for Python and CLI
from tqdm import tqdm
for i in tqdm(range(10000)):
...
Output:
76%|████████████████████████████ | 7568/10000 [00:33<00:10, 229.00it/s]
pycodestyle is a tool to check your Python code against some of the style conventions in PEP 8.
Example usage:
$ pycodestyle --first optparse.py
optparse.py:69:11: E401 multiple imports on one line
optparse.py:77:1: E302 expected 2 blank lines, found 1
optparse.py:88:5: E301 expected 1 blank line, found 0
optparse.py:222:34: W602 deprecated form of raising exception
optparse.py:347:31: E211 whitespace before '('
optparse.py:357:17: E201 whitespace after '{'
optparse.py:472:29: E221 multiple spaces before operator
optparse.py:544:21: W601 .has_key() is deprecated, use 'in'
BossSensor - Hide screen when boss is approaching.
Boss stands up. He is approaching.
When he is approaching, fetch face images and classify image.
If image is classified as the Boss, monitor changes.
rodeo - a Python IDE built for analyzing data.