# int
a = 5
print(a)
print(type(a))

# string
a = '5'
print(a)
print(type(a))

# list
b = [1,2,3,4]
print(b)
print(type(b))
print(b[0])

b[0] = None
print(b[0])

print(b[4])

# tuple
c = (1,2,3,4)
print(c)
print(type(c))

print(c[0])
c[0] = None

# dict

d = {'d': 1, 'e': 2}
print(d)
print(type(d))

a_list = [[1,2,3], [4,5,6], [7,8,9], None]
print(len(a_list))
print(a_list[0])
print(a_list[0][1])

# tuple of lists and None
b_tuple =([1,2,3], [4,5,6], [7,8,9], None)

for _ele in b_tuple:
    print(_ele)

b_tuple[0] = [1,2,3]

b_tuple[0][0] = 2

for _ele in b_tuple:
    print(_ele)

### Function as object

class Foo:
    def method1(self):
        print('Foo.method1')

    def method2(self):
        print('Foo.method2')


# class definition
d =[Foo.method1, Foo.method2]


for _ele in d:
    print(_ele)


# class instance
foo = Foo()

e =[foo.method1, foo.method2]

for _ele in e:
    print(_ele)
    _ele()

### How call a function

def foo(a, b):
    print(a)
    print(b)


foo(1, 2) # -> a=1, b=2 # positional arguments
foo(b=1, a=2) # -> a=2, b=1 # named arguments, key-value arguments

# without args
def func(a, b, c):
    print(a)
    print(b)
    print(c)

func(1,2,3)
# func(1, 2)
# func(1,2, 3, 4)

# with args
def func(a, *args):
    print(a)
    print(args)
    print(type(args))
    print(f'len: {len(args)}')

func(1,2,3)

func(1)
func(1, 2)
func(1,2, 3, 4)

# args is just keyword, the improtant is *
def foo(*my_attributes):
    print(my_attributes)


foo(1,2,3,4,5,6,7,8)

def boo(a, b, *args):
    print(f'{a}, {b}, {args}')

boo (1,2,3)

def fun(a, b, c):
    print(a, b, c)

list_ = [1, 2, 3]

fun(list_[0], list_[1], list_[2])

fun(*list_)

# *list_ = list_[0], list_[1], list_[2]

list_ = [3, 4, 5]

my_list = [1, 2, *list_]
print('my_list')
print(my_list)

list_ = [1, 2, 3, 4, 5]
first, *rest = list_
print(list_)
print(first)
print(rest)
print(type(rest))

### assigment -> unused value
list_ = [1, 2, 3, 4, 5]
first, _, *rest = list_ # best practise to use _ for unused values
print(first)
print(rest)

### Solution
def my_sum(first, *args):
    total = first
    for arg in args:
        total += arg # => total = total + arg
    return total


### Solution 2
def my_sum(first, *args):
    return sum([first, *args])

### Expected behaviour
print(my_sum(2, 3, 4)) # ==> 9
print(my_sum(2)) # ==> 2
print(my_sum())  # ==> TypeError

def foo(a,b, **kwargs):
    print('a =', a)
    print('b =', b)
    print('kwargs =', kwargs)
    print(type(kwargs))

foo(2, 3, c=4, d=5)

### Hint -- dict builtin function
a = dict(a=2, b=3, c=None)
print(a)

b = {'a': 2, 'b':3, 'c': None}
print(b)

assert a == b

### Hint -- dict usage
d = {'a': 2, 'b': 3}
print(d)

d['key'] = 'value'
d['c'] = 5
print(d)

### Hint -- third way
numbers = [1, 2, 3, 4, 5]
def f(number):
    return number%2 == 0
print(list(filter(f, numbers)))

f = None
g = None
print(id(f), id(g))

# f is g and g is None


r = 1
t = 2
print(id(r), id(t))

### Use `a is None` instead of `a == None` because of the following trap:
class A:
    def __eq__(self, other):
        return True

a = A()
b = None
print(a == b) # => a.__eq__(b)
print(a is b) # id(a) == id(b)

### Solution 1

def dict_without_Nones(**kwargs):
    result = kwargs.copy()
    for k, v in kwargs.items():
        if v is None:
            result.pop(k)
    return result

### Solution 2
def dict_without_Nones_1(**kwargs):
    result = {}
    for k, v in kwargs.items():
        if v is not None:
            result[k] = v
    return result

### Solution 3
def dict_without_Nones_2(**kwargs):
    return {k: v for k, v in kwargs.items() if v is not None}

### Dict comprehension
# from flat values 
print({x: bin(x) for x in range(5)})

# from another dict
input_dict = dict(a=1, b=2, c=3, d=None)
output_dioct = {k: v for k, v in input_dict.items() if v is not None}


