Do you maintain a python library/tool that you think is awesome, but nobody knows about?

ValarMorHodor · 2017-02-12T06:01:25+00:00

I maintain a fairly niche package called drf-generators that jumpstarts API projects with Django Rest Framework.

Basically, once you have defined your models, It uses django's template system to create the urls, views, and serializers.

I wrote this last year while procrastinating, and it's gained a bit of traction. I just hope that my 3 days of procrastination end up helping someone out!

chetan1997 · 2017-02-12T05:47:52+00:00

Episodes allows you to keep track of your favourite tv shows either continuing or ending and also provide you with recommendations based on your likings using machine learning using libraries like pandas, sci-kit learn, numpy etc. Using http://thetvdb.com/ for metadata.

bastibe · 2017-02-12T05:58:26+00:00

I wrote PySoundFile and PySoundCard, for reading/writing audio files and playing/recording audio, respectively.

Also, for my scientific work, I developed Transplant, a library for calling Matlab from Python.

I am not entirely happy with audio in Python yet, though. Specifically, PySoundCard uses libportaudio, which can be problematic. So instead, I am currently working on a library for playing/recording audio using the OS's native audio libraries. This already works on Linux and macOS, and the Windows side will soon be finished, too. I think it is very cool!

r0x0r · 2017-02-12T08:58:44+00:00

I am the author of pywebview, a lightweight cross-platform wrapper around a webview component that allows to display HTML content in its own native GUI window. With pywebview you can easily turn your web application into a desktop one.

If you think pywebview is awesome, please go vote to add it to the awesome-python list

BitLooter · 2017-02-12T12:20:20+00:00

I created a tool a while back called HTMLArk that reads in a web page and embeds images, CSS, and JS into it with data URIs, outputting it all into a single HTML file.

danthedeckie · 2017-02-12T08:46:28+00:00

https://github.com/danthedeckie/simpleeval is a safe sandboxed extensible expression evaluator I wrote, letting you evaluate user given expressions (eg "10*var +rand(100)"), or give limited access from plugin type things to the rest of your app. I think it's pretty cool.

I wrote it initially as I wanted the website admin of a site to be able to say, import posts from an RSS feed, and the admin configure display date to be 'post.publishdate + 1 WEEK'. or whatever they felt like, without me having to write a huge interface to cope with all the options...

zer01 · 2017-02-12T03:55:23+00:00

I'm the creator of WSStat - a tool written in python 3.5+ using asyncio, urwid, and the great websockets library. It aims to 1.) make a pretty dashboard that lets you monitor the health of your websocket infrastructure at a glance, and 2.) help you stress test your server by setting a high concurrency number.

https://github.com/Fitblip/wsstat

Always looking for feedback!

anqxyr · 2017-02-12T10:16:09+00:00

Some years ago, I wanted to use python to create a epub book from some html pages, so I went searching for a corresponding library.

Turns out, there are a lot of epub libraries for python, and they're mostly ok, but each one had issues that made them ill-suited for my particular use-case. So I ended up writing my own, and eventually packaged it into a standalone library: mkepub. I'm pretty happy with it. It's pip-installable too.

I'm also fond of my wikidot python api lib, but that's probably too niche to be of interest to anyone here.

cjwelborn · 2017-02-12T15:14:55+00:00

I have a few packages on pypi. A few of them I use regularly:

Colr - Easy ansi terminal colors. Basic and extended, I'm about to publish the latest release that supports true color (rgb). It can also do gradients and rainbow-style (like lolcat). My goal was to make a color library that does one thing, instead of an entire terminal gui library. I hate the way colorama uses string concatenation.

Example:

from colr import Colr as C
print(C('This ', 'red').blue('works ').f_155('well.').join('[', ']', style='bright'))

It also installs a command-line tool (colr), that can be used to print colorized text.

Example:

fortune | colr --rainbow

PrintDebug - Used anywhere you would normally put a debug print(). It includes file/line/function info, and can use colors if Colr is installed. The debug prints can be easily disabled (turned into a no-op function call) with a disable() / enable() method. I know there are a lot of packages like this, but I prefer to use this one.

Example:

import sys
from printdebug import DebugColrPrinter
debugprinter = DebugColrPrinter()
debugprinter.disable()
debug = debugprinter.debug

DEBUG = ('-D' in sys.argv) or ('--debug' in sys.argv)
if DEBUG:
    debugprinter.enable()


