Python - Getting subclass from input. Do I have to write a separate function?

Question

I'm working in Python 2.7.8. What follows is a slight variant of the problem I'm working on.

I have a large number of custom classes that I've written where the inheritance is like a tree. The behavior is well encapsulated by the following example:

import random

class Animal(object):
    def __init__(self, name):
        self.name = name
        self.can_own_pets = False #most Animals cannot own pets
        self.get_features()

    def give_pet(self, pet):
        if not self.can_own_pets:
            print(self.name+' cannot own a pet!')
        else:
            self.pets.append(pet)

    def is_hungry(self):
        return random.choice([True, False])

    def get_features(self):
        """
        In some classes, get features will be a function
        that uses self.name to extract features.
        In my problem, the features are extracted
        with regular expressions that are determined by
        by the class.
        """
        pass

class Human(Animal):
    def __init__(self, name):
        super(Human, self).__init__(name)
        self.can_own_pets = True
        self.pets = []

class Dog(Animal):
     def __init__(self, name):
        super(Dog, self).__init__(name)

     def bark(self):
         print 'WOOF'

     def get_features(self):
         if 'chihuahua' in self.name:
             self.is_annoying = True
         elif 'corgi' in self.name:
             self.adorable = True

My program needs to take in a large number of animals and delegate them to the correct classes -- I need the correct attributes and methods. What I would like to do is modify the Animal constructor so that if the name argument is something like "Finn the Dog" or "Jake the Human", it (the constructor) returns an instance of the class "Dog" or "Human", complete with the appropriate methods and attributes. Now, I know that I could easily write a function that takes a string and class as arguments, constructs a dictionary where the keys are the names of the subclasses of the given class, looks up the element of the dictionary that is contained in the string, and returns an object of that class. My question is whether or not there is a way to code this into the Animal class itself, which seems more elegant to me (as well as easier to maintain).

Answer 1

Here's an implementation --

def _get_all_subclasses(cls):
  for scls in cls.__subclasses__():
    yield scls
    for scls in _get_all_subclasses(scls):
      yield scls


class Animal(object):

  @staticmethod
  def from_string(s):
    for cls in _get_all_subclasses(Animal):
      # Somehow pick the class based on the string... This is a really simple example...
      if cls.__name__ in s:
        return cls()
    raise ValueError('Bummer.  Animal has not been discovered.')


class Dog(Animal):
  pass


class Cat(Animal):
  pass


class Lion(Cat):
  pass

print Animal.from_string('is a Dog')
print Animal.from_string('is a Cat')
print Animal.from_string('Lions!!!')
print Animal.from_string('Lockness Monster')

There are limitations here

• All of the constructors need to be pretty much the same which means that Cat.__init__ needs to basically do the same thing that Human.__init__ does.
• After you create the instance, your code needs to have logic to handle Cat, Human, Dog, etc. In some cases that's Ok (e.g. the code really only cares that it is working with an Animal), but frequently it isn't (after all, Cats can walk on fences, but Humans can't).

Generally, the principle that I like to live by is to try to make the inputs to my functions permissive (is it a list or a tuple? Who cares! Duck Typing FTW!) but to try to have really well defined outputs. I think that this makes interfaces easier to use in the long haul and the code that I wrote above would probably not pass a code review if I was the reviewer :-).

Answer 2

To build upon mgilson's answer

You can override the __new__ method so that you can instantiate the classes like normal without a static method.

class Animal(object):

    @classmethod
    def _get_all_subclasses(cls):
        for scls in cls.__subclasses__():
            yield scls
            for scls in scls._get_all_subclasses():
                yield scls

    def __new__(cls, name):
        cls_ = cls
        for subcls in Animal._get_all_subclasses():
            if subcls.__name__ in name:
                cls_ = subcls
                break
        instance = object.__new__(cls_)
        if not issubclass(cls_, cls):
            instance.__init__(name)
        return instance