### Solution 3
def is_not_None(item):
    # item is a pair of (key, value)
    key, value = item
    return value is not None

def dict_without_Nones_3(**kwargs):
    return dict(filter(is_not_None, kwargs.items()))

### Expected behaviour

assert dict_without_Nones(a="1999", b="", c=None) == {'a': '1999', 'b': ''}

%timeit dict_without_Nones(a="1999", b="", c=None)
%timeit dict_without_Nones_1(a="1999", b="", c=None)
%timeit dict_without_Nones_2(a="1999", b="", c=None)
%timeit dict_without_Nones_3(a="1999", b="", c=None)


# ns = 10(-9) nanoseconds
# us = 10(-6) microseconds

### What timeit does?
from time import time

for run in range(7):
    s = time()
    for i in range(1000000):
        dict_without_Nones(a="1999", b="", c=None)
    e = time()
    print((e-s)/1000000)

### Using timeit outside IPython and Jupyter Notebook
import timeit

code = 'dict_without_Nones(a="1999", b="", c=None)'
gl = {'dict_without_Nones': dict_without_Nones}
results = timeit.repeat(code, globals=gl)
print(results)

def foo(a, b, c):
    print('a =', a)
    print('b =', b)
    print('c =', c)

d = {'a': 2, 'b': 3, 'c': 4}
foo(**d)  # equivalent to foo(a=2, b=3, c=4)

# A trap!
foo(*d)

### default value
from numpy import cov


def add(a, b, c, convert_to_float=False):
    if convert_to_float:
        a = float(a)
        b = float(b)
        c = float(c)
    return a + b + c

print(add(1,2,3, convert_to_float=True))

### Wrong solution

def append_func(item, list_=[]):
    list_.append(item)
    return list_



### Correct solution

def append_func(item, list_=None):
    if list_ is None:
        list_ = []
    list_.append(item)
    return list_

### Expected behaviour
print(append_func('e'))
print(append_func('f'))

assert append_func(3, [1, 2]) == [1, 2, 3]
assert append_func('c', ['a', 'b']) == ['a', 'b', 'c']
assert append_func('e') == ['e']
l = ['a', 'b']
assert append_func('e', l) == ['a', 'b', 'e']
assert l == ['a', 'b', 'e']
assert append_func('f') == ['f']

### This is how Python works

def append_func(item, list_=[]):
    list_.append(item)
    return list_



# default_list = []
# def append_func(item, list_):
#     if list_ nie zostało przekazane:
#         list_ = default_list
#     list_.append(item)
#     return list_


### This is how Python works 2
def generate_list():
    print('Generating a new empty list...')
    return []

def append_func(item, list_=generate_list()):
    list_.append(item)
    return list_


### Correct solution

def append_func(item, list_=None):
    if list_ is None:
        list_ = []
    list_.append(item)
    return list_

print(append_func.__defaults__)

items = ['Alice', 'has', 'a', 'cat']
print(sorted(items)) # => A is lower than a as the python string definition says that
print(sorted(items, key=len))

def my_function(item):
    return len(item)

print(sorted(items, key=my_function))

# or simpler:

print(sorted(items, key=lambda item: len(item))) # lambda x: func(X)

files = ['data.txt', 'text.csv', 'data.csv', 'text.json', 'asd.dfg.json']

# output ['text.csv', 'data.csv', 'text.json', 'asd.dfg.json', 'data.txt']

### Hints
filename = 'data.txt'
print(filename.split('.'))

### Solution
print(sorted(files, key=lambda filename: filename.split('.')[-1]))

('csv', 'data.csv') < ('csv', 'text.csv')

def get_extension(filename):
    return filename.split('.')[-1]
print((get_extension('data.txt'), 'data.txt'))

files = ['data.txt', 'text.csv', 'data.csv', 'text.json']

def get_extension(filename):
    return filename.split('.')[-1]
print(sorted(files, key=lambda filename: (get_extension(filename), filename)))

def foo(
    a: int,
    b: str,
    c: dict,
    d: list | None = None,
) -> None:
    '''
    ble ble 
    '''
    pass


foo((1,), (2,), (3,), (4,))
print(foo.__annotations__)

def foo():
    x: int
    x = 3
    y: float = 2.0
    

c = 5
def bar():
    c: str
    print(c)

bar()

def generate_adder(x):
    def add(y):
        return x + y
    return add

add_5 = generate_adder(5)  # add_5 combines add function AND the value of x
print(add_5)
print(add_5(10))
print(add_5(15))

print(add_5.__closure__)  # add_5 really is more than just add function

# Addition closure
def addition(n):
    def inner_function(x):
        return x + n
    return inner_function

add_10 = addition(10)
print(add_10.__closure__)
print(add_10.__closure__[0].cell_contents)

# Subtraction closure
def subtraction(n):
    def inner_function(x):
        return x - n
    return inner_function

