text: I have a situation where I need to enforce and give the user the option of one of a number of select functions, to be passed in as an argument to another function:
  I really want to achieve something like the following:
  from enum import Enum
  #Trivial Function 1
  def functionA():
  pass
  #Trivial Function 2
  def functionB():
  pass
  #This is not allowed (as far as i can tell the values should be integers)
  #But pseudocode for what I am after
  class AvailableFunctions(Enum):
  OptionA = functionA
  OptionB = functionB
  def myUserFunction(theFunction = AvailableFunctions.OptionA):
  #Type Check
  assert isinstance(theFunction,AvailableFunctions)
  #Execute the actual function held as value in the enum or equivalent
  return theFunction.value()
  Your assumption is wrong. Values can be arbitrary, they are not limited to integers. From the documentation:.
  However the issue with functions is that they are considered to be method definitions instead of attributes!
  In [1]: from enum import Enum In [2]: def f(self, *args): ...: pass ...: In [3]: class MyEnum(Enum): ...: a = f ...: def b(self, *args): ...: print(self, args) ...: In [4]: list(MyEnum) # it has no values Out[4]: [] In [5]: MyEnum.a Out[5]: <function __main__.f> In [6]: MyEnum.b Out[6]: <function __main__.MyEnum.b>
  You can work around this by using a wrapper class or just
  functools.partial:
  from functools import partial class MyEnum(Enum): OptionA = partial(functionA) OptionB = partial(functionB)
  Sample run:
  In [7]: from functools import partial In [8]: class MyEnum2(Enum): ...: a = partial(f) ...: def b(self, *args): ...: print(self, args) ...: In [9]: list(MyEnum2) Out[9]: [<MyEnum2.a: functools.partial(<function f at 0x7f4130f9aae8>)>] In [10]: MyEnum2.a Out[10]: <MyEnum2.a: functools.partial(<function f at 0x7f4130f9aae8>)>
  Or using a wrapper class:
  In [13]: class Wrapper: ...: def __init__(self, f): ...: self.f = f ...: def __call__(self, *args, **kwargs): ...: return self.f(*args, **kwargs) ...: In [14]: class MyEnum3(Enum): ...: a = Wrapper(f) ...: In [15]: list(MyEnum3) Out[15]: [<MyEnum3.a: <__main__.Wrapper object at 0x7f413075b358>>]
  Also note that if you want you can define the
  __call__ method in your enumeration class to make the values callable:
  In [1]: from enum import Enum In [2]: from functools import partial In [3]: def f(*args): ...: print(args) ...: In [4]: class MyEnum(Enum): ...: a = partial(f) ...: def __call__(self, *args): ...: self.value(*args) ...: In [5]: MyEnum.a(1,2,3) # no need for MyEnum.a.value(1,2,3) (1, 2, 3)