pleasant-promises 1.1

Description:

pleasantpromises 1.1

Pleasant python promises
pip install pleasant-promises

Python promises are a thing, really! But they get ugly quickly. This package lets you handle promises using generator syntax.
Here's what using 3 sequential promises looks like without this package:
def resolve_greatgrandparent(person,info):
parent_prom = person_loader.load(person.parent_id)
def handle_parent(parent):
grandparent_prom = person_loader.load(parent.parent_id)

def handle_grandparent(grandparent):
return person_loader.load(grandparent.parent_id)

return grandparent_prom.then(handle_grandparent)

return parent_prom.then(handle_parent)

And now with this package,
from pleasant_promises import genfunc_to_prom

@genfunc_to_prom
def resolve_greatgrandparent_name(person,info):
parent = yield person_loader.load(person.parent_id)
grandparent = yield person_loader.load(parent.parent_id)
great_grandparent = yield person_loader.load(grandparent.parent_id)
return great_grandparent

Usage with Graphql/Graphene
If you're using promises, you're probably also using graphene or at least graphql. There are a few other helpers in here to help with your graphql schema,
Dataloaders
This package has a useful subclass wrapper of the promise package's Dataloader. You can overload its batch_load method with a generator function. This is useful if you want call another dataloader within batch_load. This class will also convert non-promise values to promises, which is required by the API we're wrapping.
from pleasant_promises.dataloader import Dataloader

class GrandparentLoader(DataLoader):
def batch_load(self,keys):
parents = yield person_loader.load_many(keys)
grandparents = yield person_loader.load_many(parent.parent_id for parent in parents)
# ...

You'll still have to decorate other dataloader methods with @genfunc_to_prom, though:
from pleasant_promises import genfunc_to_prom

class GrandparentLoader(DataLoader):
@genfunc_to_prom
def get_grandparent_for_single_key(self,key):
parent = yield person_loader.load(key)
grandparent = yield person_loader.load(parent.parent_id)
return grandparent

def batch_load(self,keys):
return Promise.all([self.get_grandparent_for_single_key(key) for key in keys])

Graphene middleware
Without the middleware, you'll have to decorate all your resolvers that want to use the generator syntax.
from pleasant_promises import genfunc_to_prom

class MyPersonType(graphene.ObjectType):
# ...
@genfunc_to_prom
def resolve_grandparent(self,info):
parent = yield person_loader.load(person.parent_id)
grandparent = yield person_loader.load(parent.parent_id)
return grandparent

To avoid repeating this decorator on all your resolvers, use our pleasant middleware
from pleasant_promises.graphene import promised_generator_middleware


my_graphene_schema.execute('THE QUERY', middleware=[promised_generator_middleware])