subtract_3 = subtraction(3)
print(subtract_3.__closure__)
print(subtract_3.__closure__[0].cell_contents)

# Division closure
def division(n):
    def inner_function(x):
        return x / n
    return inner_function

divide_by_2 = division(2)
print(divide_by_2.__closure__)
print(divide_by_2.__closure__[0].cell_contents)

# Complex operation closure (power)
def power_operation(n):
    def inner_function(x):
        return x ** n
    return inner_function

power_of_4 = power_operation(4)
print(power_of_4.__closure__)
print(power_of_4.__closure__[0].cell_contents)

import functools

def shouter(func):
    print('wywolanie dekorowania funkcji')
    @functools.wraps(func)  # takes care of func.__doc__ and func.__name__
    def wrapper(*args, **kwargs):
        print('Before foo')
        result = func(*args, **kwargs)
        print('After foo')
        return result
    return wrapper

@shouter
def foo(a):
    '''Docstring'''
    print("Message:", a)
    return 42

# foo = shouter(foo)  # equivalent

result = foo(a="Inside")  # delegates to wrapper
print("result =", result)

print(foo.__doc__)
print(foo.__name__)

@shouter
def bar(a, b):
    print("Bar")
    
bar(1, 2)

### Initial Code
def suppress_exceptions(func):
    @functools.wraps(func)  # takes care of func.__doc__ and func.__name__
    # wrapper definition starts
    def wrapper(*args, **kwargs):
        try:
            return func(*args, **kwargs)
        except Exception:
            return None
    # wrapper definiton ends
    return wrapper

### Expected Behaviour

@suppress_exceptions
def foo(a, b):
    return a/b

print(foo(4, 2))  # ==> 2
print(foo(4, 0))  # ==> return None instead of an exception

from time import time, sleep

a = 5

# 1
print('jestem poza foo') # global namespacem kod wykonuje sie od razu (pierwsze przejscie)



### Initial Code
# 2
def suppress_exceptions(func):
    # 4, 9
    print(f'decor outter: {func.__name__}')
    # 5, 10
    @functools.wraps(func)  # takes care of func.__doc__ and func.__name__
    # wrapper definition starts
    # 6, 11
    def wrapper(*args, **kwargs):
        # 13
        try:
            # 4
            print(f'decor inner: {func.__name__}')
            return func(*args, **kwargs)
        except Exception:
            return None
    # wrapper definiton ends
    # 7
    return wrapper

# 3
@suppress_exceptions # ==> foo = supress_exceptions(foo)
def foo():
    b = 6
    print('jestem w foo') # local namespace funkcji 


# 8
@suppress_exceptions # ==> boo = supress_exceptions(boo)
# comment
def boo():
    print('jestem w boo')



# 12
foo()
# boo()

## Solution
def timeit(func):  # func == original bar
    @functools.wraps(func)  # takes care of func.__doc__ and func.__name__
    def wrapper(*args, **kwargs):
        start = time() # timestamp 
        try:
            return func(*args, **kwargs)
        finally:
            elapsed = time() - start # timestamp
            print(f"Elapsed {elapsed:.3f} sec")
    return wrapper

### Expected behaviour
# @timeit
def bar(a, b):
    sleep(0.1)
    retval = a / b
    sleep(0.1)
    return retval

bar = timeit(bar)

# Sample function calls
print(bar(4, 2))  # Expected output: Elapsed 0.204 sec, 2.0
# Elapsed 0.207 sec
# 2.0




print(bar(4, 0))  # Expected output: Elapsed 0.104 sec, Traceback with ZeroDivisionError
# Elapsed 0.104 sec
# raise Zero Division Error

### Solution
def retry_three_times(func):
    @functools.wraps(func)  # takes care of func.__doc__ and func.__name__
    def wrapper(*args, **kwargs):
        for _ in range(2):
            try:
                return func(*args, **kwargs)
            except Exception:
                pass
        return func(*args, **kwargs)
    return wrapper

### Expected Behaviour 1: Function Succeeds on First Attempt
@retry_three_times
def works():
    return 42

print(works())

### Expected Behaviour 2: Function Always Fails
@retry_three_times
def always_fails():
    raise Exception

print(always_fails())

### Expected Behaviour 3: Function Succeeds on Third Attempt
trial = 0

@retry_three_times
def works_on_third_trial():
    global trial
    trial += 1  # trial = trial + 1
    if trial == 3:
        return 42
    else:
        raise Exception

print(works_on_third_trial())  # Expected output: 42

### Solution
test_functions = []

def test(func):
    test_functions.append(func)
    return func

import functools

# ### Solution
test_functions = []

def test(func):
    test_functions.append(func)
    return func

### Expected Behaviour
@test
def a():
    print("a()")
    
