initial

Author: fpierfed

05-interlude_decorators.py

@@ -0,0 +1,49 @@
+from functools import wraps
+import logging
+import time
+
+
+def timeit(logger):
+    def wrapper(fn):
+
+        @wraps(fn)
+        def inner_wrapper(*args, **kwargs):
+            t0 = time.time()
+            result = fn(*args, **kwargs)
+            logger(f'{fn.__name__} took {time.time() - t0:.02f} seconds')
+            return result
+        return inner_wrapper
+    return wrapper
+
+
+@timeit(print)
+def foo(n):
+    time.sleep(n)
+    return n
+
+
+@timeit(logging.warning)
+def bar(n):
+    time.sleep(n)
+    return n
+
+
+def time_all(logger):
+    def wrapper(cls):
+        for name, obj in vars(cls).items():
+            if not name.startswith('_') and callable(obj):
+                setattr(cls, name, timeit(logger)(obj))
+        return cls
+    return wrapper
+
+
+@time_all(print)
+class Foo:
+    def bar(self, n):
+        time.sleep(n)
+        return n
+
+    def baz(self, n):
+        m = n * 2
+        time.sleep(m)
+        return m

06-decorators.py

@@ -0,0 +1,74 @@
+from math import pi
+
+
+class TypeChecker:
+    required_type = object
+
+    def __init__(self, name=None):
+        self.name = name
+
+    def __get__(self, instance, owner=None):
+        return instance.__dict__[self.name]
+
+    def __set__(self, instance, value):
+        assert isinstance(value, self.required_type), \
+               f'Booooo! Expecting a {self.required_type.__name__}'
+        instance.__dict__[self.name] = value
+
+
+class IntType(TypeChecker):
+    required_type = int
+
+
+def type_check(**kwargs):
+    def wrapper(cls):
+        for var_name, checker_class in kwargs.items():
+            setattr(cls, var_name, checker_class(var_name))
+        return cls
+    return wrapper
+
+
+@type_check(x=IntType, y=IntType)
+class Point:
+    def __init__(self, x, y):
+        self.x = x
+        self.y = y
+
+    def move_by(self, dx, dy):
+        self.x += dx
+        self.y += dy
+
+    def __str__(self):
+        return f'A Point at {self.x}, {self.y}'
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}({self.x}, {self.y})'
+
+
+class PointType(TypeChecker):
+    required_type = Point
+
+
+@type_check(center=PointType, radius=IntType)
+class Circle:
+    center = PointType('center')
+    radius = IntType('radius')
+
+    def __init__(self, center, radius):
+        self.center = center
+        self.radius = radius
+
+    @property
+    def area(self):
+        return pi * self.radius ** 2
+
+    def __str__(self):
+        return f'A Circle at {self.center.x}, {self.center.y} and ' + \
+               f'radius {self.radius}'
+
+    def __repr__(self):
+        return f'{self.__class__.__name__}({self.center!r}, {self.radius!r})'
+
+
+# Fewer lines of code!
+# Mind-bending?