# coding: utf-8
import unittest
 
def sum(a,b):
    return a+b
 
class ModuleTest1(unittest.TestCase):
    def setUp(self):
        pass

    def tearDown(self):
        pass

    def testsum1(self):
        self.assertEqual(sum(1,2),3)
        
    def testsum2(self):
        self.assertEqual(sum(1,-1),0)
 
if __name__ == '__main__':
    unittest.main()

..
----------------------------------------------------------------------
Ran 2 tests in 0.000s
 
OK

testSuite = unittest.TestSuite()
for testmethod in ('testsum1', 'testsum2'):
    testSuite.addTest(ModuleTest1(testmethod))
runner = unittest.TextTestRunner()
runner.run(testSuite)

from types import FunctionType

class ModuleTest(unittest.TestCase):
    def testA(self):
            self.assertEqual(True,True)


for key, value in ModuleTest.__dict__.items():
    if 'test' in key and isinstance(value, FunctionType):
            print key
# testA

class MyPrettyPrinter(pprint.PrettyPrinter):

    def format(self, _object, context, maxlevels, level):
        if sys.version_info[0] == 2:
            if isinstance(_object, unicode):  # pragma: no cover
                return "'%s'" % _object.encode('utf8'), True, False
            elif isinstance(_object, str):  # pragma: no cover
                _object = unicode(_object, 'utf8')
                return "'%s'" % _object.encode('utf8'), True, False
        return pprint.PrettyPrinter.format(self,
                                           _object,
                                           context,
                                           maxlevels,
                                           level)

class Service(object):
    data = []

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

class MyClass(object):
    class_var = 1

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

foo = MyClass(2)
bar = MyClass(3)

foo.class_var, foo.i_var
## 1, 2
bar.class_var, bar.i_var
## 1, 3
MyClass.class_var ## <— This is key
## 1

MyClass.__dict__
'''
dict_proxy({'__module__': '__main__', 
            '__doc__': None, 
            '__dict__': <attribute '__dict__' of 'MyClass' objects>, 
            '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, 
            'class_var': 2, 
            '__init__': <function __init__ at 0x10895e398>})
'''

foo = MyClass(2)
foo.class_var
## 1
MyClass.class_var = 2
foo.class_var
## 2

foo = MyClass(2)
foo.class_var
## 1
foo.class_var = 2
foo.class_var
## 2
MyClass.class_var
## 1

class Service(object):
    data = []

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

s1 = Service(['a', 'b'])
s2 = Service(['c', 'd'])

s1.data.append(1)

s1.data
## [1]
s2.data
## [1]

s2.data.append(2)

s1.data
## [1, 2]
s2.data
## [1, 2]

class Circle(object):
    pi = 3.14159

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

    def area(self):
        return Circle.pi * self.radius * self.radius

Circle.pi
## 3.14159

c = Circle(10)
c.pi
## 3.14159
c.area()
## 314.159

class Person(object):
    all_names = []

    def __init__(self, name):
        self.name = name
        Person.all_names.append(name)

joe = Person('Joe')
bob = Person('Bob')
print Person.all_names
## ['Joe', 'Bob']

# Model.py
from functools import reduce
from typing import List

class dataSchema(object):
    def __init__(self, name: str, age: int):
        self.setProperty(name, age)

    def setProperty(self, name: str, age: int):
        self.name = name
        self.age  = age

    def getProperty(self):
        if self.age == -1:
            raise Exception('not setted.')
        return {'name': self.name, 'age': self.age}

    def __str__(self):
        return "(name : {}, age : {})".format(self.name, self.age)

    def __repr__(self):
        return "{}(\"{}\", {})".format(self.__class__.__name__, self.name, self.age)


class Model(object):
    def __init__(self):
        self.data = []

    def append(self, item : dataSchema):
        self.data.append(item)

    def getDataList(self) -> List[dataSchema]:
        return self.data

    def getTotalAge(self) -> int:
        def getAge(data):
            return data.getProperty()['age']
        
        totalAge = reduce(lambda x, y: x+y, map(getAge,self.data))
        return totalAge


def makeAndGetDummyData():
    '''
    실험을 위한 dummy data
    '''
    a = dataSchema("OHS", 28)
    b = dataSchema("HYJ", 28)
    return [a, b]

# View.py
from typing import List


class View:
    def __init__(self):
        pass

    def viewTotalAgeAndCount(self, totAge:int, count:int) -> None:
        print("###### totalAge ######\n{}\n#### number of data ####\n{}".format(totAge, count))
    def viewDataList(self, nameList: List[str], ageList: List[int]) -> None:
        if len(nameList) != len(ageList):
            raise Exception('the length of nameList must be same with the one of ageList.')
        print("name\tage")
        print("----------------")
        for name, age in zip(nameList, ageList):
            print("{}\t{}".format(name, age))

# Controller.py
from Model import Model, makeAndGetDummyData
from View import View
from functools import reduce
from typing import List


