The gossip from getslash

Add argument type checking for strict hooks

Is it possible to use hooks on methods in a class?

Is it possible to use hooks on methods in a class? E.g.:

import gossip


class Foo:
    def trigger(self):
        gossip.trigger('this_hook')

    @gossip.register('this_hook')
    def triggered_by_hook(self):
        print('triggered_by_hook')


foo = Foo()
foo.trigger()

Check triggered tags for correctness when the hook is set to strict

Add support for registration blueprints

Optimize Group.unregister_token()

There is currently TODO in the code for optimazing Group.unregister_token() method.

gossip/gossip/groups.py

Line 130 in 5a09968

# todo: optimize this

(The comment will be removed from the code in my next PR).

Support contextbacks

The usage should be something like:

operation_context = gossip.define_contextback('name', args=(...), tags=..., ....)

And then for registration

@operation_context.register
@contextmanager
def my_contextmanager(arg1, arg2):
     ...
     yield
     ....

Gossip ignore define_hook kwargs if the hook was registered before

Reproduction code:

import gossip

@gossip.register('hook_a')
def foo(**kwargs):
    pass

gossip.define('hook_a', tags=('my', 'tags'), arg_names=('x', 'y'))
gossip.define('hook_b', tags=('my', 'tags'), arg_names=('z', 'y'))

@gossip.register('hook_b')
def bar(**kwargs):
    pass

for hook in gossip.get_all_hooks():
  print(f'Hook: {hook.full_name}, tags: {hook.tags}, arguments: {hook.get_argument_names()}')

The output:

Hook: hook_a, tags: ('my', 'tags'), arguments: ()
Hook: hook_b, tags: ('my', 'tags'), arguments: ('z', 'y')

hook_b is as expected, but hook_a should add x & y as arguments

gossip.unregister_token does not work as expected

The following code fails on AssertionError:

import gossip

@gossip.register('a.b', token='token')
def foo():
    pass

gossip.unregister_token('token')
assert not gossip.get_all_registrations()  # <= Raise AssertionError

Allow defining hooks as non-reentrant

This would make the hook recursion resistant, meaning that it cannot be triggered while its trigger is handled.

Allow unregister token from a hook

Currently unregistering by token in the middle of a hook trigger causes hooks to be skipped

Add needs/provides mechanism for fine grained control of dependencies

Gossip allows defining hook with empty-string name

In [1]: import gossip

In [2]: gossip.define("")
Out[2]: <Hook ()>

Using gossip for objectmethods

how can I use gossip for objectmethods

>>> import gossip
>>> class MyClass(object):
...     def trigger(self):
...         gossip.trigger('my_hook')
...     @gossip.register('my_hook')
...     def my_func(self):
...         print 42
... 
>>> my_object = MyClass()
>>> my_object.trigger()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in trigger
  File "/home/eli/qa/.venv/local/lib/python2.7/site-packages/gossip/hooks.py", line 189, in trigger
    trigger_with_tags(hook_name, kwargs, None)
  File "/home/eli/qa/.venv/local/lib/python2.7/site-packages/gossip/hooks.py", line 199, in trigger_with_tags
    hook.trigger(kwargs or {}, tags)
  File "/home/eli/qa/.venv/local/lib/python2.7/site-packages/gossip/hooks.py", line 152, in trigger
    exception_policy.handle_exception(ctx, exc_info)
  File "/home/eli/qa/.venv/local/lib/python2.7/site-packages/gossip/exception_policy.py", line 29, in handle_exception
    reraise(exc_info[0], exc_info[1], exc_info[2])
  File "/home/eli/qa/.venv/local/lib/python2.7/site-packages/gossip/hooks.py", line 169, in _call_registration
    registration(**kwargs)  # pylint: disable=star-args
  File "/home/eli/qa/.venv/local/lib/python2.7/site-packages/gossip/registration.py", line 70, in __call__
    return self.func(*args, **kwargs)
TypeError: my_func() takes exactly 1 argument (0 given)

since the self parameter is not sent

Can you gossip python-gossip detail usage?

Thanks YOU

Adding registration context

The code of hook registration for specific code block looks not elegant.
Currently there are two options for doing it:

hook = gossip.get_hook('my_hook')
reg = hook.register(func)
... # Code block
reg.unregister

or

goossip.register(func, 'my_hook', token='some_token')
... # Code block
gossip.unregister_token('some_token')

It would be nice to have:

with gossip.registrated(fun, 'my_hook'):
    ... # Code block

Better description for registrations on exception logs

For example, raising an exception in a registration yields something like this:

[2014-06-16 15:16] WARNING: gossip.hooks: Exception occurred while calling <gossip.registration.Registration object at 0x7f66e37e8d50>

It would be better to attempt and describe the actual registration name (function/object)

Add option to make groups non-strict

Add per-registration hook for handling and possibly swallowing errors

Support registration of coroutines

In several cases it is necessary to register hooks in pairs (e.g. start/end or before/after of events). In some of these cases it is necessary to ensure that the "closing" hook isn't called unless the "hook" was called. This is particularly useful for plugin systems.

This feature will enable registering like this:

from gossip import Toggle

_toggle = Toggle()
@gossip.register(toggle_on=_toggle)
def before():
   ...

@gossip.register(toggle_off=_toggle)
def after():
   ...

drop python2 and python3 <=3.5 support

Add sphinx extension for listing hooks

Every project which uses gossip, should have its own implementation for listing the gossip hooks it supports.

It would be nice to have a sphinx extension which listing all the hooks of a specific gossip group for documentation.

Support passing callable to register which allow to dynamically enable/disable the registration

We have a package that registers for many (different) gossip hooks.
Our package has a "disabling" context. We need a way to disable all our registrations during the context and re-enable them afterward.

Register pre-defined hook with arguments

Hi Rotem,

Thanks for developing Gossip. I love it!
I'm currently using it as part of a framework I'm writing, so I'm pre-defining a lot of hooks I use in different places. I always store the hook object and use it directly for registration (to have the hook name defined in only one place), but I'm hitting a wall when using arguments with these objects. I'm using strict groups.

# Works fine
myhook = gossip.define("mygroup.testhook", arg_names=["some_arg"])

@myhook.register
def some_function(some_arg):
    pass

# Does not work: 
myhook = gossip.define("mygroup.testhook", arg_names=["some_arg"], tags=["test"])

@myhook.register(tags=["test"])
def some_function(some_arg):
    pass

I always end up with the following
TypeError: register() takes at least 2 arguments (2 given)

Do I need to wrap the register() call to get the functionality I want?

Cheers!
Tim

Add hook.register_no_op to allow "logical" registrations without any actual function being called

Originated by getslash/slash#490

Add option to globally mute hooks in a context

Hook priority/weight

Hello. Great job on this library! Very feature rich and easy to use.

I'm wondering if there's a way of specifying priority or weights when registering hooks. The provides/needs capabilities are not quite what I'm looking for. Glancing at the source code it seems there isn't a way of doing this in gossip, but maybe someone knows of a work-around?

This, and collecting all hook return values, are the only two things stopping me from completely ditching the blinker library.

getslash / gossip Goto Github PK

gossip's People

Contributors

Stargazers

Watchers

Forkers

gossip's Issues

Recommend Projects

Recommend Topics

Recommend Org