Advanced Python

%%file requirements.txt
numpy
matplotlib
numba 
astropy

!pip install -q pip --upgrade
!pip install -q -r requirements.txt

# make sure pylab runs inline when using the notebook
%matplotlib inline
import numpy as np
import pylab as plt

light_minimal = {
    'font.family': 'serif',
    'font.size': 14,
    "axes.titlesize": "x-large",
    "axes.labelsize": "large",
    'axes.edgecolor': '#666666',
    "xtick.direction": "out",
    "ytick.direction": "out",
    "xtick.major.size": "8",
    "xtick.minor.size": "4",
    "ytick.major.size": "8",
    "ytick.minor.size": "4",
    'xtick.labelsize': 'small',
    'ytick.labelsize': 'small',
    'ytick.color': '#666666',
    'xtick.color': '#666666',
    'xtick.top': False,
    'ytick.right': False,
    'axes.spines.top': False,
    'axes.spines.right': False,
    'image.aspect': 'auto'
}

plt.style.use(light_minimal)

a = 5       # integer
a = "text"  # string

a: int = 5
b: str = "text"

def scale(scalar, vector):
    return [scalar * num for num in vector]

new_vector = scale(2.0, [1.0, -4.2, 5.4])

Vector = list[float]

def scale(scalar: float, vector: Vector) -> Vector:
    return [scalar * num for num in vector]

new_vector = scale(2.0, [1.0, -4.2, 5.4])

Vector = list[float]

def scale(scalar: float, vector: Vector) -> Vector:
    return [scalar * num for num in vector]

scale.__annotations__

a: int = 5
b: str = "text"
__annotations__

a = "text"               # what happens?
a: "dummy quantity" = 5  # Does it work? What could this mean?

from typing import Any, Sequence, Callable
from itertools import cycle
import inspect

Vector = list[float]

def scale(scalar: float, vector: Vector) -> Vector:
    return [scalar * num for num in vector]


def AssertInstanceGenericType(name: str, value: Any, annotation: type) -> None:
    if annotation == inspect._empty:  # empty annotation
        return
    try:
        if not isinstance(value, annotation):
            raise RuntimeError(f"TypeCheck {name:s}: got {value} not of type {annotation}.")
    except TypeError:  # e.g. List[...], Sequence[...]
        orig, what = annotation.__origin__, annotation.__args__
        if not isinstance(value, orig):
            raise RuntimeError(f"TypeCheck {name:s}: got {value} not of type {annotation}.")
        for e, (subval, subw) in enumerate(zip(value, cycle(what))):
            AssertInstanceGenericType(f"{name:s}[{e:d}]", subval, subw)

def isinstanceGenericType(name: str, value: Any, annotation: type, verbose: bool = True) -> bool:
    try:
        AssertInstanceGenericType(name, value, annotation)
        return True
    except RuntimeError as err:
        if verbose:
            print(err)
        return False

def assert_types(func: Callable,
                *args: Sequence[Any],
                **kwargs: dict[str, Any]) -> Any:

    sig = inspect.signature(func)
    for value, (name, pardef) in zip(args, sig.parameters.items()):
        AssertInstanceGenericType(name, value, pardef.annotation)

    result = func(*args, **kwargs)
    AssertInstanceGenericType("returned value", result, sig.return_annotation)
    return result

isinstanceGenericType('dummy', 2.0, int)

isinstanceGenericType('dummy', 2, int)

isinstanceGenericType('dummy', [2, 3.0], list[int])

isinstanceGenericType('dummy', [2, 3.0], list[int | float])

assert_types(scale, 2.0, [1.0, -4.2, 5.4])

assert_types(scale, 2.0, [1.0, -4.2, 5])

import pylab as plt
r = plt.plot(range(10))
r

s = "some text"
s1 = s.strip()  # remove leading/trailing spaces
su = s1.upper() # make uppercase
print(su)