class Controller(object):
    def __init__(self):
        self.model = Model()
        dummyDataList = makeAndGetDummyData()
        for d in dummyDataList:
            self.model.append(d)
        self.view = View()

    def touchDataList(self) -> None:
        dataList = self.model.getDataList()

        nameList = [d.getProperty()["name"] for d in dataList]
        ageList = [d.getProperty()["age"] for d in dataList]

        self.view.viewDataList(nameList, ageList)

    def touchTotalAgeAndCount(self) -> None:
        totalAge = self.model.getTotalAge()
        dataLen = len(self.model.getDataList())

        self.view.viewTotalAgeAndCount(totalAge, dataLen)

# mvc.py
from Controller import Controller
if __name__ == '__main__':
    controller = Controller()

    controller.touchDataList()
    controller.touchTotalAgeAndCount()

print "Hello world"

myVar = 5
myBool = True # or False
myFloat = 1.23

print myVar

def spam():
    eggs = 12
    return eggs

print spam()

myVar = 4 # 이것은 주석이다

"""이것은 모두 주석이다.
이것도 주석이다.
"""
myVar = 1

addition = 72 + 23
subtraction = 108 - 204
multiplication = 108 * 0.5
division = 108 / 9

eggs = 10 ** 2
print eggs

spam = 3 % 2
print eggs

name = "Ryan"
age  = "19"
food = "cheese"

escape = 'There\'s a snake in my boot!'

"""
string "PYTHON" 은 6개의 문자를 가지고있다.

+---+---+---+---+---+---+
| P | Y | T | H | O | N |
+---+---+---+---+---+---+
  0   1   2   3   4   5
"""
fifth_letter = "MONTY"[4]

print fifth_letter

parrot = "Norwegian Blue"
print len(parrot)

parrot = "Norwegian Blue"
print parrot.lower()

parrot = "norwegian blue"
print parrot.upper()

pi = 3.14
print str(pi)

print "Monty Python"
###
the_machine_goes = "Ping!"

print the_machine_goes
###
print "Spam " + "and " + "eggs" # string concatenation
###
pi = 3.14
print "The value of pi is around " + str(pi)

string_1 = "Camelot"
string_2 = "place"

print "Let's not go to %s. 'Tis a silly %s." % (string_1, string_2)

name = raw_input("What is your name?")
quest = raw_input("What is your quest?")
color = raw_input("What is your favorite color?")

print "Ah, so your name is %s, your quest is %s, " \
"and your favorite color is %s." % (name, quest, color)

from datetime import datetime
date = datetime.now()
print date

type(date) is datetime # True
type(date) is int      # False
type(date) is str      # False

from datetime import datetime

now = datetime.now()
print now.year
print now.month
print now.day

from datetime import datetime
now = datetime.now()

print '%s/%s/%s' % (now.year, now.month, now.day)

from datetime import datetime
now = datetime.now()

print '%s:%s:%s' % (now.hour, now.minute, now.second)

false = True and False
true  = True or False
notTrue = not True

answer = "Left"

if answer == "Left":
    print "The answer is Left"
elif answer == "Right":
    print "The answer is Right"
else:
    print "The answer is %s" % answer

def greater_less_equal_5(num):
    if num > 5:
        return 1
    elif num < 5:          
        return -1
    else:
        return 0

print greater_less_equal_5(4)
print greater_less_equal_5(5)
print greater_less_equal_5(6)

original = raw_input("Enter a word:")

# word를 받아서 맨 앞의 글자를 뒤로 보내고 ay를 붙인다.
pyg = 'ay'

original = raw_input('Enter a word:')

if len(original) > 0 and original.isalpha():
    word = original.lower()
    first = word[0]
    new_word = word[1:len(word)] + first + pyg
    print new_word
else:
    print 'empty'

def tax(bill):
    """Adds 8% tax to a restaurant bill."""
    bill *= 1.08
    print "With tax: %f" % bill
    return bill

def tip(bill):
    """Adds 15% tip to a restaurant bill."""
    bill *= 1.15
    print "With tip: %f" % bill
    return bill

meal_cost = 100
meal_with_tax = tax(meal_cost)
meal_with_tip = tip(meal_with_tax)

def cube(number):
    return number**3

def by_three(number):
    if number % 3 == 0:
        return cube(number)
    else:
        return False

import math

print math.sqrt(25)

from math import sqrt

print sqrt(25)

import math            # Imports the math module
everything = dir(math) # Sets everything to a list of things from math
print everything       # Prints 'em all!

def biggest_number( *args ): #argument의 list...
    print max( args )
    return max( args )

def smallest_number( *args ):
    print min( args )
    return min( args )

def distance_from_zero( arg ):
    print abs( arg )
    return abs( arg )


biggest_number( -10,-5,5,10 )
smallest_number( -10,-5,5,10 )
distance_from_zero( -10 )

print type(53)
print type(1.23)
print type("Hello")

type(53) is int      # True
type(53) is str      # False

def hotel_cost(nights):
    return 140 * nights

def plane_ride_cost(city):
    if city == "Charlotte":
        return 183
    elif city == "Tampa":
        return 220
    elif city == "Pittsburgh":
        return 222
    else:
        return 475

def rental_car_cost(days):
    cost = 40 * days;

    if days >= 7:
        cost -= 50
    elif days>=3:
        cost -=20
    return cost

