5

Short, but complete, summary

I want to allow users of my function (a class factory) to inject/overwrite global imports when using my function (longer explanation of rationale below). But there are about 10 different variables that could be passed in and it adds a number of very repetitive lines to the code. (granted, also makes it more complicated to call too :P) Right now, I'm doing something like the following (just simplifying all of this). To make it runnable, I'm using a dummy class, but in the actual script I'd be using import pkg1, etc. Figured this was clearer and shorter than a class factory, etc.

class Dummy(object): pass

pkg1, pkg2 = Dummy(), Dummy()
pkg1.average = lambda *args : sum(args) / len(args)
pkg2.get_lengths = lambda *args : map(len, args)


def get_average(*args, **kwargs):
    average = kwargs.get("average") or pkg1.average
    get_lengths = kwargs.get("get_lengths") or pkg2.get_lengths
    return average(*get_lengths(*args))

adjusted_length = lambda *args: map(len, args) + [15]
print get_average([1,2], [10, 4, 5, 6]) == 3 # True
print get_average([1,2], [10, 4, 5, 6], get_lengths=adjusted_length) == 7 # True

Related SO questions

This stack overflow post: Modifying locals in Python, seemed particularly relevant and initially I wanted to just overwrite locals by storing to the locals dictionary but (1) it didn't seem to work, and (2) it seems like it was a bad idea. So, I'm wondering if there's another way to do it.

This one looked promising ( Adding an object to another module's globals in python ), but I'm not really sure how to access the globals for the current file in the same way as a module. (and this question - python: mutating `globals` to dynamically put things in scope - doesn't really apply, since I'm (ultimately) using this to define classes).

I guess I could wrap everything in an exec statement (like this post - globals and locals in python exec() ), but that's both fiddly and means that it's much harder to do error checking/linting/etc.

So here's what I'd like to do. (NOTE: I would have used from pkg1 import average AND from pkg2 import get_lengths but I wanted the example to be clearer (need to copy pkg1 and pkg2 above to run this))

average = pkg1.average
get_lengths = pkg2.get_lengths

def get_average(*args, **kwargs):
    localvars = locals()
    for k in ("get_lengths", "average"):
        if kwargs.get(k, None) and kwargs[k] is not None:
            localvars[k] = kwargs[k]
    return average(*get_lengths(*args))

print get_average([1,2], [10, 4, 5, 6]) == 3 #True
print get_average([1,2], [10, 4, 5, 6], get_lengths=adjusted_length) == 7 # False, is 3

Rationale for my specific use-case

Right now, I'm trying to write a dynamically-generated class factory (to use as an SQLAlchemy mixin), but I want to allow users of my class to pass in alternate constructors, so they can use SQLAlchemy adapters, etc.

For example, Flask-SQLAlchemy provides the same interface as SQLAlchemy, but provides a custom object/class (db) that wraps around all the SQLAlchemy objects to provide more features.

Community
  • 1
  • 1
Jeff Tratner
  • 16,270
  • 4
  • 47
  • 67
  • And here's a gist showing the same example but with a class factory (it's a bit more complicated to read, so I didn't use it in the post): https://gist.github.com/3203215 – Jeff Tratner Jul 30 '12 at 01:39

1 Answers1

2

You could use arguments with default values to pass functions in. This is effectively what you are doing but cleaner. I've used lists as a single argument instead of *args because it is easier to deal with when you have other arguments. You'll have to enclose your lists in a tuple to pass them in to get_average.

The builtin function sorted works like this so it should be easy for Python programmers to understand.

get_average(lists, average=pkg1.average, get_lengths=pkg2.get_lengths):
    return average(*get_lengths(*lists))

print get_average(([1,2], [10, 4, 5, 6]))
print get_average(([1,2], [10, 4, 5, 6]), get_lengths=adjusted_length)

If you have many keyword arguments you could package them in an object:

class GetAverageContext(object):
    def __init__(self, average=pkg1.average, get_lengths=pkg2.get_lengths):
        self.average = average
        self.get_lengths = get_lengths

DefaultGetAverageContext = GetAverageContext()

def get_average(lists, context=DefaultGetAverageContext):
    return context.average(*context.get_lengths(*lists))
Peter Graham
  • 11,323
  • 7
  • 40
  • 42
  • Good points. on using default values - I thought of that, and that's a reasonable alternative, but it still ends up with (in my case) 10 keyword arguments, which gets a bit long. On the other hand, it makes it explicit exactly what you should pass in the use the function. On using lists, while I agree that with the function I posted that would be a better way to do it, that was an artifact from the class factory (since the `__init__` method of the class takes in `(self, *args, **kwargs)` and doesn't use any keyword arguments (just for mro/super compatibility)) – Jeff Tratner Jul 30 '12 at 01:53
  • @Jeff Tranter: I think using `**kwargs` doesn't improve things. You have to document all the keyword arguments somewhere anyway. If you have many keyword arguments you can package them up in an object instead. I've edited my answer with an example. – Peter Graham Jul 30 '12 at 02:13
  • frankly, after I read your first answer, I realized you had the right idea (especially because makes the doc for the function more descriptive). Good idea with the object though. – Jeff Tratner Jul 30 '12 at 03:08