notebook toolbar

Activate

index execution_count cell_type toolbar started_at completed_at source loc metadata outputs

index	execution_count	cell_type	source	loc	metadata	outputs
1	In	markdown	# fumbling around with `pluggy` https://pluggy.readthedocs.io/ * register/unregister plugins * define specs and implementations at the same time. # fumbling around with `pluggy` https://pluggy.readthedocs.io/ * register/unregister plugins * define specs and implementations at the same time.	`{'data': {'text/html': 'fumbling around with \nhttps://pluggy.readthedocs.io/ \n\nregister/unregister plugins \ndefine specs and implementations at the same time. \n\n'}}`	6	fumbling around with https://pluggy.readthedocs.io/ register/unregister plugins define specs and implementations at the same time.
2	In 1	code	import pluggy `import pluggy`	`{}`	1	0 outputs.
3	In	markdown	we're going to think about a sample `PROG`ram that has an interface. we're going to think about a sample `PROG`ram that has an interface.	`{'data': {'text/html': "we're going to think about a sample PROGram that has an interface.\n"}}`	1	we're going to think about a sample `PROG` ram that has an interface.
4	In 2	code	PROG = "sample-program" `PROG = "sample-program"`	`{}`	1	0 outputs.
5	In	markdown	the `specification` decorates the functions and signatures of our interface. the `implementation` uses the `specification` for consistency when it actually defines computational work. the `specification` decorates the functions and signatures of our interface. the `implementation` uses the `specification` for consistency when it actually defines computational work.	`{'data': {'text/html': 'the specification decorates the functions and signatures of our interface.\nthe implementation uses the specification for consistency when it actually defines computational work.\n'}}`	2	the `specification` decorates the functions and signatures of our interface. the `implementation` uses the `specification` for consistency when it actually defines computational work.
6	In 3	code	implementation, specification = pluggy.HookimplMarker(PROG), pluggy.HookspecMarker(PROG) `implementation, specification = pluggy.HookimplMarker(PROG), pluggy.HookspecMarker(PROG)`	`{}`	1	0 outputs.
7	In	markdown	`PROG`s `specification` for `my_plugin` provides a default interface. `PROG`s `specification` for `my_plugin` provides a default interface.	`{'data': {'text/html': 'PROGs specification for my_plugin provides a default interface.\n'}}`	1	`PROG` s `specification` for `my_plugin` provides a default interface.
8	In 4	code	@implementation @specification(firstresult=False) def my_plugin(a, b, c): return "".join(map(str, (a,b,c))) `@implementation @specification(firstresult=False) def my_plugin(a, b, c): return "".join(map(str, (a,b,c)))`	`{}`	3	0 outputs.
9	In	markdown	we register the `specifaction` onto a plugin `manager` we register the `specifaction` onto a plugin `manager`	`{'data': {'text/html': 'we register the specifaction onto a plugin manager\n'}}`	1	we register the `specifaction` onto a plugin `manager`
10	In 5	code	manager = pluggy.PluginManager(PROG) `manager = pluggy.PluginManager(PROG)`	`{}`	1	0 outputs.
11	In	markdown	our `specification` lives in the `import __main__` or `MAIN` namespace. our `specification` lives in the `import __main__` or `MAIN` namespace.	`{'data': {'text/html': 'our specification lives in the import __main__ or MAIN namespace.\n'}}`	1	our `specification` lives in the `import __main__` or `MAIN` namespace.
12	In 6	code	manager.add_hookspecs(__main__ := __import__(__name__)) assert "my_plugin" in dir(manager.hook), "the plugin is registered" `manager.add_hookspecs(__main__ := __import__(__name__)) assert "my_plugin" in dir(manager.hook), "the plugin is registered"`	`{}`	2	0 outputs.
13	In	markdown	now we can add our `implementation` of `my_plugin` in the `__main__` module now we can add our `implementation` of `my_plugin` in the `__main__` module	`{'data': {'text/html': 'now we can add our implementation of my_plugin in the __main__ module\n'}}`	1	now we can add our `implementation` of `my_plugin` in the `__main__` module
14	In 7	code	manager.register(__main__); `manager.register(__main__);`	`{}`	1	0 outputs.
15	In	markdown	now we can execute our `manager.hook.my_plugin` method now we can execute our `manager.hook.my_plugin` method	`{'data': {'text/html': 'now we can execute our manager.hook.my_plugin method\n'}}`	1	now we can execute our `manager.hook.my_plugin` method
16	In 8	code	manager.hook.my_plugin(a=10, b=20, c=30) `manager.hook.my_plugin(a=10, b=20, c=30)`	`{}`	1	1 outputs. ['102030']
17	In	markdown	let's add another implementation. we can't name it `my_plugin` otherwise we'll lose the scope of our previous method. here we name our method whatever we want and explicitly define the `implementation:specname` it refers to. let's add another implementation. we can't name it `my_plugin` otherwise we'll lose the scope of our previous method. here we name our method whatever we want and explicitly define the `implementation:specname` it refers to.	`{'data': {'text/html': "let's add another implementation. we can't name it my_plugin otherwise we'll lose the scope of our previous method. here we name our method whatever we want and explicitly define the implementation:specname it refers to.\n"}}`	1	let's add another implementation. we can't name it `my_plugin` otherwise we'll lose the scope of our previous method. here we name our method whatever we want and explicitly define the `implementation:specname` it refers to.
18	In 9	code	@implementation(specname="my_plugin") def another_plugin(a, b): return (a, b) `@implementation(specname="my_plugin") def another_plugin(a, b): return (a, b)`	`{}`	2	0 outputs.
19	In	markdown	now seems like a good time test what `async` functions do now seems like a good time test what `async` functions do	`{'data': {'text/html': 'now seems like a good time test what async functions do\n'}}`	1	now seems like a good time test what `async` functions do
20	In 10	code	@implementation(specname="my_plugin", trylast=True) async def async_my_plugin(a, b): return (a, b) `@implementation(specname="my_plugin", trylast=True) async def async_my_plugin(a, b): return (a, b)`	`{}`	2	0 outputs.
21	In	markdown	reregistering the `__main__` gives an error because `pluggy` doesn't allow someone register the module twice reregistering the `__main__` gives an error because `pluggy` doesn't allow someone register the module twice	`{'data': {'text/html': "reregistering the __main__ gives an error because pluggy doesn't allow someone register the module twice\n"}}`	1	reregistering the `__main__` gives an error because `pluggy` doesn't allow someone register the module twice
22	In 11	code	try: manager.register(__main__); assert False, "can't register the module twice" except ValueError: assert True `try: manager.register(__main__); assert False, "can't register the module twice" except ValueError: assert True`	`{}`	2	0 outputs.
23	In	markdown	the proper registration requires we unregister the module first. `the proper registration requires we unregister the module first.`	`{'data': {'text/html': 'the proper registration requires we unregister the module first.\n'}}`	1	the proper registration requires we unregister the module first.
24	In 12	code	manager.unregister(__main__) manager.register(__main__); `manager.unregister(__main__) manager.register(__main__);`	`{}`	2	0 outputs.
25	In	markdown	now our invocation finds both implementations. `now our invocation finds both implementations.`	`{'data': {'text/html': 'now our invocation finds both implementations.\n'}}`	1	now our invocation finds both implementations.
26	In 13	code	(results := manager.hook.my_plugin(a=10, b=20, c=30)) `(results := manager.hook.my_plugin(a=10, b=20, c=30))`	`{}`	1	1 outputs. ['102030', (10, 20), <coroutine object async_my_plugin at 0x7feab0168040>]
27	In	markdown	`async_my_plugin` evaluates to a coroutine that we'd have to handle properly. `async_my_plugin` evaluates to a coroutine that we'd have to handle properly.	`{'data': {'text/html': "async_my_plugin evaluates to a coroutine that we'd have to handle properly.\n"}}`	1	`async_my_plugin` evaluates to a coroutine that we'd have to handle properly.
28	In 14	code	assert __import__("inspect").iscoroutine(results[-1]) `assert __import__("inspect").iscoroutine(results[-1])`	`{}`	1	0 outputs.