import pylab as plt
r = []
r.append( plt.plot(range(10)) )
r.append( plt.xlabel('measured') )
r.append( plt.ylabel('calculated') )
r.append( plt.title('Measured vs. Calculated') )
r.append( plt.grid(True) )
r

plt.plot(range(10))
plt.xlabel('measured')
plt.ylabel('calculated')
plt.title('Measured vs. Calculated')
plt.grid(True)
ax = plt.gca()       # gca == get current axis
line = ax.lines[0]
line.set_marker('o')
plt.setp(line, color='g');   # set properties

class Vector(object):
    def __init__(self):
        pass

class Vector:
    def __init__(self, x, y, z):
        """ Constructor """
        self.x, self.y, self.z = x, y, z
    def sum(self, other):
        """ add 2 vectors """
        return Vector(self.x + other.x,
                      self.y + other.y,
                      self.z + other.z)
    def scalar_prod(self, other):
        """ product of 2 vectors """
        return (self.x * other.x +
                self.y * other.y +
                self.z * other.z)

a = Vector(1,0,0)
b = Vector(0,1,0)
print("a . b = ", a.scalar_prod(b))
print(a.sum(b)) #???

class Vector:
    def __init__(self, x, y, z):
        """ Constructor """
        self.x, self.y, self.z = x, y, z
    def sum(self, other):
        """ add 2 vectors """
        return Vector(self.x + other.x,
                      self.y + other.y,
                      self.z + other.z)
    def scalar_prod(self, other):
        """ product of 2 vectors """
        return (self.x * other.x +
                self.y * other.y +
                self.z * other.z)
    def __str__(self):
        """ str representation """
        return "Vector({s.x},{s.y},{s.z})".format(s=self)

a = Vector(1,0,0)
b = Vector(0,1,0)
print("a . b = ", a.scalar_prod(b))
print(a.sum(b)) #???

x = Vector(1, 0, 0)
y = Vector(0, 1, 0)
z = Vector(0, 0, 1)

# x.scalar_prod(x).sum(y.scalar_prod(y))
x.scalar_prod(x) + y.scalar_prod(y) + 2 * x.scalar_prod(y) == x.sum(y).scalar_prod(x.sum(y))

# x ** 2 + y ** 2 + 2 * x * y == (x + y) ** 2

class Vector(object):
    def __init__(self, x, y, z):
        self.x, self.y, self.z = x, y, z
    def __repr__(self):
        # String repr, called when >>> Vector([1,2,3]) <CR>
        return self.__str__() + ", " + object.__repr__(self)
    def __str__(self):
        """ str representation """
        return "Vector({s.x},{s.y},{s.z})".format(s=self)
    def __add__(self, p):
        if isinstance(p, Vector):	# if p Vector, sum of p1*p2
            return Vector(self.x + p.x, self.y + p.y, self.z + p.z)
        return Vector(self.x + p, self.y + p, self.z + p)
    def __mul__(self, p):
        if isinstance(p, Vector):	# scalar product p1*p2
            return self.x * p.x + self.y * p.y + self.z * p.z
        return Vector(self.x * p, self.y * p, self.z * p)
    def __matmul__(self, p):
        """ self @ p as vector product """
        if not isinstance(p, Vector):
            raise RuntimeError("second argument is not a Vector")
        x = self.y * p.z - self.z * p.y
        y = self.z * p.x - self.x * p.z
        z = self.x * p.y - self.y * p.x
        return Vector(x, y, z)
    def __pow__(self, p):
        return sum([self.x ** p, self.y ** p, self.z ** p])

x = Vector(1, 0, 0)
y = Vector(0, 1, 0)
z = Vector(0, 0, 1)

xy = x * y
print("x.y = ", xy)
print(x)
x * x + y * y + x * y * 2 == (x + y) ** 2

import numpy as np

