No celery, no python, just pure multiprocessing goodness.

Use base PyPI tooling. While Poetry is really neat, we'll stick with the simplest approach.

https://github.com/inglesp/async-requests

Conditions:

• Python 3.3 with asyncio installed
• Python>=3.4

Notes:

• Will have to split up requirement files
• Will have to put more logic into setup.py

Support could be added either directly or by ensuring it's easy for a third party package to extend webhooks with this functionality.

Some uses of webhooks may allow for multiple senders with different permissions or handle sensitive data that needs to be verified to be both accurate and authenticated.

One solution to this problem is HMAC which uses a shared secret key and is already implemented in the Python Standard Library:
https://docs.python.org/3.4/library/hmac.html

As a point of comparison, you can see how the financial service Dwolla uses HMAC for their webhooks:
https://developers.dwolla.com/dev/pages/webhooks

All Django specific code should go in webhooks/django. Need to:

1. Create webhooks with URLs, event names, and creator in the admin
2. Track the result of pushing webhooks
3. Set/track how many times things are attempted.
4. Potentially provide hooks for async behavior

Hi,
I just found a small issue when I tried to use async_redis.sender function

senderobj = Senderable(
    wrapped, dkwargs, hash_value, ATTEMPTS, *args, **kwargs
)

# connection = value_in("url", dkwargs, kwargs)  # url params should be set to senderobj.url
senderobj.url = value_in("url", dkwargs, kwargs)
connection = value_in("connection", dkwargs, kwargs)

@job('default', connection=connection)
def worker(senderobj):

    return senderobj.send()

return worker(senderobj)

I think the above code might be an issue to use async sender. If I'm wrong, please correct me. Thanks.

Options under consideration. I think I need to confirm each is thread-safe.

• stdlib asyncio - Do I want to dig into this much low level code?
• aiohttp
• HTTPX - I lean toward this because it supports my use cases and the API is simple

Hi pydanny :). This line in base.py overrides the configured logging settings. Could you remove this line, as logging should be setup elsewhere in the consumer web application? Thanks!

It would be awesome if we could leverage in modern serverless functions as an option to handle asynchronous sendings.

• Convert all files
• Confirm they actually render. Pandoc is awesome but isnt perfect

Rather than use decorators on functions, allow users to implement via classes.

Sample API that I'm not happy with so I'm still thinking about it

class Basic(BaseWebhook):

    def send(wife: Object, husband: Object):
        return {"husband": husband, "wife": wife}

    def recorder(self):
        # Call out to persistence

basic = Basic(url, encoding, timeout, custom_headers, signing_secret)
basic.send(husband, wife)

Objectives:

• type hints for clarity and reduction of docs
• Base class shouldn't be the stock implementation
• Should be obvious in design so others can easily create senders in order to solve their needs

GH actions is an excellent replacement for Travis

Currently our HTTP tests are all functional. Add pure unit tests using https://github.com/dropbox/responses

Objectives for new design

The current design is ungainly in places, let's improve on it!

Old API

Problems:

1. Long argument names
2. url, encoding, timeout, custom_headers, and signing secret added to request/response by the decorator. What's a better way to do it?

>>> @webhook(sender_callable=targeted.sender, hash_function=uuid.uuid4)
>>> def basic(wife, husband, url, encoding, timeout, custom_headers, signing_secret):
>>>     return {"husband": husband, "wife": wife}

New API

Objectives:

1. Shorten argument names for ease of use
2. Add a recorder decorator argument so implementors can save results to logs, db, or whatever they way
3. TODO Try to find a better way to add url, encoding, timeout, custom_headers, and signing_secret to requests

>>> import uuid
>>> from webhook import webhook
>>> from mystff import sender_func, save_to_db
>>>
>>> @webhook(sender=sender_func, hasher=uuid.uuid4, recorder=save_to_db)
>>> async def basic(wife, husband, url, encoding, timeout, custom_headers, signing_secret):
>>>     # I'm not happy with how arguments are managed right now, still thinking about it
>>>     return {"husband": husband, "wife": wife}
>>> await basic(...args here)

Lines 25-26 of encoders.py don't appear to be working:

            if r.endswith('+00:00'):
                r = r[:-6] + 'Z'

See failing test test_json_encoder_time_tzinfo_gmt() in commit 0c6f487.

When this project began, https://docs.python.org/3/library/functools.html#functools.cached_property wasn't in the stdlib.

This means this library must support Python 3.8 or higher