Mixin Classes

Hi, thanks for this exellent video. Do you mind explaining this section of the code..

    def _represent(self, value):
        if isinstance(value, object):
            if hasattr(value, 'to_dict'):
                return value.to_dict()
            else:
                return str(value)
        else:
            return value

I am also interested in understanding this code. Can you respond with the link to explain the 19APR2020 comment?

From what I gather by the video’s small comments and looking up the code by line (where needed) this is what I came up with:

def _represent(self, value):
        if isinstance(value, object):
            if hasattr(value, 'to_dict'):
                return value.to_dict()
            else:
                return str(value)
        else:
            return value

• if isinstance(value, object): checks if the value passed is an object (i.e. a class)
• if hasattr(value, 'to_dict'): if it is a class, check if it has a to_dict attribute (more on this later)
  • return value.to_dict(): if it does have a 'to_dict' attribute, call that class’s to_dict method
  • NOTE: In previous lessons, we learned that methods can be referred to as attributes when not passed any arguments, hence methods can be referred to as attributes and hence hasattr() is used to make this check
• else: return str(value): if there is no to_dict attribute in the class, return the string representation of the passed in value instead
• else: return value: if the passed in value isn’t an instance of the object super class, return the value itself

In general this method seems to be checking 3 things:

1. If value is a class, check for a to_dict method, if there is, call that class’ to_dict method
2. If value is a class, but DOESN’T have a to_dict method, return the string representation of the value passed in (noted by str(value))
3. If value ISN’T a class, return the value itself

As far as isinstance and hasattr are concerned, these are the tests I ran in a REPL:

>>> string = 'hello'
>>> isinstance(string, object)
True
>>> dir(string)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>> hasattr(string, 'isspace')
True

• I passed in a string “value” into isinstance, checking to see that it’s an instance of the object super class (it is, as we know)
• I checked to see what attributes the string class comes with by using dir(string) just to get a simple case example to use with hasattr
• As an example I passed 'isspace' to hasattr to see what gets returned, and this seems to be a boolean that checks whether the value or class passed has the provided attribute

As far as why this check needs to be done in general, that’s beyond me, since as of Python 3 everything inherits from the object super class so it appears to me that isinstance(value, object) would always return true. But I was able to find this StackOverflow article about making your code “Python Agnostic” (adhering to both Python 2 and Python 3 syntax). Hope this helps :)

To piggyback on Roy’s answer, it seems that in Python 3 this method could have been simplified and written as the following (given that any value that we could reasonably pass in should inherently be an object):

def _represent(self, value):
    if hasattr(value, 'to_dict'):
        return value.to_dict()
    else:
        return str(value)

Given this simplification, the next question you might have is: Why not just do the following instead?

def _represent(self, value):
    return str(value)

This would work but the output would look like the following:

{
  "id": "1",
  "name": "Mary Poppins",
  "address": "121 Admin Rd.\nConcord, NH, 03301"
}

It would be nice if the class allowed us to also reformat the address output so that the final result would like this instead:

 {
   "id": "1",
   "name": "Mary Poppins",
   "address": {
     "street": "121 Admin Rd.",
     "street2": "",
     "city": "Concord",
     "state": "NH",
     "zipcode": "03301"
   }
 }

Here we have a dictionary (address) printed within a dictionary. We can now see the keys in the key-value pairs for the address. You’ll notice that the id and name look just as before. So how do we achieve this? It involves a recursive call to to_dict(). Whenever we come across an object that inherits from AsDictionaryMixin, we can call its to_dict() method to print it in this specialized key-value dictionary format.

There are two classes that inherit from AsDictionaryMixin: Employee and Address. We initiate a call to_dict() on the Employee objects in our main script code found in program.py:

for employee in EmployeeDatabase().employees():
    print_dict(employee.to_dict())

Then as we print each employee object using to_dict(), we step through each element of that employee.

def to_dict(self):
    return {
        prop: self._represent(value)
        for prop, value in self.__dict__.items()
        if not self._is_internal(prop)
    }

First we find the id, and print it as a key-value pair. Next we find the name and print it similarly. Then we come across the embedded Address object. Address objects inherit from AsDictionaryMixin. As such, we can print them using the same to_dict() method. We recognize that an object inherits from AsDictionaryMixin by looking for the inherited attribute/method to_dict(). That’s where the conditional if hasattr(value, 'to_dict'): code comes into play. If the object we are printing inherits from AsDictionaryMixin (and thus has the to_dict() method), we opt to make the recursive call to to_dict() to give it the desired formatting:

def _represent(self, value):
    if hasattr(value, 'to_dict'):
        return value.to_dict()
    else:
        return str(value)

Otherwise, we just print the value in its standard string representation (like we see with the id or name).

It might be interesting to note that we could have changed the condition to look more directly for whether the object in question inherits from AsDictionaryMixin. That code would look like this:

def _represent(self, value):
    if issubclass(value.__class__, AsDictionaryMixin):
        return value.to_dict()
    else:
        return str(value)

This achieves the same effect.

Are mixins simply like composition relationships but without the .__init__() method?

@Ariba S They’re like Java interfaces with default method implementations. In other words, their only purpose is to augment concrete classes with additional behavior. Mixins can’t stand on their own, so there’s little point in instantiating them directly. Instead, they modify or hook into existing classes thanks to multiple inheritance.

Notable examples of mixins in Python include the ThreadingMixIn and lots of features in Django.