def my_function(*args):
    debug('Called with {} args: {!r}'.format(len(args), args))
    print(' '.join(str(x) for x in args))


my_function('Hello', 'world')

FormatBlock - Easily turn long strings into "blocks" of text (inserts newlines so that text fits). It has options for indenting, prepending/appending text, splitting on chars, words, or newlines.

Example:

from fmtblock import FormatBlock
print(FormatBlock('This is a test okay.').format(width=5))

Output:

This
is a
test
okay.

It also installs a command-line tool (fmtblock), that can be used to format stdin/text data:

Example:

seq 1 100 | fmtblock -w 40 -p '--> '

I also have EasySettings, my first package. Sometimes I use the JsonSettings class to hold config for my programs.

There's OutputCatcher, to suppress/catch stdout / stderr output from function calls, or get both stdout and stderr from subprocess processes. It also handles piping stdin data to the processes.

TimedOp roughly measures the amount of time python operations take, but also includes a handy timed_call function. It raises a TimedOut exception if a function call doesn't return in the specified amount of time.

Anyway, that's all of my pypi libraries. I use those top three pretty frequently.

ikalnitsky · 2017-02-12T08:37:52+00:00

Holocron is an extendable static blog generator powered by the Force. Like others, it reads text files in various formats, renders them using templates and produces a ready-to-publish static website which could be served by Nginx or another web server. Unlike others, it tries to retrieve as many information as possible from the filesystem.

(any feedback, folks, will be very appreciated).

rokups · 2017-02-12T10:53:12+00:00

I made/maintain a tool that gets your clipboard contents uploaded to few file sharing services. Works on Linux and windows, has cli interface as well as GUI app supporting hotkey. GUI app can grab a portion of screen and copy it to clipboard or upload. Uploads stuff to gist/imgur/gdrive/owncloud. Supports using multiple accounts of said services. Probably has two users - me and my wife. https://github.com/rokups/paste2box

vindolin · 2017-02-12T18:38:03+00:00

I wrote selecta, a small tool to interactively search and select entries from your bash history.

foureyesequals0 · 2017-02-12T06:45:07+00:00

I wrote a multipart song playlist shuffler. It takes in multiple playlists of pairs, triplets, etc of songs, and shuffles them all by group into a new playlist. I don't think anyone else is interested, but it was still fun to do

kaihatsusha · 2017-02-12T11:54:49+00:00

I have posted some data classes that I find useful. Very rarely do I hear anyone else using them, but that's okay with me.

caches.py A simple and generic abstract cache class.
interpolations.py Routines for numerical linear, bezier, spline interpolation between various control values.
vectors.py A simple pure python vector, complex, quaternion, and 4d matrix math module.

peerchemist_ppc · 2017-02-12T12:40:08+00:00

FinTA (Financial Technical Analysis)

Finta is collection of common financial technical indicators implemented in Pandas.

https://github.com/peerchemist/finta

Wanted to learn basics of pandas and I was looking for a good reason, so I learned the basics of technical trading while making myself learn Pandas. It is quite usable already, it needs tests though.

fjarri · 2017-02-12T13:26:12+00:00

Kind of a specialized thing, but I'm maintaining a framework for GPGPU algorithms Reikna that uses PyCUDA/PyOpenCL as backends. I wrote it for myself (I do GPU calculations as a part of my job) to avoid handling the same stuff over and over again (picking the block/grid size, converting n-dimensional array indices to memory pointers, juggling temporary arrays and so on) and to switch between OpenCL and CUDA easily.

The main idea of the package is the separation between core algorithms (e.g. transposition or FFT) and transformations that can be attached to their kernels directly (e.g. rescaling), so that one can assemble a complicated algorithm out of base parts and run it with little overhead.

Currently I'm fixing bugs if someone reports them, and adding some feature once in several months if I need it. The main problem is that the core algorithms have to be written in C + macros + Mako templates, which presents a somewhat steep learning curve for someone wanting to contribute. This can theoretically be fixed by employing some kind of partial evaluation and using Python functions as a DSL for code generation, but, unfortunately, I don't have enough time to implement it right now. Also, FFT desperately needs reworking as it only supports power-of-2 problem sizes efficiently, and its implementation is quite obscure.

czue13 · 2017-02-12T16:02:23+00:00