class Vector(object):
    def __init__(self, x):
        self.x = np.atleast_1d(x)
    def __repr__(self):
        # String repr, called when >>> Vector([1,2,3]) <CR>
        return self.__str__() + ", " + object.__repr__(self)
    def __str__(self):
        """ str representation """
        return "Vector({s.x})".format(s=self)
    def __add__(self, p):
        if isinstance(p, Vector):	# if p Vector, sum of p1*p2
            return Vector(self.x + p.x)
        return Vector(self.x + p)
    def __mul__(self, p):
        if isinstance(p, Vector):	# scalar product p1*p2
            return np.sum(self.x * p.x)
        return Vector(self.x * p)
    def __matmul__(self, p):
        """ self @ p as vector product """
        if not isinstance(p, Vector):
            raise RuntimeError("second argument is not a Vector")
        return Vector(x @ p.x)
    def __pow__(self, p):
        return sum(self.x ** p)

x = Vector([1, 0, 0])
y = Vector([0, 1, 0])
z = Vector([0, 0, 1])

xy = x * y
print("x.y = ", xy)
print(x)
x * x + y * y + x * y * 2 == (x + y) ** 2

import numpy as np
import pylab as plt

class Interp:
    def __init__(self, x, y):
        self.x, self.y = x, y
    def __call__(self, xn):
        return np.interp(xn, self.x, self.y)

def interpfn(x, y):
    def f(xn):
        return np.interp(xn, x, y)
    return f

import numpy as np
import pylab as plt
x = np.arange(10)
y = np.hstack([x[: 5] ** 2, 25 - 5 * x[5:]])
interp = Interp(x, y)
xn = np.linspace(0, 10, 20)
plt.plot(x, y, 'o-', lw=2)
plt.plot(xn, interp(xn), '.-')

class IMF(object):
    mass = [0.1, 120.]

    
class Salpeter(IMF):
    pass

f = Salpeter()
print(f.mass)

class IMF(object):
    """
    IMF object class
    let you define an IMF as multiple power-laws.

    attributes:
        norm:    norm of the function
    """

    def __init__(self, *args, **kwargs):
        """
        """
        pass

    def get_enclosed_mass(self, Mmin, Mmax):
        """Get the enclosed mass over a given mass range.
        """
        pass

    def get_enclosed_Nstar(self, Mmin, Mmax):
        """Get the enclosed dN over a given mass range
        """
        pass

    def get_avg_mass(self, Mmin, Mmax):
        """ get the avg mass over a given range """
        pass

    def getValue(self, m):
        """ returns the value of the normalized IMF at a given mass m:
            note: m can be an iterable
        """
        pass

    def random(self, N, massMin=None, massMax=None):
        """ Draw samples from this distribution
        Samples are distributed over the interval [massMin, massMax]
        Interval is truncated to the IMF range definition if it extents beyond it. 
        (taken as is otherwise)
        """
        pass
    
    def __call__(self, m=None):
        return self.getValue(m)

import numpy as np


