Start of exercises.

Author: dham

doc/source/11_further_object-oriented_features.rst

@@ -540,6 +540,40 @@ Glossary
 Exercises
 ---------
 
+Obtain the `skeleton code for these exercises from GitHub classroom
+<>`__. 
+
+.. proof:exercise::
+
+    The objective of this exercise is to write a :term:`decorator` which logs
+    whenever the decorated function is called. This sort of decorator could be
+    very useful in debugging code. Create the decorator in the
+    `log_decorator.log_decorator` module and ensure it is importable as
+    `log_decorator.log_call`. The decorator should be applicable to functions
+    taking any combination of arguments.
+    
+    The logging itself should be accomplished using
+    the built-in `logging` module by calling :func:`logging.info` and passing
+    the logging message.
+
+    The logging message should comprise the function name (accessible using the
+    `__name__` attribute), followed by round brackets containing first the
+    :func:`repr` of the positional arguments, followed by the key=value pairs
+    the keyword arguments.
+
+.. proof:exercise::
+
+    The :mod:`groups.groups` module in the skeleton code is the new version
+    introduced above, using an :term:`abstract base class`. The
+    `log_decorator.log_call` :term:`decorator` has been applied to the
+    :math:`Group._validate` :term:`abstract method`. However, even once you
+    have implemented this decorator, it never gets called. Your challenge is to
+    modify :mod:`groups.groups` so that the decorator is called every time a
+    subclass :meth:`_validate` method is called, but **without** moving or
+    duplicating `@log_call`.
+
+
+
 Exam preparation
 ----------------
 

doc/webgit

@@ -1 +1 @@
-Subproject commit 980ab0a97fffdaab91555208aa27ee249e79c715
+Subproject commit 3ec91a3fbcd3791143806564c6f04affb354357f

example_code/addable.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+
+
+class Addable(ABC):
+
+    @abstractmethod
+    def __add__(self, other):
+        return NotImplemented
+
+    @classmethod
+    def __subclasshook__(cls, C):
+        if cls is not Addable:
+            return NotImplemented
+        for B in C.__mro__:
+            if "__add__" in B.__dict__:
+                if B.__dict__["__add__"] is None:
+                    return NotImplemented
+                return True
+        return NotImplemented

example_code/groups_abc.py

@@ -64,7 +64,7 @@ def symbol(self):
 
     @abstractmethod
     def _validate(self, value):
-        """Ensure that value is a legitimate element value in this group."""
+        """Ensure that value is a legitimate element value in this Group."""
         pass
 
     @abstractmethod