@test
def b():
    print("b()")
    
def c():
    print("c()")

print('a =', a)
print(test_functions)
assert test_functions == [a, b]
for test_function in test_functions:
    test_function()

def shouter_ex(msg):
    def decor(func):  # func == spam
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            print("Start:", msg)
            try:
                return func(*args, **kwargs)
            finally:
                print("End:", msg)
        return wrapper
    return decor

@shouter_ex("Decorate spam") # tahe shouter_ex and run it with argument: "Decorate spam" -> return decor  => @decor => decor(spam)
def spam(a, b):
    '''Docstring'''
    return a/b

# is equivalent to: spam = shouter_ex("Decorate spam")(spam)

# or is equivalent to:

dec = shouter_ex("Decorate spam")
# dec == decor

@dec
def spam(a, b):
    '''Docstring'''
    return a/b

print(spam(4, 2))

### SOLUTION
def suppress_exceptions_ex(exception=Exception, value_on_exception=None):
    def decor(func):  # func == spam
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except exception:
                return value_on_exception
        return wrapper
    return decor

### Expected Behaviour

# BAD # @suppress_exceptions_ex # ==> egg=supress_exception_ex(egg)
# GOOD # @suppress_exceptions_ex() # ==> egg = supress_exceptions_ex()(egg)
@suppress_exceptions_ex(exception=ZeroDivisionError, value_on_exception=0.0)
def egg(a, b):
    return a/b

print(egg(4, 2))
print(egg(4, 0)) # ==> return 0 instead ZeroDivision Error
print(egg('asdf', 'qwer'))  # ==> TypeError

class Person:  # class header
    phone = None # class atrribute (variable)
    phones = [] # class atrribute (variable)
    
    # __init__ is a one of first functions called during class instantiation
    def __init__(self, name): # method definition
        self.name = name # instance attribute

p1 = Person('John')
p2 = Person('Alice')

print(p1.name)
print(p2.name)

p1.name = 'Bob'

print(p1.name)
print(p2.name)

### Case 1
class Person:
    phone = None
    
    def __init__(self, name):
        self.name = name

    def mymethod(self):
        pass

p1 = Person('John')
p2 = Person('Alice')

print('p1.phone =', p1.phone)
p1.phone = 98765

print('p1.phone =', p1.phone)
print('p2.phone =', p2.phone)

print('p1.__dict__ =', p1.__dict__)
print('p2.__dict__ =', p2.__dict__)
print('Person.__dict__ =', Person.__dict__)
p2.mymethod()

### Case 2
class Person:
    phones = []
    instances = []

    def __init__(self, name):
        self.name = name

p1 = Person('John')
p2 = Person('Alice')

print('p1.phones =', p1.phones)

p1.phones.append(987654)

print('p1.phones =', p1.phones)
print('p2.phones =', p2.phones)

print('p1.__dict__ =', p1.__dict__)
print('p2.__dict__ =', p2.__dict__)
print('Person.__dict__ =', Person.__dict__)

### Case 3
class Person:
    phones = []
    
    def __init__(self, name):
        self.name = name

p1 = Person('John')
p2 = Person('Alice')
print('p1.phones =', p1.phones)

p1.phones = [98765]
p1.phones.append(12345)
print('p1.phones =', p1.phones)
print('p2.phones =', p2.phones)

print('p1.__dict__ =', p1.__dict__)
print('p2.__dict__ =', p2.__dict__)
print('Person.__dict__ =', Person.__dict__)

print(Person.phones)
print(p1.__class__.phones) # informational
print(p1.phones)

class BankAccount:
    def __init__(self, initial_balance):
        self._balance = initial_balance
        
    def print_balance(self):
        print(self._balance)

    def get_balance(self):
        return self._balance

account = BankAccount(100.0)
print(account.get_balance())  # proper usage
print(account._balance) # really no protection, it's only a convention
print(account.__dict__)

class BankAccount:
    def __init__(self, initial_balance=0):
        self.__balance = initial_balance

    def withdraw(self, amount):
        self.__balance -= amount

    def deposit(self, amount):
        self.__balance += amount

    def info(self):
        print(f"Balance is {self.__balance}")

account = BankAccount(100.0)


print(account.__dict__)

# print(account.__balance)  # => AttributeError
# print(account._BankAccount__balance)

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    @property
    def is_zero(self):
        return self.x == 0 and self.y == 0

p1 = Point(2, 3)
p2 = Point(0, 0)

print(p1.is_zero)
print(p2.is_zero)

# p1.is_zero = False # ==>  Atribute Error - read only

from math import sqrt