class IMF(object):
    """
    Here is one possible implementation, which
    let you define an IMF as multiple power-laws
    """
    def __init__(self, nI, x, a, massMin=0.1, massMax=120., name=None):
        """__init__ - constructor of the class

        Parameters
        ----------
        nI: int
            number of definition intervals

        x:  iterable
            interval edges (of len nI + 1)

        a:  iterable
            power-law indexes (of len nI) in units of dN/dM (Salpeter corresponds to -2.35)

        massMin: float
            minimal mass

        massMax:
            maximal mass

        name: string
            optional name

        notes
        -----
        1 - the mass range can be restricted by massMin, massMax while keeping
            the official definition.
        2 - indexes of the different power-laws are assumed to be in units of
            dN/dM, ie, -2.35 corresponds to a Salpeter IMF. However, sometimes
            you could find -1.35, which corresponds to an index defined in
            terms of dN/dlog(M).
        """
        # Store relevant information
        # ==========================
        self.nIMFbins  = nI
        self.massinf   = np.asarray(x)
        self.slope     = np.asarray(a)
        self.name      = name
        self.coeffcont = np.zeros(np.size(a))
        self.massMin   = massMin
        self.massMax   = massMax

        # Make functional form
        # ====================
        # the first step is to build the functional form of the IMF:
        # i.e., make a continuous function and compute the normalization

        # continuity
        # ----------
        # given by:  c[i-1] * x[i] ^ a[i-1] = c[i] * x[i] ^ a[i]
        # arbitrary choice for the first point, which will be corrected by the
        # normalization step.
        self.coeffcont[0] = 1.
        for i in range(1, nI):
            self.coeffcont[i]  = (self.coeffcont[i - 1])
            self.coeffcont[i] *= (x[i] ** (a[i - 1] - a[i]))

        # normalize
        # ---------
        # depends on the adpoted definition of the IMF indexes:
        # either dN/dM or dN/dlog(M). In this example we consider that indexes
        # are given in units of dN/dM.
        # get the norm : integral(imf(M) dM) = 1 seen as a prob dist. funct."""
        self.norm = 1.  # will be updated at the next line
        self.norm = self.get_enclosed_Nstar(self.massMin, self.massMax)

        # Compute the average mass
        self.avg = self.get_avg_mass(self.massMin, self.massMax)

    def get_enclosed_Nstar(self, Mmin, Mmax):
        """get_enclosed_Nstar - Get the enclosed dN over a given mass range.
        Analytic integration, Sum(imf(m) dm)
        Note: no extrapolation outside the original mass range definition of the IMF.

        keywords
        --------
        Mmin, Mmax: float, float
            lower and upper masses

        returns
        -------
        r: float
            enclosed dN within [Mmin, Mmax]
        """
        x = self.massinf
        a = self.slope
        c = self.coeffcont

        # will be useful in the integration
        b = a + 1.

        val = 0.
        # analytical integration of a power law
        for i in range(0, self.nIMFbins):
            if (Mmin < x[i + 1]) & (Mmax > x[i]):
                if x[i] <= Mmin:
                    x0 = Mmin
                else:
                    x0 = x[i]
                if x[i + 1] <= Mmax:
                    x1 = x[i + 1]
                else:
                    x1 = Mmax
                # careful if the index is 1
                if a[i] == 1:
                    S = c[i] * (np.log(x1) - np.log(x0))
                else:
                    S = c[i] / b[i] * ( (x1) ** (b[i]) - (x0) ** (b[i]) )
                val += S

        return val * self.norm

    def get_enclosed_mass(self, Mmin, Mmax):
        """get_enclosed_mass - Get the enclosed mass over a given mass range.
        Analytic integration, integral(m * imf(m) dm)

        Note: no extrapolation outside the original mass range definition of the IMF.

        Parameters
        ----------
        Mmin, Mmax: float, float
            lower and upper masses

        returns
        -------
        r: float
            enclosed mass within [Mmin, Mmax]
        """
        x = self.massinf
        a = self.slope
        c = self.coeffcont

        # will be useful in the integration
        b = a + 2.

        val = 0.
        # analytical integration of a power law
        for i in range(0, self.nIMFbins):
            if (Mmin < x[i + 1]) & (Mmax > x[i]):
                if x[i] <= Mmin:
                    x0 = Mmin
                else:
                    x0 = x[i]
                if x[i + 1] <= Mmax:
                    x1 = x[i + 1]
                else:
                    x1 = Mmax

                # careful if the index is 1
                if a[i] == 2:
                    S = c[i] * (np.log(x1) - np.log(x0))
                else:
                    S = c[i] / b[i] * ( (x1) ** (b[i]) - (x0) ** (b[i]) )
                val += S

        return val * self.norm

    def getValue(self, m):
        """getValue - returns the value of the normalized IMF at a given mass m
            IMF(m) = 1 / norm * c * m ** a
            and integral( IMF(m) dm ) = 1

        Parameters
        ----------
        m: float or iterable of floats
            masses at which evaluate the function

        returns
        -------
        r: float or ndarray(dtype=float)
            evaluation of the function (normalized imf)
        """
        # if m is iterable
        if getattr(m, '__iter__', False):
            return np.asarray([ self.getValue(mk) for mk in m])
        else:
            # extrapolation
            if (m > self.massMax) or (m < self.massMin):
                return 0.
            # exact value exists
            elif m in self.massinf[:-1]:
                ind = np.where(m == self.massinf)
                return float(float(self.coeffcont[ind]) / self.norm * m ** self.slope[ind])
            # otherwise do the evaluation with the correct interval
            else:
                i = 0
                if self.nIMFbins > 1:
                    while m > self.massinf[i]:
                        i += 1
                    i -= 1
                if self.massinf[i] > self.massMax:
                    return 0.
                else:
                    return float(float(self.coeffcont[i]) / self.norm * m ** self.slope[i])

    def get_avg_mass(self, Mmin, Mmax):
        """ get the avg mass over a given range
              < M > = integral(M * imf * dM) / integral(imf * dM)

        :param Mmin: float, lower mass
        :param Mmax: float, upper mass
        """
        return self.get_enclosed_mass(Mmin, Mmax) / self.get_enclosed_Nstar(Mmin, Mmax)

    def random(self, N, massMin=None, massMax=None):
        """random - Draw mass samples from this distribution
        Samples are distributed over the interval [massMin, massMax]
        Interval is truncated to the IMF range definition if it extents beyond it. (taken as is otherwise)

        Parameters
        ----------

        N: int
            size of the sample

        massMin: float
            lower mass (default self.massMin)

        massMax: float
            upper mass (default self.massMax)

        returns
        -------

        r: ndarray(dtype=float)
            returns an array of random masses

        method
        ------

        drawing random numbers from a given distribution can be done using
        multiple methods. When you can compute or accurately estimate the
        integral of your function, the optimal way is to use it, aka "Inverse
        transform sampling". Briefly:

        let's call F(x) = integral( imf(m) dm, m=massMin..x)

        Since we use power laws, the intregral is trivial. if x such as
        M[i] <= x < M[i+1], with M the masses used to define the IMF:

        F(x) = F(M[i]) + 1 / norm * 1 / (a[i] + 1) ( x ** (a[i] + 1) - M[i] ** (a[i] + 1) )

        The trick is to observe that F(x) varies between 0 and 1, and that
        there is a unique mapping between F(x) and x (F is a bijective
        function).
        I spare the proof but we can demonstrate that drawing uniform F(x)
        numbers between 0 and 1 will then give us x values that exactly follow
        the imf.

        In our case, the previous equation is inversible, and once you extract
        x as a function of F(x) you're done.
        """

        # check keyword values, default is the IMF definition
        massMin = massMin or self.massMin
        massMax = massMax or self.massMax

        beta = self.slope + 1.

        # compute the cumulative distribution values at each mass interval edge
        F = np.zeros(self.nIMFbins + 1)
        F[-1] = 1.0
        for i in range(1, self.nIMFbins):
            F[i] = F[i - 1] + 1. / self.norm * (self.coeffcont[i - 1] / (beta[i - 1])) * ( self.massinf[i] ** (beta[i - 1]) - self.massinf[i - 1] ** (beta[i - 1]) )

        #find intervals of massMin and massMax
        for k in range(self.nIMFbins):
            if massMin >= self.massinf[k]:
                mink = k
            if massMax >= self.massinf[k]:
                maxk = k
        if massMin < self.massMin:
            Fmin = 0.
        elif massMin >= self.massMax:
            return
        else:
            i = mink
            Fmin = F[i] + 1. / self.norm * ( self.coeffcont[i] / (beta[i]) ) * ( massMin ** (beta[i]) - self.massinf[i] ** (beta[i]) )

        if massMax >= self.massMax:
            Fmax = 1.0
        elif massMax < self.massMin:
            return
        else:
            i = maxk
            Fmax = F[i] + 1. / self.norm * ( self.coeffcont[i] / (beta[i]) ) * ( massMax ** (beta[i]) - self.massinf[i] ** (beta[i]) )

        x = np.random.uniform(Fmin, Fmax, N)
        y = np.zeros(N)
        for k in range(self.nIMFbins):
            ind = np.where((x >= F[k]) & (x < F[k + 1]))
            if len((ind)[0]) > 0:
                y[ind] = self.massinf[k] * ( 1. + (x[ind] - F[k]) / (self.massinf[k] ** (beta[k])) * ( beta[k] ) * self.norm / self.coeffcont[k]) ** (1. / (beta[k]))
        return y

    def __call__(self, m=None):
        """__call__ - make a callable object (function like)

        Parameters
        ----------

        m: float or iterable or None
            if None calls self.info()
            else calls self.getValue(m)
        """
        if m is None:
            return self.info()
        return self.getValue(m)

    def info(self):
        """ prints a quick summary of the functional object """
        txt = """IMF: {s.name}, IMF(m) = 1./norm * c * m ** a
        nI = {s.nIMFbins},
        norm = {s.norm}, 1/norm = {invnorm},
        Average mass = {s.avg},
        m[] = {s.massinf},
        a[] = {s.slope},
        c[] = {s.coeffcont}"""
        print(txt.format(s=self, invnorm=1. / self.norm))


