adding all files done so far

learning/decorators/decorator.py

@@ -0,0 +1,204 @@
+import itertools
+import functools
+from time import perf_counter, sleep
+import sys
+
+
+def do_twice(func):
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        for _ in itertools.repeat(None, 2):
+            func(*args, **kwargs)
+            return func(*args, **kwargs)
+    return wrapper
+
+
+def timer(func):
+    @functools.wraps(func)
+    def wrapper_timer(*args, **kwargs):
+        start_time = perf_counter()
+        value = func(*args, **kwargs)
+        end_time = perf_counter()
+        run_time = end_time - start_time
+        print(f'Finished {func.__name__!r} in {run_time:.4f} secs')
+        return value
+    return wrapper_timer
+
+
+def debug(func):
+    """ Print the function signature and return the value """
+    @functools.wraps(func)
+    def wrapper_debug(*args, **kwargs):
+        args_repr = [repr(a) for a in args]
+        kwargs_repr = [f'{k}={v!r}' for k, v in kwargs.items()]
+        signature = ', '.join(args_repr + kwargs_repr)
+        print(f'Calling {func.__name__}({signature})')
+        value = func(*args, **kwargs)
+        print(f'{func.__name__!r} returned {value!r}')
+        return value
+    return wrapper_debug
+
+
+def slow_down(func):
+    @functools.wraps(func)
+    def wrapper_slow_down(*args, **kwargs):
+        sleep(1)
+        return func(*args, **kwargs)
+    return wrapper_slow_down
+
+
+def repeat(num: int):
+    def decorator_repeat(func: callable):
+        @functools.wraps(func)
+        def wrapper_repeat(*args: list, **kwargs: dict):
+            for _ in range(num):
+                value = func(*args, **kwargs)
+            return value
+        return wrapper_repeat
+    return decorator_repeat
+
+
+def repeatN(_func=None, *, num=2):
+    def decorator_repeatN(func):
+        @functools.wraps(func)
+        def wrapper_repeatN(*args, **kwargs):
+            for _ in range(num):
+                value = func(*args, **kwargs)
+            return value
+        return wrapper_repeatN
+
+    if _func is None:
+        return decorator_repeatN
+    else:
+        return decorator_repeatN(_func)
+
+
+def repeat_partial(func=None, *, num=2):
+    if func is None:
+        return functools.partial(repeat_partial, num=num)
+
+    @functools.wraps(func)
+    def repeat_partial_wrapper(*args, **kwargs):
+        for _ in range(num):
+            value = func(*args, **kwargs)
+        return value
+    return repeat_partial_wrapper
+
+
+# def count_calls(func: callable):
+#     @functools.wraps(func)
+#     def wrapper_count_calls(*args, **kwargs):
+#         wrapper_count_calls.num_calls += 1
+#         print(f'Call {wrapper_count_calls.num_calls} of {func.__name__!r}')
+#         return func(*args, **kwargs)
+#     wrapper_count_calls.num_calls = 0
+#     print(wrapper_count_calls.num_calls)
+#     return wrapper_count_calls
+
+
+# def count_calls(func: callable):
+#     num_calls = 0
+#     print(num_calls)
+#     @functools.wraps(func)
+#     def wrapper_count_calls(*args, **kwargs):
+#         nonlocal num_calls
+#         num_calls += 1
+#         print(f'Call {num_calls} of {func.__name__}')
+#         return func(*args, **kwargs)
+#     return wrapper_count_calls
+
+
+def count_calls(func=None, *, num=0):
+    if func is None:
+        return functools.partial(count_calls, num=num)
+
+    @functools.wraps(func)
+    def wrapper_count_calls(*args, **kwargs):
+        wrapper_count_calls.num += 1
+        print(f'Call {wrapper_count_calls.num} of {func.__name__}')
+        return func(*args, **kwargs)
+    wrapper_count_calls.num = num
+    return wrapper_count_calls
+
+
+class Counter(object):
+    """docstring for Counter"""
+    def __init__(self, func):
+        print('start init')
+        super(Counter, self).__init__()
+        functools.update_wrapper(self, func)
+        self.func = func
+        self.num_calls = 0
+        print('finished init')
+
+    def __call__(self, *args, **kwargs):
+        print('start call')
+        self.num_calls += 1
+        print(f'Call {self.num_calls} of {self.func.__name__!r}')
+        print('finished call')
+        return self.func(*args, **kwargs)
+
+
+# class slowDown(object):
+#     """docstring for slowDown"""
+#     def __init__(self, rate):
+#         if callable(rate):
+#             self.func = rate
+#             self.rate = 1
+#         else:
+#             self.rate = rate
+
+#     def __get__(self, obj, type=None):
+#         return functools.partial(self, obj)
+
+#     def __call__(self, *args, **kwargs):
+#         if not hasattr(self, 'func'):
+#             self.func = args[0]
+#             return self
+#         sleep(self.rate)
+#         self.func(*args, **kwargs)
+
+
+class slowDown(object):
+    """docstring for Slow_Down"""
+    def __init__(self, rate=1):
+        print('init')
+        self.rate = rate
+
+    def __call__(self, func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            print('wrapper')
+            sleep(self.rate)
+            func(*args, **kwargs)
+        print('call finished')
+        print(self, func)
+        return wrapper
+
+
+# class slowDown(object):
+#     """docstring for slowDown"""
+#     def __init__(self, rate):
+#         if callable(rate):
+#             self.func = rate
+#             self.rate = 1
+#             print(f'no args, {locals()}, func={self.func}, rate={self.rate},\
+#                   self={self}')
+#         else:
+#             self.rate = rate
+#             print(f'args set, rate={self.rate}')
+
+#     def __get__(self, obj, type=None):
+#         print(f'get called, self={self}, obj={obj}, type={type}')
+#         return functools.partial(self, obj)
+
+#     def __call__(self, *args, **kwargs):
+#         print(f'call called, rate={self.rate}, args={args}'
+#               f', kwargs={kwargs} ,self={self}')
+#         print(f'locals = {locals()}')
+#         if not hasattr(self, 'func'):
+#             self.func = args[0]
+#             print(f'args set, setting self.func to {self.func}')
+#             return self
+#         sleep(self.rate)
+#         self.func(*args, **kwargs)