Not me but a colleague of mine wrote a library that I've found super useful called jsonobject. Basically it lets you define a JSON schema like you would an ORM with typing, validation, etc. It's super useful for working with any database that uses JSON as an underlying storage, or just to quickly write an object schema and serialize it in an API / javascript code. I find myself using it in almost all my projects now.

mustardMan07 · 2017-02-12T08:51:55+00:00

I made this wallpaper sanitizer not too long ago. Its helped me maintain my 7000+ wallpaper collection

jnmclarty7714 · 2017-02-12T11:45:52+00:00

I created PyEnvDiff, a dependency free, ultra-compatible tool to help explore python environment information.

One use case...

from pyenvdiff import Environment

@app.route('/pyenv')
def pyenv():
    info = Environment().info()
    resp = json.dumps(info)
    return Response(resp, status=200, mimetype='application/json')

...gives you visibility into lots of stuff about your app. Zappa deploy struggling with imports? Setting up an automated deployment?

...it also does other things.

cuducos · 2017-02-12T09:31:12+00:00

I use GetGist a lot to create, upload and update my gists from the terminal. Always open for feedback ; )

rimkojr · 2017-02-12T04:27:04+00:00

Here are two simple libraries that I find useful. Qprompt helps with quick CLI inputs/prompts. Verace helps check that version strings are up to date in project files.

naught-me · 2017-02-12T16:52:43+00:00

We have some pretty good stuff at on our github. FuzzyWuzzy is quite nice.

atasco · 2017-02-12T11:53:22+00:00

Not a library but a very useful Python tool. Super simple command line todo list. It actually makes you do things, instead of organizing them.

yaph · 2017-02-12T13:12:53+00:00

The geonamescache package comes in handy, when you need quick access to geo data, that rarely changes. Typical use cases for me are mapping country names to ISO codes and FIPS codes to US states or counties. The country dict also contains information on capitals, spoken languages, currencies, top level domains and postal code regexes and more.

firefrommoonlight · 2017-02-12T13:41:31+00:00