# Deriving common IMF from the literature
#=========================================

# in the definitions below, power-law indexes are given for the dN/dlog(M)
# definition and accordingly converted before usage

class Kennicutt(IMF):
    def __init__(self):
        nI = 2
        x = [0.1, 1., 120.]
        a = [-0.4, -1.5]
        a = np.asarray(a) - 1
        massMin = 0.1
        massMax = 120.
        IMF.__init__(self, nI, x, a, massMin, massMax, name='Kennicutt')


class Kroupa2001(IMF):
    def __init__(self):
        nI = 4
        x = [0.01, 0.08, 0.5, 1., 150.]
        a = [0.7, -0.3, -1.3, -1.3]
        a = np.asarray(a) - 1
        massMin = 0.01
        massMax = 120.
        IMF.__init__(self, nI, x, a, massMin, massMax, name='Kroupa 2001')


class Kroupa93(IMF):
    def __init__(self):
        nI = 3
        x = [0.1, 0.5, 1., 120.]
        a = [-0.3, -1.2, -1.7]
        a = np.asarray(a) - 1
        massMin = 0.1
        massMax = 120.
        IMF.__init__(self, nI, x, a, massMin, massMax, name='Kroupa 1993')


class Salpeter(IMF):
    def __init__(self):
        nI = 1
        x = [0.1, 120.]
        a = [-1.35]
        a = np.asarray(a) - 1
        massMin = 0.1
        massMax = 120.
        IMF.__init__(self, nI, x, a, massMin, massMax, name='Salpeter')