class Vector:
    def __init__(self, x, y): # always starts in 0,0
        self.x = x
        self.y = y
        
    # getter (read-only property)
    @property # telloing this is getter (read-only)
    def length(self):  # method definiton with a name of our dynamic attribute - property
        return sqrt(self.x**2 + self.y**2) # returned value, if I wish to keep it as internal variable, the best practise is to use _name
    
    # setter (requires getter)
    @length.setter  # must be the same name (length) as above
    def length(self, new_length):  # the same here - must be the same name (length) as above
        if new_length < 0:
            raise ValueError("Negative length is invalid")
        elif new_length == 0:
            self.x = 0
            self.y = 0
        elif self.length == 0:
            raise ValueError("Ooops, unknown direction")
        else:
            factor = new_length / self.length
            self.x *= factor
            self.y *= factor

v = Vector(3, 4)
print(v.length)

v.length = 10  # delegates to Vector.length(self=v, new_length=10)
print(v.length, v.x, v.y)

### Expected Behaviour
v = Vector(3, 4)
v.length = 10
assert (v.x, v.y) == (6, 8)

u = Vector(0, 0)
u.length = 0
assert (u.x, u.y) == (0, 0)
# u.length = 10  # ==> ValueError

### Before
class Connection:
    def __init__(self, target):
        self.target = target
        self.state = 'disconnected'
        
    def connect(self):
        ip, port = self.target.split("::")
        print(f"Connecting to ip={ip} port={port}")
        self.state = 'connected'
        
    def disconnect(self):
        ip, port = self.target.split("::")
        print(f"Disconnecting from ip={ip} port={port}")
        self.state = 'disconnected'

c = Connection('127.0.0.1::80')
c.target = '127.0.0.1::60' # overwrite target - should be allowed
assert c.target == '127.0.0.1::60'
assert c.state == 'disconnected'
c.connect()
assert c.state == 'connected'
c.target = '127.0.0.1::40'  # should be disallowed
c.disconnect()
c.state = 'connected'  # should be disallowed


# target writable in dosconnected tsate only
# state is private (read-only) to class

### After
class Connection:
    def __init__(self, target):
        self._connected = False
        self.target = target  # delegates to target setter
        
    def connect(self):
        print(f"Connecting to ip={self._ip} port={self._port}")
        self._connected = True
        
    def disconnect(self):
        print(f"Disconnecting from ip={self._ip} port={self._port}")
        self._connected = False
        
    @property
    def target(self):
        return f"{self._ip}::{self._port}"
    
    @target.setter
    def target(self, new_target):
        if self._connected:
            raise ValueError("Cannot change target when connected")
        self._ip, self._port = new_target.split("::")
    
    @property
    def state(self):
        # if self._connected:
        #     return 'connected'
        # else:
        #     return 'disconnected'
        return 'connected' if self._connected else 'disconnected'

### Expected Behaviour
c = Connection('127.0.0.1::80')
c.target = '127.0.0.1::60'
assert c.target == '127.0.0.1::60'
assert c.state == 'disconnected'
c.connect()
assert c.state == 'connected'
# c.target = '127.0.0.1::40'  # ==> ValueError
c.disconnect()
# c.state = 'connected'  # ==> AttributeError

assert set(c.__dict__.keys()) == {'_ip', '_port', '_connected'}
# c.target and c.state should be properties
# c.target should be writtable only when disconnected
# c.state should be read-only

class Factorial:
    def __init__(self):
        self.cache = {0: 1}

    def __call__(self, n): # it can take any arguments, similar to a regullar function
        if n not in self.cache:
            print(f'Computing fact({n})')
            self.cache[n] = n * self(n-1)
        return self.cache[n]

fact = Factorial()  # delegates to __init__ and creates new object
print(fact(3))  # delegates fact.__call__(3)
print(fact(3))  # delegates fact.__call__(3)

print(fact.cache)

assert fact(3) == 3 * 2 * 1
assert fact(5) == 5 * fact(4)

print(fact.cache)

# Cache of caches
class CachedFunction:
    class _SingleFunction:
        def __init__(self, function):
            self._function = function
            self._cache = {}

        def __call__(self, *args):
            if args not in self._cache:
                self._cache[args] = self._function(*args)
            return self._cache[args]

    def __init__(self):
        self.functions = {}

    def __call__(self, *args):
        ## ?? which function is triggered
        if args not in self._cache:
            self._cache[args] = self._function(*args)
        return self._cache[args]

    def add_function(self, func):
        if func not in self.functions:
            self.functions[func] = self._SingleFunction(func)

        return 


# SOLUtiON !!!
# Your Code Here
class CachedFunction:
    def __init__(self, function):
        self._function = function
        self._cache = {}

    def __call__(self, *args):
        # ask for permission
        # if args not in self._cache:
        #     self._cache[args] = self._function(*args)
        # return self._cache[args]

        # ask for forgiveness
        try:
            return self._cache[args]
        except KeyError:
            ret = self._cache[args] = self._function(*args)
            return ret
        except TypeError: # when args unhashable
            return self._function(*args)

