Running Initializer for Class

Question

I'm not really sure what a good title for this question would be, so i'll explain what I want to do.

I want to have a class, which can be instantiated in some way like so:

class Setting(int):
  def __init__(self, value, description=None):
    super(Setting, self).__init__(value)
    self.description = description

max_memory = Setting(5, description="The maximum memory we can use")

print s + 5 # 10
print s.description # The maximum memory we can use

But then, I'd like this to work for all objects, so I can just have one class. So that I can have the object behave exactly as if it were the same as the underlying value object, but just with the additional description attribute.

I tried changing the above to:

class Setting(object):
  def __init__(self, value, description=None):
    type(value).__init__(value)
    self.description = description

s = Setting(5)

print s + 5
print s.description

But now I get the error:

Traceback (most recent call last):
  File "test.py", line 8, in <module>
    print s + 5
TypeError: unsupported operand type(s) for +: 'Setting' and 'int'

and if I look at dir(self), it does not seem to have run the initialiser for the class of value.

Is it possible to do this?

I know i could just make a few different classes for the different types, but i'd rather only have the one and just have it be generic.

(yes i realise that if the object has a description attribute it would be overwritten, i plan on using this only for the primitives, which is one of the reasons it's a problem in the first place since i can't just add attributes.)

Answer 1

Here's a proof-of-concept of what I think you're trying to accomplish:

def Setting(value, description=None):
  class Internal(type(value)):
      def __new__(self, value, description=None):
          return type(value).__new__(Internal, value)
      def __init__(self, value, description=None):
          super(Internal, self).__init__(value)
          self.description = description
  return Internal(value, description)

s = Setting(5, description="The maximum memory we can use")

print s+10, s.description

v = Setting([1, 2], description="A useful list")

print v+[3], v.description

which emits

15 The maximum memory we can use
[1, 2, 3] A useful list

The core idea is to wrap the class into a factory function -- an "extra level of indirectness" that should help you achieve your desired result.

I call this "a proof of concept", first of all, because it's quite wasteful of memory: a new class object springs up for every call to Setting. The factory function should hold a dict acting as a registry from type(value) to the specific Internal class wrapping it, populating it on the fly -- a typical "memoization" idiom, though here it's used to save memory, not so much running time.

Second, I haven't verified that all special methods behave as desired on a Setting-wrapped "primitive type" (for all "primitive types" of interest, both mutable and immutable) -- offhand it seems like it should work, but nothing but thorough unit-testing can give you confidence here!-)

Answer 2

The built-in repr() of an object is a string. You can modify it with the repr library, but I'm not sure it can be a different type. There are some additional details/ ideas in this SO question.

Answer 3

If I understand you correctly, you want to have types/classes that behave normally like their type, and additionally have a 'description' field. How you go about it is strange - I believe the statement

type(value).__init__(value)

has no effect whatsoever, though I am perplexed why python doesn't throw a warning for this. Surely .init calls within an init should be reserved for super classes.

I would do the following and use s.value instead of s:

class Setting(object):
  def __init__(self, value, description=None):
    self.value = value
    self.description = description

s = Setting(5)

print s.value + 5
print s.description