Following The DRY Principle

[DecisioNaut]

Tired of repeating yourself when using the TM1Service resource, @onefloid?
I think I remember a conversation we had about this issue...

As Raymond Hettinger uses to shout: "There must be a better way!"
So I just remembered decorators and asked Mr Copilot!

Here's what I got:

Question:
How can I use a decorator for avoiding repeated with statements for using resources?

Answer:
You can create a decorator that handles the opening and closing of resources, such as files, to avoid repeated with statements. Here's an example of how you can modify your code to use such a decorator:

def resource_manager(resource_path):
    def decorator(func):
        def wrapper(*args, **kwargs):
            with open(resource_path) as resource:
                return func(resource, *args, **kwargs)
        return wrapper
    return decorator


@resource_manager('./game/test.py')
def reader(resource):
    return resource.read()


def main():
    print(reader())


if __name__ == '__main__':
    main()

In this example, the resource_manager decorator takes a resource_path argument and opens the resource (in this case, a file) within the wrapper function. The reader function now takes the opened resource as an argument, allowing you to avoid repeating the with statement.

Caution

However, my dear @onefloid, using this naive approach, you won't like it. Now, reader doesn't really know it's input data or types in your code editor anymore. But there's the functools-library coming to your rescue! And so let's ask Copilot again:

Question:
How can I improve this approach using functools?

Answer:
You can use functools.wraps to preserve the metadata of the original function when creating decorators. Here's how you can improve your approach using functools:

import functools

def resource_manager(resource_path):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            with open(resource_path) as resource:
                return func(resource, *args, **kwargs)
        return wrapper
    return decorator


@resource_manager('./game/test.py')
def reader(resource):
    return resource.read()


def main():
    print(reader())


if __name__ == '__main__':
    main()

In this improved version, the resource_manager decorator uses functools.wraps to wrap the func function. This ensures that the metadata of the original function (such as its name and docstring) is preserved. The reader function now takes the opened resource as an argument, allowing you to avoid repeating the with statement.

Hope, this was what you were looking for... At least I think this would be pretty neat.

[DecisioNaut]

... and sorry for flexing, again, with my google and Copilot supported tiny muscles... 😉

[onefloid]

Thanks @DecisioNaut It's planned to rewrite these parts. Maybe it will be easier and clearer if we introduce some higher order regular functions, like generic_exists(). Then the commands just handle the parameters and call the generic_* function. With this approach, we can also significantly reduce the duplicate connections and provide some basic logging functions without repeating ourselves.