class MillerScalo(IMF):
    def __init__(self):
        nI = 3
        x = [0.1, 1., 10., 120.]
        a = [-0.4, -1.5, -2.3]
        a = np.asarray(a) - 1
        massMin = 0.1
        massMax = 120.
        IMF.__init__(self, nI, x, a, massMin, massMax, name='Miller & Scalo')


class Scalo98(IMF):
    def __init__(self):
        nI = 3
        x = [0.1, 1., 10., 120.]
        a = [-0.2, -1.7, -1.3]
        a = np.asarray(a) - 1
        massMin = 0.1
        massMax = 120.
        IMF.__init__(self, nI, x, a, massMin, massMax, name='Scalo 1998')


class Scalo86(IMF):
    def __init__(self):
        nI = 24
        x = [    1.00000000e-01,   1.10000000e-01,   1.40000000e-01,
                 1.80000000e-01,   2.20000000e-01,   2.90000000e-01,
                 3.60000000e-01,   4.50000000e-01,   5.40000000e-01,
                 6.20000000e-01,   7.20000000e-01,   8.30000000e-01,
                 9.80000000e-01,   1.17000000e+00,   1.45000000e+00,
                 1.86000000e+00,   2.51000000e+00,   3.47000000e+00,
                 5.25000000e+00,   7.94000000e+00,   1.20200000e+01,
                 1.82000000e+01,   2.69200000e+01,   4.16900000e+01,
                 1.20000000e+02     ]
        a = [  3.2   ,  2.455,  2.   ,  0.3  ,  0.   ,  0.   , -0.556, -1.625,
               -1.833, -1.286,  1.5  , -1.857,  0.   , -2.333, -3.455, -1.692,
               -2.571, -1.722, -1.611, -1.667, -2.333, -1.353, -0.947, -1.778]
        a = np.asarray(a) - 1
        massMin = 0.1
        massMax = 120.
        IMF.__init__(self, nI, x, a, massMin, massMax, name='Scalo 1986')

