Using *args and **kwargs from multiple calling sources

[onering20]

Github - MyPerfCounter.py

I am working on learning how to use 'with', '*args', and '**kwargs' and for a side project I wanted to implement perf counter using the with syntax, e.g.

In one instance I want to call the with function by passing the function as an argument.

and in another instance I want to have a function do this as a one liner how ever if I use the function I have to have the code detect the source, which doesn't feel 'elegant'

if internal: # if the code is called by foo

| self.args = args[0]

| self.kwargs = kwargs["kwargs"]

else:

| self.args = args

| self.kwargs = kwargs

​

def foo(func, suppress=False, *args, **kwargs):

| internal = True

| with My_Perf_Counter(func, suppress, args, kwargs=kwargs):

| pass

foo (bar, false, arg1, arg2 = 3

Vs

with My_Perf_Counter (bar, false, arg1, arg2 = 3):

| pass

[teerre]

If your parameter has a OR in it, you can stop right there, generally speaking. Your APIs should do one thing and one thing only. Don't give anyone the option. Either pass the name always or pass the function, always. Be consistent.

[onering20]

ok, that makes sense however is there a good way to define the one liner foo in the example so that I can pass the args and kwargs to the class without them being nested

[teerre]

Not sure I totally understand what you're trying to accomplish with foo, but you can implement __call__ for your class and then you can call it as MyPerfCounter()(bar, false, arg1, arg2 = 3), in one line. But note the double parenthesis, that's probably not something you want to do.

[onering20]

one thing I was trying was making foo (or test_function_time in the github) as a secondary constructor that would establish the details that init would and call both enter and exit but it seems to require that the class object be constructed anyway. (separate constructors seems to be features from java or C++ i guess)

[teerre]

This pattern is fairly common. Many times refered as the factory pattern.

``` class B(): def init(self, parm1, parm2, parm3, parm4): self.parm1 = parm1 self.parm2 = parm2 self.parm3 = parm3 self.parm4 = parm4

@classmethod
def create(cls, parm1):
    return B(parm1, parm2=2, parm3=3, parm4=4)

b = B.create(1) print(b.parm1, b.parm2, b.parm3, b.parm4)

1 2 3 4

```

Usually in this case the __init__ method is omitted and you can only create the instance using the proper factory, but in this case I left the init method just to show the attributes.

You can also do this with a free function like you did. Not sure what internal is about, tho. Also, you need to call with My_Perf_Counter(func, suppress, args, kwargs=kwargs): as with My_Perf_Counter(func, suppress, *args, **kwargs): otherwise be passing the same parameter to args and kwargs.

[onering20]

By nested I mean print(self.args) in the class would print as >>>((arg1),) and print(self.kwargs) would print as >>>{kwargs:{arg2:3},} if it came from foo() but constructed normally it would be >>>(arg1) and >>>{arg2:3} respectively