### Expected Behaviour
from time import sleep

def long_computations(a, b):
    print("Computations going on...")
    sleep(1)
    return a + b

cached_long_computation = CachedFunction(long_computations)  # calls __init__


def foo():
    pass

cached_foo = CachedFunction(foo)

# Imagine there are more functions we need to cache, 
# so we don't want to put the caching logic inside 
# long_computations function.

print(cached_long_computation(2, 3))  # calls __call__(2, 3) takes 10s

print(cached_long_computation(2, 3))  # no computations

@CachedFunction
def cached_inc(a):
    print(f'Executing inc({a})')
    sleep(2)
    return a + 1

cached_inc = CachedFunction(cached_inc)
print(cached_inc(3))
print(cached_inc(3))

### Ask for permission
numbers = [42, 20, 0]
if len(numbers) > 2:
    # 100 linii kodu
    third = numbers[2]
else:
    third = None


# Ask for forgiveness
try:
    third = numbers[2]
    inversion = 1 / third
except IndexError:
    third = None
    inversion = None
except ZeroDivisionError:
    print("zero division")

class Base:  # inherits implicitly from object = Base(object):
    def base_method(self):
        print('base_method')


class Child(Base):
    def child_method(self):
        print('child_method')

child = Child()
child.child_method()
child.base_method()

# Where do we look for base_method?
print(child.__dict__)
print(Child.__dict__)
print(Base.__dict__)

base = Base()
base.base_method()
base.child_method()

class Base:
    def foo(self):
        print('Base.foo')

    def bar(self):
        print('Base.bar')

    def base_method(self):
        print('Base.base_method')

    def foo2(self):
        raise NotImplementedError # tell other developers that they have to implement the method when inheriting the class

class Child(Base):
    def foo(self):
        super().foo()
        print('Child.foo')

    def bar(self):
        print('Child.bar')

child = Child()

child.bar()

child.foo()

child.base_method()

child.foo2()

class Point:
    a = 0

    def __init__(self, x, y):
        self.x = x
        self.y = y

class Point3D(Point):

    def __init__(self, x, y, z):
        super().__init__(x, y) # run overoaded function from parent on child instance
        self.z = z


p3D = Point3D(2, 3, 4)
print(p3D.__dict__)
print(p3D.z)
print(p3D.a)

class MyObject:  # implicitly inherits from object
    pass

mo = MyObject()

print(dir(mo))  # all attributes of an object

print(mo.__str__())
print(str(mo))
print(mo)

### Initial Code
class MyObject:
    def __str__(self):
        default = super().__str__()
        return (f"The default __str__ result is {default!r}, "
                "however here we modified it.")
    
o = object()
print(o)

mo = MyObject()
print(mo)

mo = MyObject()
MyObject.__str__ = lambda self: "qwer"
print(mo)

x = MyObject()
print(str(x))  # x.__str__() 
print(repr(x))  # x.__repr__()

### 1st Use Case - Counting Distinct Objects

fruits = ['apple', 'orange', 'apple']
counts = {}
for key in fruits:
    if key not in counts:
        counts[key] = 0
    counts[key] += 1  # counts[key] = counts[key] + 1
    # or counts[key] = counts.get(key, 0) + 1
assert counts == {'apple': 2, 'orange': 1}

from collections import defaultdict

fruits = ['apple', 'orange', 'apple']
counts = defaultdict(int)  # int() == 0
# counts = defaultdict(lambda: 0)
for key in fruits:
    counts[key] += 1
assert counts == {'apple': 2, 'orange': 1}

### 2nd Use Case - MultiDictionary:

fruits = ['apple', 'orange', 'banana']
d = {}
for value in fruits:
    key = len(value)
    if key not in d:
        d[key] = []
    d[key].append(value)
assert d == {5: ['apple'], 6: ['orange', 'banana']}

fruits = ['apple', 'orange', 'banana']
d = defaultdict(list)
# d = defaultdict(lambda: [])
for value in fruits:
    key = len(value)
    d[key].append(value)
assert d == {5: ['apple'], 6: ['orange', 'banana']}

print(d)

class Foo:
    def __getitem__(self, key):
        return None

d = Foo()
print(d[1])

### Initial Code

class DefaultDict(dict):
    def __init__(self, init_value_factory):
        self._init_value_factory = init_value_factory
    
    def __getitem__(self, key):  # called by d[key] syntax
        ### Ask for permission
#         if key not in self:
#             self[key] = self._init_value_factory()
#         return super().__getitem__(key)
#         # return super()[key]  # doesn't work
        
        ### Ask for forgiveness
        try:
            return super().__getitem__(key)
        except KeyError:
            value = self[key] = self._init_value_factory()
            return value
        