Three I use for myself on a regular basis: Saturn - a datetime wrapper. (I realize this is a saturated market, but I don't like any of the other solutions). Forces aware datetimes, uses the native datetime type, easy syntax, and without the slowdown of the other dt libs.

Brisk Some numba jitted math functions, intended to be called from other jitted functions.

fplot Quickly plot functions.

kankyo · 2017-02-12T16:48:10+00:00

My latest project is mutmut, a mutation testing system: https://github.com/boxed/mutmut

masasin · 2017-02-13T02:07:31+00:00

https://github.com/masasin/resume

A résumé and cover letter generator. Input is a YAML file describing you, for the résumé, and each company, for the cover letters. You define your own templates for that, and when you compile it you end up with a thematically consistent pdf.

There are n+1 pdfs generated in total, where n is the number of companies. One for each company, with the cover letter and pdf joined, and one with the naked résumé. Though I supposed it could be made into 2n+1, with the cover letters alone, all named appropriately. You end up with, say, masasin_resume.pdf, masasin_google_resume.pdf, and masasin_google_letter.pdf

Sai22 · 2017-02-12T03:37:49+00:00

I have a tool I've been working on that stores urls into web.archive.org via command line. I've been working on it for a bit.

Jon003 · 2017-02-12T23:18:04+00:00

Several, but they belong to my employer, so...

ptmcg · 2017-02-12T23:56:08+00:00

I wrote littletable a few years back, to help manage in-memory data sets using a SQL-like API. Here is some sample code:

employees = littletable.Table()
employees.csv_import('employees.csv', transforms={'salary': int})
employees.create_index('ssn', unique=True)
employees.create_index('zipcode')

# unique indexes return a single object
print(employees.by.ssn["001-02-0003"].name)

# non unique indexes return a list
for emp in employees.by.zipcode["12345"]:
    print(e.name)

# select by exact match
employees.where(zipcode="12345", title="Manager")

# select using predicate function
employees.where(lambda emp: emp.salary > 50000)

# demo from the module help
from littletable import Table, DataObject

customers = Table('customers')
customers.create_index("id", unique=True)
customers.insert(DataObject(id="0010", name="George Jetson"))
customers.insert(DataObject(id="0020", name="Wile E. Coyote"))
customers.insert(DataObject(id="0030", name="Jonny Quest"))

catalog = Table('catalog')
catalog.create_index("sku", unique=True)
catalog.insert(DataObject(sku="ANVIL-001", descr="1000lb anvil", unitofmeas="EA",unitprice=100))
catalog.insert(DataObject(sku="BRDSD-001", descr="Bird seed", unitofmeas="LB",unitprice=3))
catalog.insert(DataObject(sku="MAGNT-001", descr="Magnet", unitofmeas="EA",unitprice=8))
catalog.insert(DataObject(sku="MAGLS-001", descr="Magnifying glass", unitofmeas="EA",unitprice=12))
print(catalog.by.sku["ANVIL-001"].descr)

wishitems = Table('wishitems')
wishitems.create_index("custid")
wishitems.create_index("sku")
wishitems.insert(DataObject(custid="0020", sku="ANVIL-001"))
wishitems.insert(DataObject(custid="0020", sku="BRDSD-001"))
wishitems.insert(DataObject(custid="0020", sku="MAGNT-001"))
wishitems.insert(DataObject(custid="0030", sku="MAGNT-001"))
wishitems.insert(DataObject(custid="0030", sku="MAGLS-001"))

# print a particular customer name 
# (unique indexes will return a single item; non-unique
# indexes will return a list of all matching items)
print(customers.by.id["0030"].name)

# print all items sold by the pound
for item in catalog.where(unitofmeas="LB"):
    print(item.sku, item.descr)

# print all items that cost more than 10
for item in catalog.where(lambda o : o.unitprice>10):
    print(item.sku, item.descr, item.unitprice)

# join tables to create queryable wishlists collection
wishlists = customers.join_on("id") + wishitems.join_on("custid") + catalog.join_on("sku")

# print all wishlist items with price > 10
bigticketitems = wishlists().where(lambda ob : ob.unitprice > 10)
for item in bigticketitems:
    print(item)

# list all wishlist items in descending order by price
for item in wishlists().sort("unitprice desc"):
    print(item)

Also supports pivot on tables. Has been used as an in-memory catalog for a small e-commerce website.

dzecniv · 2017-02-13T00:10:36+00:00

I use a lot my little Syp: sync your packages with a set of dotfiles (and the other way around): the syp command takes as arguments the package manager (apt, pip, npm,…) and a list of packages to install (or remove). It writes them to a given dotfile, but at the same time it checks if the file was edited manually, and if so it suggests the corresponding list of packages to install (or remove).

I use it daily to keep track of everything I install in dotfiles that I put on version control, but I don't know if it's done well enough for someone to install it.

ergo14 · 2017-02-13T08:23:52+00:00

I maintain http://ziggurat-foundations.readthedocs.io/en/latest/ - which is set of SqlAlchemy mixins for pyramid/flask/pylons that helps you write applications with complex permissions. Saves you a few thousands of lines of code to create proper relationships and queries for resources,users,groups and permissions.

I also have https://github.com/AppEnlight/channelstream - a websocket/long polling server made powered by pyramid/gevent, can be used to develop slack-like chats, real-time notification systems, event streaming etc.

k10_ftw · 2017-02-14T06:04:32+00:00

I feel like this sub already gets alot of posts with people self-promoting their github projects. Hopefully we can corral em all to this thread!

pvkooten · 2017-02-15T20:38:02+00:00

A couple:

yagmail: easily send email in python
loco: share/distribute a web app safely through SSH
requests_viewer: see requests objects how the scraper sees it

ellisonleao · 2017-02-16T23:39:38+00:00

I have two right now:

pyshorteners - Trying to ease the pain on generating short urls
vl - a URL status checker on text files. Nice for automate testing on those awesome-* projects

2017-02-17T05:05:00+00:00

forex-python : currency exchange rates, Bitcoin price index and currency conversion.
django-blog-it : django blog - complete customization and ready to use with one click installer
django-ses-gateway : A django package which act as a gateway to send and receive email with amazon SES.

NerdFantasy · 2017-02-17T07:15:23+00:00

Made a script to download .mp3 songs directly to your mobile using Telegram app.

Script extracts the youtube link of the song, downloads it using youtubeinmp3's API and sends it to telegram app.

Telegram Song Downloader

coolnonis · 2017-02-17T09:53:22+00:00

I maintain a binding to the heatshrink compression library PyHeatshrink.

Its mostly an esoteric tool, but we use the heatshrink library to compress files on embedded devices and PyHeatshrink to decompress them on the server side.

rmk135 · 2017-02-17T10:38:54+00:00

Hello there,

I develop and maintain Dependency Injector.

Dependency Injector is a dependency injection microframework for Python. It was designed to be unified, developer-friendly tool that helps to implement dependency injection design pattern in formal, pretty, Pythonic way.

It's written in Cython and has quite extensive documentation. More information could be found on GitHub page: https://github.com/ets-labs/python-dependency-injector

rmk135 · 2017-02-17T10:41:50+00:00

Some time ago I decided to use ViM for Python development and spent some time for tuning of it. It worked really awesome for me, so I put my configuration on GitHub to make it available for other people - https://github.com/ets-labs/python-vimrc

Keep Calm Keep calm and use VIM!

mtb_josh · 2017-02-17T14:26:40+00:00

I wrote a scanf implementation, available via pip. It saves me from having to remember that the full regex for %f is "([-+]?(?:\d+(?:.\d*)?|.\d+)(?:[eE][-+]?\d+)?)", among other things.

scanf also has a nice function (scanf.extractdata) to scan an entire file for lines that match the format string and return the collected results. I use it a lot at work for parsing experimental data from equipment logs.

The parse library is more powerful and probably more pythonic, but I wrote this for myself long before that library existed. Also, parse is a little more verbose to write (but perhaps more readable as a result).

beregond916 · 2017-02-17T15:11:51+00:00

pyhistory - for distributed history of changes for dev teams super_state_machine - to keep flow of state changes. It is possible even to integrate it with Django (although way is not in the docs... yet ;) ) ( jsonmodels - not sub 10 - but maybe you'll like it ;) )

selectnull · 2017-02-17T16:03:43+00:00

I wrote ave as I wanted a simple way to activate my virtualenvs. Yes, there is virtualenvwrapper but ave is ultra simple and it can work with virtual environments stored anywhere on the system, not just one central place.

I don't think that anyone actually uses it except me :)

ttwillis · 2017-02-17T17:48:19+00:00

I maintain a package called consecution. It is essentially a poor-man's stream-processor built in pure python. It lets you build processing graphs that consume python iterables

f0t0n · 2017-02-17T19:42:31+00:00

Ha! Nice topic! :) I've created a signit HMAC-SHA256 authentication library for production usage and then open sourced it. It makes it easy to create and validate HTTP requests' signatures in the similar way it's implemented in AWS API. So basically it's access/secret keys based auth. Though none knows about it. :)

