class Person:
    def __init__(self, name):
        self.name = name
    def __repr__(self):
        return f"{type(self).__name__}({self.name!r})"
    def walk(self):
        print(self.name, 'walking')
    def run(self):
        print(self.name,'running')
    def swim(self):
        print(self.name,'swimming')
        
class OlympicRunner(Person):
    def run(self):
        print(self.name,self.name,"running incredibly fast!")
        
    def show_medals(self):
        print(self.name, 'showing my olympic medals')
    
def train(person):
    person.walk()
    person.swim()
    person.run()
    
terry = Person('Terry Gilliam')
graham = Person('Graham Chapman')
train(terry)

usainbolt = OlympicRunner('Usain Bolt')
usainbolt

# what's heppening here
terry.swim()

# its actually equivalent to:
Person.swim(terry)

# we can take the function swim out of the Person class
swim = Person.swim

# this is called an unbound function - it is not glued to a particular object
print(swim) # <function Person.swim at 0x06737228>

# we can call it on any person
swim(terry)
swim(graham)

# lets take the function 'swim' from terry
terry_swim = terry.swim
print(terry_swim) # <bound method Person.swim of Person('Terry Gilliam')>

# this function is bound to Terry Gilliam. 
# the 'self' parameter has been determined - we dont need any parameters
terry_swim()

try:
    terry_swim(graham)
except Exception as ex:
    print('you cannot change the object:', ex)

def sing(self):
    print(self, 'is singing')

# add sing() method to Person class
# from this moment on, any Person object also has a sing() method 
Person.sing = sing
print(sing)
print(terry.sing)
terry.sing()
print()

# can we add functions to a particular instance?
# just putting a function in an instance does not bind it to the instance
print(train) # the train() function
usainbolt.train = train
try:
    usainbolt.train() # this won't work
except Exception as ex:
    print('the train function is not bound:', ex, '\n')
    
# here's how we can can do it
# bind the function `train` to think it bound to usainbolt
train_usain = train.__get__(usainbolt, type(usainbolt))
print(train_usain)
train_usain()
usainbolt.train = train_usain
usainbolt.train()

from pprint import pprint
pprint(usainbolt.__dict__)
print()

pprint(usainbolt.__class__) # OlympicRunner
pprint(OlympicRunner.__dict__)
print()

pprint(OlympicRunner.__base__)
pprint(Person.__dict__)

run = getattr(usainbolt, 'run') # equivalent to usainbolt.run
print(run)

time_machine = attribute_usain_doesnt_have = getattr(usainbolt, 'time_machine', None)
print(time_machine) if time_machine is not None else print('no time machine yet')

import inspect
pprint(inspect.getfile(inspect)) # what .py created this module?
print()

pprint(inspect.getmembers(usainbolt, inspect.ismethod)) # get methods of usainbolt
print()

pprint(inspect.signature(train)) # returns the parameters of the function train()
print()

# objects of type Person first look for methods in class Person, then in class object
print(Person.__mro__, '\n')

# objects of type OlympicRunner first look for methods in class OlympicRunner, then in Person, then in class object
print(OlympicRunner.__mro__, '\n')

terry.swim()     # Person.swim(terry)
usainbolt.swim() # Person.swim(usainbolt)
terry.run()      # Person.run()
usainbolt.run()  # OlympicRunner.run(usainbolt)

class InstagramCelebrity(Person):        
    def run(self):
        Person.run(self) # call the run() method defined in class Person
        print(self.name, 'taking picture and uploading to instagram')

kardashian = InstagramCelebrity('Kardashian')
kardashian.run()

class InstagramCelebrity(Person):        
    def run(self):
        super().run() # calls the run() on the first base class that has a run() function
        print(self.name, 'taking picture and uploading to instagram')

kardashian = InstagramCelebrity('Kardashian')
kardashian.run()

class Comedian(Person):
    # this code is run NOW, when this class is being defined
    funny_level = 0

# therefore we can access Comedian.funny_level even BEFORE creating any instances
print(Comedian.funny_level) # 0
pprint(Comedian.__dict__) # funny_level is an attribute of Comedian class
Comedian.funny_level = 50

# create a comedian instance
eric = Comedian('Eric Idle')

#  eric doesn't its own funny_level attribute
pprint(eric.__dict__)

# eric.funny_level actually returns Comedian.funny_level
print(eric.funny_level) # 50 

# when we're assigning a value to eric.funny_level, we're actually ADDING a new attribute to eric's __dict__
eric.funny_level = 100
pprint(eric.__dict__)
print(eric.funny_level) # 100
print(Comedian.funny_level) # unchanged, it is still 50

def show_dict_helper(dict_): return [ k for k in dict_ if not k.startswith('__')]

class Test:
    
    print("computing squares:")
    squares = []
    for i in range(10):
        squares.append(i**2)
    print("finished computing squares:", squares)
        
    class InnerClass:
        print("Defining an inner function now")
        
    def myfunc(self):
        pass

        
print()        
pprint(Test.squares)
pprint(show_dict_helper(Test.__dict__)) # ['squares', 'i', 'InnerClass', 'myfunc']      

## How is it different from __init__ methods?
class Comedian2(Person):
    
    # code to *define* the __init__ function runs *now*
    # the __init__ function goes into Comedian2.__dict__
    def __init__(self, name, funny_level):
        # this code runs only when we are creating an instance
        # name, funny_level end up in the instance's dict
        self.name = name
        self.funny_level = funny_level
        
eric2 = Comedian2('Eric Idle', funny_level=100)

# now Comedian2 only has attributes related to the class
pprint(Comedian2.__dict__) # mostly just __init__

# and our instance eric2 has all the attributes related to instances
pprint(eric2.__dict__) # 'name' and 'funny_level'

import random
class ImprovComedian(Comedian2):
    JOKES = [
        'why is 10 afraid of 7? because 7 8 9',
        'How did 10 die ? he was in the middle of 9 11',
        "What's the difference between insomnia and amnesia? " \
            "I stayed up all night yesterday trying to remember ...",
        "what's a freudian slip? its when you mean one thing but you say your mother"
    ]
        
    # return random joke for every attribute that doesn't already exist in the class
    def __getattr__(self, name):
        return f"so regarding {name}... " + random.choice(type(self).JOKES)    

    
seinfeld = ImprovComedian('Seinfeld', 100)
print(seinfeld.name, seinfeld.funny_level) # normal attributes continue to work

# when you ask for attributes that "don't exist" __getattr__ gets called
print(seinfeld.numbers)
print(seinfeld.sleep)