Skip to main content

Extends Python with useful features.

Project description

🧰 Toolbox

Toolbox is a set of tools that expands on the Python Standard Library.


pip install toolbox


Documentation can be found here. PDF version of docs can be found here.


Toolbox follows the same pattern as of the Python Standard Library (PSL) which means that all tools are found inside package names that corresponds to that of the PSL (e.g. asyncio, collections, etc.) with only one exception (config).

Code Examples

Check out documentation for function definitions and more details.


async to_thread

Runs passed function in a new thread to ensure non-blocking IO during asynchronous programming.

from toolbox import to_thread
import asyncio
import time

def func():
    return "Hello world"

async def main():
    await to_thread(func)


Decorator that converts synchronous function into an asynchronous function. Leverages the to_thread function above.

from toolbox import awaitable
import asyncio
import time

def func():
    return "Hello world"

async def main():
    await func()



Combines a property and a classmethod into one, creating a class property. Allows access to computed class attributes.

from toolbox import classproperty

class Animal:
    def dog(cls):
        return "whoof!"

print( # >>> 'whoof!'



An interface for type-agnostic operations between different types.

from toolbox import Item

item = Item(100)
print(item == b"100" == "100" == 100) # >>> True


Dictionary with two-way capabilities.

from toolbox import BidirectionalDict

d = BidirectionalDict({"hello": "world"})
print(d) # >>> {'hello': 'world', 'world': 'hello'}


Dictionary that can be accessed as though it was an object.

from toolbox import ObjectDict

d = ObjectDict({"hello": "world"})
print(d.hello) # >>> 'world'


Dictionary that can be added or subtracted to.

from toolbox import OverloadedDict

d1 = OverloadedDict({"hello": "world"})
d2 = OverloadedDict({"ola": "mundo"})

d1 += d2
print(d1) # >>> {'hello': 'world', 'ola': 'mundo'}

d1 -= d2
print(d1) # >>> {'hello': 'world'}


Dictionary that does not distinct between spaces and underscores.

from toolbox import UnderscoreAccessDict

d = UnderscoreAccessDict({"hello world": "ola mundo"})
d['hello_world'] # >>> 'ola mundo'


Dictionary that is frozen.

from toolbox import FrozenDict

d = FrozenDict({"hello": "world"})
d['ola'] = 'mundo'
# >>> KeyError: 'Cannot set key and value because this is a frozen dictionary.'

All *Dict types above can be combined together (as mixins) to create unique dictionary types. Example:

from toolbox import ObjectDict, UnderscoreAccessDict

class Dict(ObjectDict, UnderscoreAccessDict):
    """ New dictionary that allows object access with underscore access. """

d = Dict({"hello world": "ola mundo", "100": "one hundred"})
print(d.hello_world)    # >>> ola mundo
print(d._100)           # >>> one hundred


Creates a nested namedtuple for easy object access.

from toolbox import nestednamedtuple

nt = nestednamedtuple({"hello": {"ola": "mundo"}})
print(nt) # >>> namedtupled(hello=namedtupled(ola='mundo'))
print(nt.hello.ola) # >>> mundo


Forces nestednamedtuple to not convert dict to namedtuple.

from toolbox import nestednamedtuple

d = {"hello": "world"}
nt = nestednamedtuple({"forced": fdict(d), "notforced": d})

print(nt.notforced)    # >>> namedtupled(hello='world')
print(nt.forced)       # >>> {'hello': 'world'}



Creates a global configuration that can be accessed by other portions of the code via conf or config function calls. Minimizes the need to create Config objects and pass them around different modules, classes, functions, etc.

from toolbox import make_config



Access global configuration as a nestednamedtuple.

from toolbox import conf

print(conf().hello) # >>> 'world'


Access global configuration as a dictionary.

from toolbox import config

print(config()['hello']) # >>> 'world'



Decorator that adds support for synchronous and asynchronous function timeout. Quits function after an amount of time passes.

from toolbox import timeout

def func():




Searches for packages installed in the system.

from toolbox import search_package

print(search_package("toolbox", method="is"))
# >>> {'toolbox': <module 'toolbox' from '.../toolbox/'>}


All tools marked as experimental are not meant to be used in production.


Decorator for adding dispatch functionality between async and sync functions. Allows calling the same function name, one as a normal function and one as an awaitable, yet receive different results.

from toolbox import asyncdispatch
import asyncio

def func():
    return "sync"

async def _():
    return "async"

async def main():
    print(func())          # >>> sync
    print(await func())    # >>> async


Comes out of the box with built-in ANSI formats that allows text style modification.

from toolbox import bold, red

print(red("This text is red!"))
print(bold("This text is bolded!"))

Check documentation here for further information on all built-in formats.


Persistent ANSI format container that allows custom ANSI code.

from toolbox import Format

bold = Format(code=1)
print(bold("hello world"))


Persistent ANSI format container that allows multiple ANSI codes.

from toolbox import Style, red, bold

error = Style(red, bold)
print(error("This is red & bolded error."))


Returns bool that indicates whether or not the user's terminal supports color.

from toolbox import supports_color



Removes ANSI codes from string.

from toolbox import strip_ansi

print(strip_ansi("\x1b[1mhello world\x1b[0m")) # >>> hello world



Unident triple quotes and removes any white spaces before or after text.

from toolbox import unident

def test():
    return unindent(
        hello world
        this is a test
        of this functionality

# >>> hello world
# >>> this is a test
# >>> of this functionality

Project details

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Files for toolbox, version 1.4.0
Filename, size File type Python version Upload date Hashes
Filename, size toolbox-1.4.0-py3-none-any.whl (19.7 kB) File type Wheel Python version py3 Upload date Hashes View
Filename, size toolbox-1.4.0.tar.gz (28.0 kB) File type Source Python version None Upload date Hashes View

Supported by

Pingdom Pingdom Monitoring Google Google Object Storage and Download Analytics Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN DigiCert DigiCert EV certificate StatusPage StatusPage Status page