def trip_cost( city,
               days,
               spending_money ):
    return rental_car_cost(days) +
           hotel_cost(days) +
           plane_ride_cost(city) +
           spending_money

print trip_cost( "Los Angeles", 5, 600 )

zoo_animals = ["pangolin", "cassowary", "sloth", "tiger" ];
# One animal is missing!

if len(zoo_animals) > 3:
	print "The first animal at the zoo is the " + zoo_animals[0]
	print "The second animal at the zoo is the " + zoo_animals[1]
	print "The third animal at the zoo is the " + zoo_animals[2]
	print "The fourth animal at the zoo is the " + zoo_animals[3]

suitcase = []
suitcase.append("sunglasses")

suitcase = ["sunglasses", "hat", "passport", "laptop", "suit", "shoes"]

first  = suitcase[0:2]  # The first and second items (index zero and one)
middle = suitcase[2:4]  # Third and fourth items (index two and three)
last   = suitcase[4:6]  # The last two items (index four and five)

animals = ["aardvark", "badger", "duck", "emu", "fennec fox"]
duck_index = animals.index("duck")  
print duck_index

animals = ["aardvark", "badger", "duck", "emu", "fennec fox"]
animals.insert(2,"cobra")
print animals

backpack = ['xylophone', 'dagger', 'tent', 'bread loaf']
backpack.remove('dagger')
print backpack

my_list = [1,9,3,8,5,7]

for number in my_list:
    # Your code here
    print 2*number

start_list = [5, 3, 1, 2, 4]
start_list.sort()

print start_list

menu = {} # Empty dictionary
menu['Chicken Alfredo'] = 14.50 # Adding new key-value pair

# key - animal_name : value - location
zoo_animals = { 'Unicorn' : 'Cotton Candy House',
'Sloth' : 'Rainforest Exhibit',
'Bengal Tiger' : 'Jungle House',
'Atlantic Puffin' : 'Arctic Exhibit',
'Rockhopper Penguin' : 'Arctic Exhibit'}
# A dictionary (or list) declaration may break across multiple lines

# Removing the items.
del zoo_animals['Unicorn']
del zoo_animals['Sloth']
del zoo_animals['Bengal Tiger']
# update the item.
zoo_animals['Rockhopper Penguin'] = 'Nowhere'

print zoo_animals

inventory = {
    'gold' : 500,
    'pouch' : ['flint', 'twine', 'gemstone'], # Assigned a new list to 'pouch' key
    'backpack' : ['xylophone','dagger', 'bedroll','bread loaf']
}

# Adding a key 'burlap bag' and assigning a list to it
inventory['burlap bag'] = ['apple', 'small ruby', 'three-toed sloth']

# Sorting the list found under the key 'pouch'
inventory['pouch'].sort()

# Your code here
inventory['pocket'] = ['seashell', 'strange berry', 'lint']

inventory['backpack'].sort()
inventory['backpack'].remove('dagger');
inventory['gold'] += 50

class Fruit(object):  
    """A class that makes various tasty fruits."""
    def __init__(self, name, color, flavor, poisonous): # constructor와 같은 듯...
        self.name = name
        self.color = color
        self.flavor = flavor
        self.poisonous = poisonous

    def description(self):                              # method들을 이렇게 정의할 수 있다.
        print "I'm a %s %s and I taste %s." % (self.color, self.name, self.flavor)

    def is_edible(self):
        if not self.poisonous:
            print "Yep! I'm edible."
        else:
            print "Don't eat me! I am super poisonous."

lemon = Fruit("lemon", "yellow", "sour", False)

lemon.description()
lemon.is_edible()

class NewClass(object): # object를 inherit한다.
    # Class magic here

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

class Animal(object):
    def __init__( self, name ):
        self.name = name

class Animal(object):
    def __init__( self, name ):
        self.name = name

zebra = Animal("Jeffrey")   # 이런 식으로 Instance를 만들 수 있다.

print zebra.name            # 이런 식으로 member variable에 접근가능하다.

class Animal(object):
    """Makes cute animals."""
    is_alive = True             # 요것도 member variable이다!
    def __init__(self, name, age):
        self.name = name
        self.age = age

zebra = Animal("Jeffrey", 2)
giraffe = Animal("Bruce", 1)
panda = Animal("Chad", 7)

print zebra.name, zebra.age, zebra.is_alive
print giraffe.name, giraffe.age, giraffe.is_alive
print panda.name, panda.age, panda.is_alive

class ShoppingCart(object):
    """Creates shopping cart objects
    for users of our fine website."""
    items_in_cart = {}
    def __init__(self, customer_name):
        self.customer_name = customer_name

    def add_item(self, product, price):
        """Add product to the cart."""
        if not product in self.items_in_cart:
            self.items_in_cart[product] = price
            print product + " added."
        else:
            print product + " is already in the cart."

    def remove_item(self, product):
        """Remove product from the cart."""
        if product in self.items_in_cart:
            del self.items_in_cart[product]
            print product + " removed."
        else:
            print product + " is not in the cart."

my_cart = ShoppingCart( "durotan" )
my_cart.add_item( "sazabi", 80000 )