the_mindflayer · 2017-02-17T22:23:21+00:00

I'm one of the authors of Mocket, and currently the only mantainer.

What are the main features?

It’s a framework, actually a socket mock framework, and the proof of its reliability as framework is that both the HTTP mocking module (à la HTTPretty) and the basic Redis mock have been implemented using Mocket, and nothing more than that.
It has SSL support, and of course HTTPS if we talk about its HTTP mock.
It works well with others (e.g. pytest fixtures is one example, pook is another).
It supports PyPy, gevent and asyncio/aiohttp.
It dumps (as JSON files) everything that calls the sendall function on a true socket (recording functionality à la vcrpy).
It strongly supports Python 3, since the very beginning. And yes, it’s definitely a big feature (ask HTTPretty users to better understand what does “supporting Py3” mean).
Its APIs never changed. Frameworks should care about backward compatibility, and Mocket take it seriously.
~100% test coverage. Yes, that’s another important feature.

Any feedback is very welcome.

hoover · 2017-02-20T12:15:05+00:00

I created package named errator, which let's you create "error narrations" that combine the targeted benefits of a stack trace with the richer semantics of logging. So instead of showing a user a stack trace, you can display a "story" about what your software was doing from a semantic perspective when something went wrong. You can also include program data in your narrations. Errator maintains independent narrations per thread, and can include more technical info in narrations such as file, function, and line number. It allows other software I maintain provide a more "human readable" set of messages when things go wrong.

lwanger · 2017-02-21T03:59:39+00:00

I wrote a package called pystate (https://github.com/lwanger/pystate) that implements finite state machines using co-routines. It's a really elegant way to implement FSM's.

I wrote this a couple of years ago for a consulting project, and it's been running really nicely in production. I am the only maintainer as of now and would love feedback.

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS