DI with context manager

[adam-ring]

Is there a good way to have a context manager with one or dependencies? I'm making a framework that includes physical hardware that needs to close resources even if errors are raised. If asked in a more generic sense, how do you call a function for a provider after instantiation?

As a sidebar, is it possible to import opyoid without using the type ignore comment? Without the comment, I get the following mypy error

cxtmngr_di.py:1: error: Skipping analyzing "opyoid": module is installed, but missing library stubs or py.typed marker

from opyoid import Module, Injector  # type: ignore[import]
from types import TracebackType
from typing import TypeVar

T = TypeVar("T", bound='MyHardwareBus')

class MyHardwareBus:
    def __enter__(self: T) -> T:
        print("Opening Bus")
        # self.open_device()
        return self

    def __exit__(self,
        exc_type: type[BaseException] | None,
        exc_val: BaseException | None,
        exc_tb: TracebackType | None,
    ) -> None:
        print("Closing Bus")
        # self.close()

class MyHardwareWidget:
    def __init__(self, bus: MyHardwareBus) -> None:
        self.bus = bus

class MyPhysModule(Module):
    def configure(self) -> None:
        self.bind(MyHardwareBus)
        self.bind(MyHardwareWidget)

inj = Injector([MyPhysModule])
widget = inj.inject(MyHardwareWidget)
with widget.bus as bus:
    print(f"{bus=}, {widget=}")

Output

When run in Python 3.10

$ python3 cxtmngr_di.py 
Opening Bus
bus=<__main__.MyHardwareBus object at 0xb643e550>, widget=<__main__.MyHardwareWidget object at 0xb643ebb0>
Closing Bus

[Aegdesil]

In your example you can define a constructor in MyHardwareBus with its dependencies, is that what you need ?

If you want to instantiate dependencies after the hardware bus has been created, you can inject a Provider directly device_provider: Provider[Device] instead of device: Device and then call device_provider.get() to instantiate the device.

I will fix the mypy warning in the next release.

[adam-ring]

I'm not sure what the best solution is yet for my particular purpose, but your description of a custom scope in the docs has inspired me a bit. My biggest issue is that I need to make sure that the bus is able to close its resource hold regardless of what happens with the widgets. There may be an alternate approach using the device_provider you mentioned above, but I don't have a firm enough mental module opyoid framework to know how to structure it in a natural way.

[Aegdesil]

If your use case is to generate / destroy a new instance when you want (after the bus instantiation), you can inject a Provider, and instantiate / destroy the instance manually with your bus context manager as you did in your example. If you bind the device with an InstanceScope, a new one will be generated every time you call the provider, if you use a SingletonScope (the default) the same instance of the device will get provided every time.

A custom scope will move the context management part in the scope, you can adapt the example to call a destructor on your instances when the provider exits. I think this is better if you want to synchronize the creation / destruction of multiple objects, without having to do it manually for every object.

[adam-ring]

The Bus is the only instance that controls a resource that needs to go through a destruction cycle, but it is a low level class. I will be using multiple types of devices that all point to the same Bus. Other than that, I never touch the Bus manually. It seems like the custom scope might be my best approach here as I don't want to manually instantiate too many devices. Thanks.