Provide access to code of providers via pipeline object

[dschick]

In many situations, it is handy to have access to the source of certain providers within a given pipeline in read-only mode.
While the visualize() functionality is already convenient for getting an overview of the pipeline, the internals of the providers are hidden, possibly even in a multilevel module.

I propose a new method which prints the path, docstring, and source of the provider, like:

pipeline = sciline.Pipeline(providers, params=params)
pipeline.prdef(CleanedData) 

where CleanedData is the key to the provider.
Under the hood, one should be able to do all the magic using the inspect python package.

Another maybe more fancy idea is to show the docstring of providers in the TaskGraph as tooltips and maybe the same for type definitions of domain types.

Best

Daniel

[SimonHeybrock]

I would suggest (for now) to simply add Pipeline.__getitem__. The user can then use inspect themselves, e.g., to get the source or the docstring.

We need to think about how to handle parameters. Currently they are wrapped in a lambda, but even if they are not, getting the docstring of a type defined via NewType doesn't really work. I don't know of Python 3.12 type aliases fare any better.

Adding __getitem__ is quite simple, in principle. It would be a thin wrapper around (probably) Pipeline._get_unique_provider.

[SimonHeybrock]

@jl-wynen Does your work in #116 which added the Provider class improve what we can do here? Should __getitem__ return Provider? One could then consider adding convenience methods (Such as docstring access) to Provider.

[jl-wynen]

That was part of the motivation. So, yes, I think we should do

Should getitem return Provider?

And the ProviderLocation class was intended to be extended if we want to access the source code. (I didn't want to name it ProviderSource because it doesn't access the source. But maybe that would be a better name in the end.)

[jl-wynen]

Actually, there is no need to use the ProviderLocation. If we can access the Provider, it can be inspected:

import inspect
import sciline

def inspect_provider(p: sciline.pipeline.Provider):
    print(f'--{p.kind}--')
    if p.kind == 'function':
        print(p.func)
        print(inspect.getsource(p.func))
    elif p.kind == 'parameter':
        print('value:', p.call({}))
    # else:  something internal that should probably not be inspected

def f(x: int) -> str:
    return str(x)

l = lambda: 3.0
l.__annotations__['return'] = float

pl = sciline.Pipeline((f, l), params={int: 2})

inspect_provider(pl._providers[int])
inspect_provider(pl._providers[str])
inspect_provider(pl._providers[float])

Prints

--parameter--
value: 2
--function--
<function f at 0x7f3966d1b0d0>
def f(x: int) -> str:
    return str(x)

--function--
<function <lambda> at 0x7f3966a2dc10>
l = lambda: 3.0

Lambdas are weird...