markdown

# fumbling around with `pluggy`

https://pluggy.readthedocs.io/

* register/unregister plugins
* define specs and implementations at the same time.

# fumbling around with `pluggy`

https://pluggy.readthedocs.io/

* register/unregister plugins
* define specs and implementations at the same time.


        {'data': {'text/html': 'fumbling around with 
\nhttps://pluggy.readthedocs.io/
\n\nregister/unregister plugins
\ndefine specs and implementations at the same time.
\n\n'}}

fumbling around with

https://pluggy.readthedocs.io/

register/unregister plugins
define specs and implementations at the same time.

In 1

code

    import pluggy

    import pluggy

markdown

we're going to think about a sample `PROG`ram that has an interface.

we're going to think about a sample `PROG`ram that has an interface.

we're going to think about a sample PROG ram that has an interface.

In 2

code

    PROG = "sample-program"

    PROG = "sample-program"

markdown

the `specification` decorates the functions and signatures of our interface.
the `implementation` uses the `specification` for consistency when it actually defines computational work.

the `specification` decorates the functions and signatures of our interface.
the `implementation` uses the `specification` for consistency when it actually defines computational work.


        {'data': {'text/html': 'the specification decorates the functions and signatures of our interface.\nthe implementation uses the specification for consistency when it actually defines computational work.\n'}}

the specification decorates the functions and signatures of our interface. the implementation uses the specification for consistency when it actually defines computational work.

In 3

code

    implementation, specification = pluggy.HookimplMarker(PROG), pluggy.HookspecMarker(PROG)

    implementation, specification = pluggy.HookimplMarker(PROG), pluggy.HookspecMarker(PROG)

markdown

`PROG`s `specification` for `my_plugin` provides a default interface.

`PROG`s `specification` for `my_plugin` provides a default interface.

PROG s specification for my_plugin provides a default interface.

In 4

code

    @implementation
    @specification(firstresult=False)
    def my_plugin(a, b, c): return "".join(map(str, (a,b,c)))

    @implementation
    @specification(firstresult=False)
    def my_plugin(a, b, c): return "".join(map(str, (a,b,c)))

markdown

we register the `specifaction` onto a plugin `manager`

we register the `specifaction` onto a plugin `manager`

we register the specifaction onto a plugin manager

In 5

code

    manager = pluggy.PluginManager(PROG)

    manager = pluggy.PluginManager(PROG)

markdown

our `specification` lives in the `import __main__` or `MAIN` namespace.

our `specification` lives in the `import __main__` or `MAIN` namespace.

our specification lives in the import __main__ or MAIN namespace.

In 6

code

    manager.add_hookspecs(__main__ := __import__(__name__))
    assert "my_plugin" in dir(manager.hook), "the plugin is registered"

    manager.add_hookspecs(__main__ := __import__(__name__))
    assert "my_plugin" in dir(manager.hook), "the plugin is registered"

markdown

now we can add our `implementation` of `my_plugin` in the `__main__` module

now we can add our `implementation` of `my_plugin` in the `__main__` module

now we can add our implementation of my_plugin in the __main__ module

In 7

code

    manager.register(__main__);

    manager.register(__main__);

markdown

now we can execute our `manager.hook.my_plugin` method

now we can execute our `manager.hook.my_plugin` method

now we can execute our manager.hook.my_plugin method

In 8

code

    manager.hook.my_plugin(a=10, b=20, c=30)

    manager.hook.my_plugin(a=10, b=20, c=30)

['102030']

markdown

let's add another implementation. we can't name it `my_plugin` otherwise we'll lose the scope of our previous method.  here we name our method whatever we want and explicitly define the `implementation:specname` it refers to.

let's add another implementation. we can't name it `my_plugin` otherwise we'll lose the scope of our previous method.  here we name our method whatever we want and explicitly define the `implementation:specname` it refers to.


        {'data': {'text/html': "let's add another implementation. we can't name it my_plugin otherwise we'll lose the scope of our previous method.  here we name our method whatever we want and explicitly define the implementation:specname it refers to.\n"}}

let's add another implementation. we can't name it my_plugin otherwise we'll lose the scope of our previous method. here we name our method whatever we want and explicitly define the implementation:specname it refers to.

In 9

code

    @implementation(specname="my_plugin")
    def another_plugin(a, b): return (a, b)

    @implementation(specname="my_plugin")
    def another_plugin(a, b): return (a, b)

markdown

now seems like a good time test what `async` functions do

now seems like a good time test what `async` functions do

now seems like a good time test what async functions do

In 10

code

    @implementation(specname="my_plugin", trylast=True)
    async def async_my_plugin(a, b): return (a, b)

    @implementation(specname="my_plugin", trylast=True)
    async def async_my_plugin(a, b): return (a, b)

markdown

reregistering the `__main__` gives an error because `pluggy` doesn't allow someone register the module twice

reregistering the `__main__` gives an error because `pluggy` doesn't allow someone register the module twice


        {'data': {'text/html': "reregistering the __main__ gives an error because pluggy doesn't allow someone register the module twice\n"}}

reregistering the __main__ gives an error because pluggy doesn't allow someone register the module twice

In 11

code

    try: manager.register(__main__); assert False, "can't register the module twice"
    except ValueError: assert True

    try: manager.register(__main__); assert False, "can't register the module twice"
    except ValueError: assert True

markdown

the proper registration requires we unregister the module first.

the proper registration requires we unregister the module first.

the proper registration requires we unregister the module first.

In 12

code

    manager.unregister(__main__)
    manager.register(__main__);

    manager.unregister(__main__)
    manager.register(__main__);

markdown

now our invocation finds both implementations.

now our invocation finds both implementations.

now our invocation finds both implementations.

In 13

code

    (results := manager.hook.my_plugin(a=10, b=20, c=30))

    (results := manager.hook.my_plugin(a=10, b=20, c=30))

['102030', (10, 20), <coroutine object async_my_plugin at 0x7feab0168040>]

markdown

`async_my_plugin` evaluates to a coroutine that we'd have to handle properly.

`async_my_plugin` evaluates to a coroutine that we'd have to handle properly.

async_my_plugin evaluates to a coroutine that we'd have to handle properly.

In 14

code

    assert __import__("inspect").iscoroutine(results[-1])

    assert __import__("inspect").iscoroutine(results[-1])