### Solution 3
# __missing__ (key)
# This method is called by the __getitem__() method of the dict class
# when the requested key is not found; whatever it returns or raises is
# then returned or raised by __getitem__() . Note that __missing__() is not
# called for any operations besides __getitem__()
class DefaultDict(dict):
    def __init__(self, init_value_factory):
        self._init_value_factory = init_value_factory

    def __missing__(self, key):
        value = self[key] = self._init_value_factory()
        return value

### Expected Behaviour

d = DefaultDict(list)
assert d['a'] == []
d['b'].append(2)
assert d['b'] == [2]

d = DefaultDict(int)
d['asdf'] += 1
assert d['asdf'] == 1

class Foo:
    def __init__(self):
        print("Constructor")

    def __str__(self):
        return "Foo!!!"

    def __getitem__(self, key):
        if key >= 5:
            raise IndexError
        return key + 100

    # def __len__(self):
    #     return 5

f = Foo()  # f = Foo.__init__()
print(str(f))  # f.__str__()
print(f[3])  # f.__getitem__(3)
# print(len(f))

for item in f:  # gets item[0], item[1] and so on until an error occures
    print(item)

print(list(f))

# SOLUTION

class Account:
    def __init__(self, initial_balance=0): 
        self._balance = initial_balance
        self._transactions = []
    
    def deposit(self, amount): 
        self._balance += amount
        self._transactions.append(amount)
    
    def withdraw(self, amount): 
        self._balance -= amount
        self._transactions.append(-amount)
    
    def __getitem__(self, index): 
        return self._transactions[index]

    @property
    def balance(self):
        return self._balance

### Expected behaviour
acc = Account(initial_balance=0)
assert acc.balance == 0
# acc.balance = 0  # ==> AttributeError: can't set a property
acc.deposit(1000)
acc.withdraw(500)
acc.deposit(1000)
assert acc.balance == 1500
assert acc[0] == 1000
assert acc[1] == -500
assert acc[2] == 1000
# acc[3] # ==> IndexError
for transaction in acc:
    print(transaction)
print("Transactions:", list(acc))

class Boo:

    def __init__(self, value):
        self.value = value

    def __eq__(self, other):
        return self.value == other.value
    
    def __lt__(self, other):
        return self.value < other.value
    
    def __str__(self):
        return self.value
    
    def __repr__(self):
        return str(self.value)

b1 = Boo(6)
b2 = Boo(5)

print(b1 == b2)

print(sorted([b1,b2]))

print(b1 > b2)

### Solution
from functools import total_ordering

@total_ordering
class Account:
    def __init__(self, initial_balance=0):
        self._balance = initial_balance
        
    def __eq__(self, other):
        return self._balance == other._balance

    def __lt__(self, other):
        return self._balance < other._balance
    
### Expected Behaviour
acc1 = Account(initial_balance=1000)
acc2 = Account(initial_balance=1000)

print(acc1 == acc2)  # acc1.__eq__(acc2)
print(acc1 != acc2)  # acc1.__ne__(acc2)  # not acc1 == acc2
print(acc1 > acc2)  # acc1.__gt__(acc2)   # not (acc1 < acc2 or acc1 == acc2)
print(acc1 >= acc2)  # acc1.__ge__(acc2)  # not acc1 < acc2
print(acc1 < acc2)  # acc1.__lt__(acc2)
print(acc1 <= acc2)  # acc1.__le__(acc2)  # acc1 < acc2 or acc1 == acc2

### Expected Behaviour
acc1 = Account(initial_balance=1000)
acc2 = Account(initial_balance=1500)
assert acc1 < acc2  # delegates to acc1.__lt__(acc2)
assert acc2 > acc1

# pip install dataclasses  # for Python 3.6 and earlier
from dataclasses import dataclass  # backport for Python 3.6 and earlier

@dataclass
class Point:
    x: float
    y: float
    z: float = 0

p = Point(2, 3, 0)
print(p.x)
print(p.y)
print(p.z)
print(p)

r = Point(2, 3)  # Uses default value z=0
print(r)

print(p == r)  # Automagical support for comparisions

### Initial Code
from dataclasses import dataclass
from datetime import datetime

# Hint: datetime.now() to get current time
print(repr(datetime.now()))

# SOLUTION
from dataclasses import field

@dataclass
class Deposit:
    amount: float
    # time: datetime = field(default_factory=lambda: datetime.now())
    time: datetime = field(default_factory=datetime.now) # ==> pass definiton of datetime.now

@dataclass
class Withdraw:
    amount: float
    time: datetime = None  # field(default_factory=datetime.now)

    def __post_init__(self):
        if self.time is None:
            self.time = datetime.now()

