class App:
    def __init__(self):
        self.endpoints = []
    
    def route(self, path, method='GET'):
        def decorator(f):
            entry = (path, method, f)
            self.endpoints.append(entry)
            return f
        return decorator

    
app = App()
    
@app.route('/')
def home():
    pass

@app.route('/blog', method='GET')
def blog():
    pass

@app.route('/login', method='POST')
def login():
    pass

print(app.endpoints)
# [('/', 'GET', <function __main__.home()>),
#  ('/blog', 'GET', <function __main__.blog()>),
#  ('/login', 'POST', <function __main__.login()>)]

from inspect import signature
from collections import namedtuple

mismatch = namedtuple('mismatch', 'arg expected_type received_type value')

def type_enforce(f):   
    def wrapper(*args, **kwargs):
        ba = sig.bind(*args, **kwargs)
        ba.apply_defaults()
        
        mismatched_types = []
        for key, value in ba.arguments.items():
            annot = f.__annotations__.get(key, None)
            if annot is None:
                continue
            
            elif not isinstance(value, annot):
                mismatched_types.append(
                    mismatch(
                        arg=key,
                        expected_type=annot,
                        received_type=type(value),
                        value=value)
                )
        
        if mismatched_types:
            message = '{prefix} for {f}\n{mismatches}\n'.format(
                prefix='Incorrect input types detected',
                f=f,
                mismatches='\n'.join([f'\t{m}' for m in mismatched_types])
            )
            raise TypeError(message)
            
        return f(*args, **kwargs)

    sig = signature(f)
    return wrapper


@type_enforce
def f1(a: int, b: int, c: None = True):
    if c:
        return a + b
    else:
        return a - b

>>> f1(2, b=1) # works as expected
3

>>> f1(2, b='hi', c=False) # b should be an int
# ---------------------------------------------------------------------------
# TypeError                                 Traceback (most recent call last)
# /tmp/ipykernel_180463/3590008736.py in <cell line: 1>()
# ----> 1 f1(2, b='hi', c=False) # b should be an int

# /tmp/ipykernel_180463/1928943809.py in wrapper(*args, **kwargs)
#      30                 mismatches='\n'.join([f'\t{m}' for m in mismatched_types])
#      31             )
# ---> 32             raise TypeError(message)
#      33 
#      34         return f(*args, **kwargs)

# TypeError: Incorrect input types detected for <function f1 at 0x7fd125eec0d0>
# 	mismatch(arg='b', expected_type=<class 'int'>, received_type=<class 'str'>, value='hi')

>>> f1(2.1, 'bye', c=-1) # a and b should be integers
# ---------------------------------------------------------------------------
# TypeError                                 Traceback (most recent call last)
# /tmp/ipykernel_180463/730960059.py in <cell line: 1>()
# ----> 1 f1(2.1, 'bye', c=-1) # a and b should be integers

# /tmp/ipykernel_180463/1928943809.py in wrapper(*args, **kwargs)
#      30                 mismatches='\n'.join([f'\t{m}' for m in mismatched_types])
#      31             )
# ---> 32             raise TypeError(message)
#      33 
#      34         return f(*args, **kwargs)

# TypeError: Incorrect input types detected for <function f1 at 0x7fd125eec0d0>
# 	mismatch(arg='a', expected_type=<class 'int'>, received_type=<class 'float'>, value=2.1)
# 	mismatch(arg='b', expected_type=<class 'int'>, received_type=<class 'str'>, value='bye')

from numpy import broadcast_arrays, full_like, nan

def vectorize(func):
    def wrapper(*args, **kwargs):
        # would need reflection to determine number of args in func
        a, b = args
        a_arr, b_arr = broadcast_arrays(a, b)
        out = full_like(a_arr, nan)
        _out_raveled = out.ravel()
        
        for i, (_a, _b) in enumerate(zip(a_arr.ravel(), b_arr.ravel())):
            _out_raveled[i] = func(_a, _b)
        return out
    return wrapper
        
    
# example function copied from numpy.vectorize docs
@vectorize
def myfunc(a, b):
    "Return a-b if a>b, otherwise return a+b"
    if a > b:
        return a - b
    else:
        return a + b

print(
    myfunc(1, 3),
    myfunc([1, 2, 3, 4, 5, 6], 3),
    myfunc(3, [1, 2, 3, 4, 5, 6]),
    myfunc([[1,2,3],[4,5,6]], [[2], [4]])
)
# array(4)
# array([4, 5, 6, 1, 2, 3])
# array([2, 1, 6, 7, 8, 9])
# array([[3, 4, 1],
#        [8, 1, 2]])

from inspect import signature

class memoize(dict):
    def __init__(self, f):
        self.f, self.sig = f, signature(f)
    def __call__(self, *args, **kwargs):
        key = self.sig.bind(*args, **kwargs)
        return self[key.args, frozenset(key.kwargs.items())]
    def __missing__(self, key):
        args, kwargs = key
        self[key] = self.f(*args, **dict(kwargs))
        return self[key]

from time import sleep    

@memoize
def add_sleep(a, b, *, sleep_for=0):
    sleep(sleep_for)
    return a + b


%timeit -n 1 -r 1 add_sleep(4, 2, sleep_for=1)
%timeit -n 1 -r 1 add_sleep(4, 2, sleep_for=1)

# 1 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)
# 97.5 µs ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)

class my_contextmanager:
    def __init__(self, func):
        self.func = func
        
    def __call__(self, *args, **kwargs):
        self.gen = self.func(*args, **kwargs)
        return self
        
    def __enter__(self):
        return next(self.gen)
    
    def __exit__(self, typ, value, traceback):
        try:
            next(self.gen)
        except StopIteration:
            return False
    
@my_contextmanager
def generator():
    print('entering context')
    yield
    print('exiting context')

with generator():
    pass

from datetime import datetime
from warnings import warn

def deprecate(*, remove_on):
    def decorator(f):
        def wrapper(*args, **kwargs):
            if datetime.now() < remove_on:
                warn(f'Please dont use {f} anymore, we will remove it on {remove_on:%Y-%m-%d}'.strip())
            else:
                warn('Wait a minute, this function should have been removed already!')

            return f(*args, **kwargs)
        return wrapper
    
    if remove_on is not None:
        remove_on = datetime.strptime(remove_on, '%Y-%m-%d')
    
    return decorator


@deprecate(remove_on='2035-02-04')
def f1():
    pass

@deprecate(remove_on='2000-02-04')
def f2():
    pass

>>> f1()
# /tmp/ipykernel_180463/1508361589.py:8: UserWarning: Please dont use <function f1 at 0x7fd11c0ad480> anymore, we will remove it on 2035-02-04
#   warn(f'Please dont use {f} anymore, we will remove it on {remove_on:%Y-%m-%d}'.strip())

>>> f2()
# /tmp/ipykernel_180463/1508361589.py:10: UserWarning: Wait a minute, this function should have been removed already!
#   warn('Wait a minute, this function should have been removed already!')