imf = Salpeter()
imf.info()

imf = Kroupa2001()
imf.info()

logm = np.arange(np.log10(0.1), np.log10(120), 0.1)
m = 10 ** logm
for imf_cls in (Salpeter, Kroupa2001, Kennicutt):
    imf = imf_cls()
    plt.plot(m, imf(m), label=imf.name, lw=2)
plt.xscale('log')
plt.yscale('log')
plt.xlabel(r'mass [M$_\odot$]')
plt.ylabel(r'p(mass | IMF)')
plt.legend()
    

imf = Kroupa2001()
rvs = imf.random(10_000)  #10000 10_000
_, b, _ = plt.hist(np.log10(rvs), log=True, 
                   bins=128, density=True, alpha=0.5)
c = 0.5 * (b[1:] + b[:-1])
dm = np.diff(10 ** b)
plt.plot(c, imf(10 ** c) * dm / (b[1] - b[0]), lw=3)

def say_hello(name: str) -> str:
    return f"Hello {name:s}"

def be_awesome(name: str) -> str:
    return f"Yo {name:s}, together we are the awesomest!"

def greet_bob(greeter_func: Callable) -> str:
    return greeter_func("Bob")

greet_bob(say_hello)

greet_bob(be_awesome)

def parent() -> None:
    print("Printing from the parent() function")

    def first_child() -> None:
        print("Printing from the first_child() function")

    def second_child() -> None:
        print("Printing from the second_child() function")

    second_child()
    first_child()

parent()

def parent() -> Callable:
    def inner() -> str:
        return "Hi, I am the inner function"
    return inner

parent()

parent()()

def deco(func: Callable) -> Callable:
    def wrapper(*args, **kwargs):
        print(f"Something before calling the function.")
        result = func(*args, **kwargs)
        print("Something after calling the function.")
        return result
    return wrapper

def say_whee():
    print("Whee!")

say_whee = deco(say_whee)

say_whee()

@deco
def say_whee():
    print("Whee!")

say_whee()

help(say_whee)

from functools import wraps

def deco(func: Callable) -> Callable:
    @wraps(func)
    def wrapper(*args, **kwargs):
        # Something before
        result = func(*args, **kwargs)
        # Something after
        return result
    return wrapper

from functools import wraps
import time

def timeit(func):
    """Prints the runtime of decorated functions"""
    @wraps(func)
    def wrapper_timer(*args, **kwargs):
        start_time = time.perf_counter()
        value = func(*args, **kwargs)
        end_time = 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

@timeit
def waste_some_time(num_times):
    for _ in range(num_times):
        sum([i**2 for i in range(10000)])

waste_some_time(999)

import functools 


class memoize(dict):
    '''Caches a function's return value each time it is called
    and returns the cached value when called later with the same arguments. (not reevaluated).
    '''
    def __init__(self, func):
        self.func = func
        functools.update_wrapper(self, func)

    def __getitem__(self, *key):
        return dict.__getitem__(self, key)

    def __missing__(self, key):
        ret = self[key] = self.func(*key)
        return ret

    __call__ = __getitem__


@memoize
def fibonacci(n):
    "Return the nth fibonacci number."
    if n in (0, 1):
        return n
    return fibonacci(n-1) + fibonacci(n-2)

%timeit fibonacci(30)

from functools import lru_cache

@lru_cache
def factorial(n):
    return n * factorial(n-1) if n else 1