class Account:
    def __init__(self, initial_balance=0): 
        self._balance = initial_balance
        self._transactions = []

    def deposit(self, amount): 
        self._balance += amount
        transaction = Deposit(amount)
        self._transactions.append(transaction)

    def withdraw(self, amount): 
        self._balance -= amount
        transaction = Withdraw(amount)
        self._transactions.append(transaction)

    def __getitem__(self, index): 
        return self._transactions[index]

    @property
    def balance(self):
        return self._balance

### Expected behaviour
acc = Account(initial_balance=0)
assert acc.balance == 0
# acc.balance = 0  # ==> AttributeError: can't set a property
acc.deposit(1000)
acc.withdraw(500)
acc.deposit(1000)
assert acc.balance == 1500
for transaction in acc:
    print(transaction)

class Foo:

    numbers = []

    def method(self, a): # self = instance of Foo created by instance = Foo()
        print(self, a)

    @classmethod
    def class_method(cls, a):  # cls == Foo
        print(cls, a)


foo = Foo()
foo.method(2)

Foo.class_method((2))

foo.method(42)  # equivalent to Foo.method(f, 42)
foo.class_method(42)  # useless most of the time
Foo.method(f, 42)
Foo.class_method(42)

from datetime import datetime 
print(datetime.now())
print(datetime(2020, 1, 22))

@dataclass
class Date:
    day: int
    month: int
    year: int

    @classmethod
    def from_string(cls, date_as_string):
        day, month, year = date_as_string.split('-')
        return cls(int(day), int(month), int(year))  # Date.__init__(malloc(), day, month, year)

### Expected Behaviour

d1 = Date(20, 1, 2016)  # one way to create a Date object
d2 = Date.from_string('20-01-2016')  # another way
assert isinstance(d1.day, int)
assert (d1.day, d1.month, d1.year) == (20, 1, 2016)
assert (d2.day, d2.month, d2.year) == (20, 1, 2016)

%%writefile data.json
{
    "hasMore": false, 
    "participantList": [
        {
            "displayName": "Piotr Hyzy", 
            "firstName": "Piotr", 
            "isDeleted": false, 
            "lastName": "Hyzy", 
            "type": "REGULAR", 
            "userId": "35595c57-8871-44d8-9bf3-031f876c765e"
        }, 
        {
            "displayName": "Lukasz Kowalski", 
            "firstName": "Lukasz", 
            "isDeleted": false, 
            "lastName": "Kowalskit", 
            "type": "REGULAR", 
            "userId": "5aa65e6e-e450-4c95-839d-c8a973d18a51"
        }
    ]
}

import json

with open('data.json', 'r') as file:
    # data = json.load(file) # file as string
    data = json.loads(file.read()) # file as stream

print(data)
print(type(data))

user_by_id = {
    record["userId"]: record
    for record in data["participantList"]
}
for id_, user in user_by_id.items():
    print(f"{id_} -> {user}")

user_id = "35595c57-8871-44d8-9bf3-031f876c765e"
print(user_by_id[user_id]["firstName"])  # print firstName of user_id

# We have a list of objects
class Person:
    def __init__(self, id, name):
        self.id = id
        self.name = name

# Creating a list of Person objects
people = [
    Person(1, 'Alice'),
    Person(2, 'Bob'),
    Person(3, 'Charlie'),
]

# Creating a dictionary where the key is the 'id' attribute and the value is the entire object
people_dict = {person.id: person for person in people}


# Now we can quickly look up an object by its 'id'
person = people_dict[3]
print(person.name)  # Output: Bob

! wget https://hyzy.dev/trainings/interface-data.json

### Solution

import json

with open('interface-data.json') as stream:
    data = json.load(stream)


print("DN                                                 Description          Speed   MTU")
print("-------------------------------------------------- -------------------- ------- ------")
for interface in data["imdata"][:10]: # loop over data.imdata for first 10 elements
    # print(interface)
    _interface =  interface["l1PhysIf"]["attributes"]
    # print(_interface)
    dn = _interface["dn"]
    descr = _interface["descr"]
    speed = _interface["speed"]
    mtu = _interface["mtu"]
    # print fields formatted in columns
    print(f"{dn:50} {descr:20} {speed:7} {mtu:6}")

### Solution 2

import json

with open('interface-data.json') as stream:
    data = json.load(stream)

interfaces = [record["l1PhysIf"]["attributes"] for record in data["imdata"]]
# dns = [interface['dn'] for interface in interfaces]

print("DN                                                 Description          Speed   MTU")
print("-------------------------------------------------- -------------------- ------- ------")
for interface in interfaces[:10]:
    #print(interface)
    dn = interface["dn"]
    descr = interface["descr"]
    speed = interface["speed"]
    mtu = interface["mtu"]
    # print fields formatted in columns
    print(f"{dn:50} {descr:20} {speed:7} {mtu:6}")