%timeit factorial(20)

from numba import jit
import random

@jit(nopython=True)
def monte_carlo_pi(nsamples):
    acc = 0
    for i in range(nsamples):
        x = random.random()
        y = random.random()
        if (x ** 2 + y ** 2) < 1.0:
            acc += 1
    return 4.0 * acc / nsamples

monte_carlo_pi(100_000)

import astropy.units as u

@u.quantity_input(myangle=u.arcsec)
def myfunction(myangle):
    return myangle ** 2

@u.quantity_input
def myfunction(myangle: u.arcsec):
    return myangle ** 2

@u.quantity_input
def myfunction(myangle: u.arcsec) -> u.deg ** 2:
    return myangle ** 2

# Test here

@timeit
@lru_cache
def fibonacci(n):
    "Return the nth fibonacci number."
    if n in (0, 1):
        return n
    return fibonacci(n-1) + fibonacci(n-2)

#Test here

@lru_cache
@timeit
def fibonacci(n):
    "Return the nth fibonacci number."
    if n in (0, 1):
        return n
    return fibonacci(n-1) + fibonacci(n-2)

#test here

%%file foo.txt
Lorem ipsum dolor sit amet, ea feugiat maiorum evertitur his. Rebum molestie scriptorem ad eam, duo posse nostro scaevola te. Vix dolorum iudicabit ad. Verear utamur vulputate eum id, ius ad ocurreret euripidis, eu qui dicant tritani fierent. Eam in latine voluptaria, erant audiam tacimates ea nec, iisque eripuit vim at.

An pri illum prodesset, sit no vocent imperdiet conclusionemque. Et has erat mediocritatem conclusionemque. Vel sint ferri sapientem ne. Quaeque scriptorem ius in, soleat adipiscing intellegam in duo, pro inani doctus facilis cu.

Pri ut mentitum necessitatibus, nulla labores perfecto sea te. At atqui aliquam his, est te meis percipit adipisci, atqui ocurreret ut pro. Ei pri vero explicari dissentias, vitae epicurei quaerendum nam ad, ut nam autem tation patrioque. Nibh eligendi maluisset eos ut, usu et utinam vidisse percipitur.

At wisi probo vel, et nostrum epicurei definiebas pri, an homero neglegentur reprehendunt has. Eu saepe oblique his, et vidisse detraxit mei. Unum vituperata duo ei, rebum deseruisse dissentiunt eum ne. Mel cu vitae salutatus tincidunt. Dictas utamur quo in, ei has percipit consequat.

Eu populo mentitum vis, esse alienum offendit ex nam, sea an ullum quando moderatius. Vis suscipit pertinacia te, ea ius nominavi iudicabit, cu congue veniam pri. Sea quot prompta reformidans at, dicat tractatos pri ne. Sed modo audire ne, dolor prompta eum cu. An duo etiam elaboraret interesset, te mea zril recteque. Equidem maiorum elaboraret id vis.

fp = open("foo.txt", 'r')
for line in fp:
    # do something
    print(line[:10], '...')
fp.close()      

with open('foo.txt', 'r') as fp:
    for line in fp:
        # do something
        print(line[:10], '...')

fp.seek(0)

class MyContext:
    def __enter__(self):
        """Enter the runtime context related to this object.
        Must return the target(s) specified in the `as` clause of the statement, if any."""
        ...
        return self   # typically
    def __exit__(self, exc_type, exc_value, traceback):
        """Exit the runtime context related to this object.
        The parameters describe the exception that caused the context to be exited (or None)"""
        pass

from contextlib import suppress
import os

with suppress(FileNotFoundError):
    os.remove('foo.txt')

# your code here

def fibonacci(n):
    "Return the nth fibonacci number."
    if n in (0, 1):
        return n
    return fibonacci(n-1) + fibonacci(n-2)

with timeit("Fibonacci"):
    fibonacci(40)

# stdout/stderr something like
# "'Fibonacci' execution time: 32.6s