t = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
print(dir(t)) # dir()로 attributes 모두 출력해서 iter()이 있는지 확인

w = iter(t)

while True:
    try:
        print(next(w))
    except StopIteration:
        break

# class-based iterator to produce odd numbers
class get_odds:
    def __init__(self, max):
        self.n=3
        self.max=max
    
    # return the iterator object
    def __iter__(self):
        return self
    
    # return the next value in the sequence (or raise StopIteration when there are no values to be returned)
    def __next__(self):
        if self.n <= self.max:
            result = self.n
            self.n += 2
            return result
        else:
            raise StopIteration
   

numbers = get_odds(10)
print(next(numbers))
print(next(numbers))
print(next(numbers))

def get_odds_generator():
    n=1
    n+=2
    yield n
    n+=2
    yield n 
    n+=2
    yield n
    
    
# Call the generator function to get the generator or the iterator object returned as "numbers"
numbers=get_odds_generator()
# Call next() method to retrieve elements from the iterator object "numbers"
# value of first yield = 3
print(next(numbers))
# value of second yield = 5
print(next(numbers))
# value of third yield = 7
print(next(numbers))

def fibonacci_generator():
    n1=0
    n2=1
    while True:
        yield n1
        n1, n2 = n2, n1 + n2
   

sequence= fibonacci_generator()
print(next(sequence))
print(next(sequence))
print(next(sequence))
print(next(sequence))
print(next(sequence))

class WordSplitterGenerator: 
    def __init__(self, text):
        self._text = text.split(' ')

    # iter함수를 구현해주면, 내부적으로 이 yield라는 keyword를 통해 
    # 다음에 return될 원소의 위치값을 기억한다.
    def __iter__(self):
        for word in self._text: 
            yield word
        return

    def __repr__(self):
        return 'WordSplitterGenerator(%s)' % (self._text)

#Generator Expression
accumulated_gexp = sum((1 + x for x in range(2000000)))
print(accumulated_gexp)
>> 2000001000000

#List Comprehension
accumulated_listcomp = sum([1 + x for x in range(2000000)])
print(accumulated_listcomp)
>>2000001000000

from sys import getsizeof

accumulated_gexp = (1 + x for x in range(2000000))
print(type(accumulated_gexp))
print(getsizeof(accumulated_gexp))

accumulated_listcomp = [1 + x for x in range(2000000)]
print(type(accumulated_listcomp))
print(getsizeof(accumulated_listcomp))

import timeit

generator_exp_time = timeit.timeit('''accumulated_gexp = (1 + x for x in range(200))''', number=1000000)
print(generator_exp_time)

list_comp_time = timeit.timeit('''accumulated_listcomp = [1 + x for x in range(200)]''', number=1000000)
print(list_comp_time)

def gen_roster(names):
    while names:
        for name in names:
            current_name = yield name
            if current_name == 'stop':
                names = None
                break
                
# run                
roster = gen_roster(names)
for i in range(10):
    if i == 3:
        roster.send('stop')
    print(next(roster))

import itertools

gen1 = itertools.count(1,2.5)
print(next(gen1))
print(next(gen1))
print(next(gen1))
print(next(gen1))
# ... 무한

# 조건
gen2 = itertools.takewhile(lambda n : n < 1000, itertools.count(1, 2.5))
for v in gen2:
    print(v)

# filterfalse : filter 조건의 반대에 해당하는 것들만 남겨!
gen3 = itertools.filterfalse(lambda n : n < 3, [1,2,3,4,5])
for v in gen3:
    print(v)

# 누적 합계
gen4 = itertools.accumulate([x for x in range(1,101)])
for v in gen4:
    print(v)

# 연결1
gen5 = itertools.chain('ABCDE', range(1,11,2))
print(list(gen5))

# 연결2
gen6 = itertools.chain(enumerate('ABCDE'))
print(list(gen6))

# 개별
gen7 = itertools.product('ABCDE')
print(list(gen7))

# 연산(경우의 수)
gen8 = itertools.product('ABCDE', repeat=3)
print(list(gen8))

# 그룹화(반복되는 원소의 그룹화)
gen9 = itertools.groupby('AAABBCCCDDEEE')
# print(list(gen9))
for chr, group in gen9:
    print(chr, ":", list(group))

# Coroutine Ex1
# def를 통해 generator, coroutine(yield를 사용하는 generator에서 파생된)을 생성할 수 있음.
def coroutine1():
    print('>>> coroutine started.')
    i = yield
    print('>>> coroutine received : {}'.format(i))


# Generator 선언
cr1 = coroutine1() # Main routine이며, "일"하나에 해되며 coroutine1() 속에 define된 task들이 subroutine에 해당 됨.

# generator 객체라고 출력됨.
print(cr1, type(cr1)) # output = "<generator object coroutine1 at 0x0000020D7E9BB740> <class 'generator'>""

# 여기에서 subroutine은 main에서 반환값을 주는 것 밖에는 없었음. 수동적임.
# 첫번째 next(cr1)에서는 coroutine()이라는 generator내의 첫번째 yield 지점까지 subroutine을 수행 하고 정지. 여기 상태를 기억.
next(cr1)
# 값 전송
# send(): main routine과 subroutine이 서로 data를 주고받을 수 있게 함. next()의 기능도 포함하고 있음.
cr1.send(100) # coroutine이 100을 받는다. output = "">>> coroutine received : 100"

# 잘못된 사용
# 다음과 같이 generator 선언 후, 바로 send()의 parameter로 값을 전달하는 경우, 예외 발생
cr2 = coroutine1()
cr2.send(100) # output = "TypeError: can't send non-None value to a just-started generator"

# 맞는 사용법
def coroutine():
    print('>>> coroutine started.')
    i = yield
    print('>>> coroutine received : {}'.format(i))
cr3 = coroutine()
next(cr3)
cr3.send(50)

def func():
    print('Function part 1')
    x = yield
    print(x)
    print('Function part 2')
    a = yield
    print(a)
    print('Function part 3')

# 위 generator function을 통해 send와 yield 활용해보기    
try:
    y = func()
    next(y)	        # Function part 1 executed, to reach the first yield we used next
    y.send(6)		# Function part 2 executed and value sent 6
    y.send(12)		# Function part 2 executed and value sent 12 and StopIteration raised

except StopIteration as e:
    pass

def func1():
    print('Function 1 part 1')
    yield
    print('Function 1 part 2')
    yield
    print('Function 1 part 3')
    yield
    print('Function 1 part 4')
    yield
    print('Function 1 part 5')

def func2():
    print('Function 2 part 1')
    yield
    print('Function 2 part 2')
    yield
    print('Function 2 part 3')
    yield
    print('Function 2 part 4')
    yield
    print('Function 2 part 5')


try:
    a = func1()
    b = func2()
    next(a)  	# Will execute Function 1 part 1
    next(b)  	# Will execute Function 2 part 1
    next(a)  	# Will execute Function 1 part 2
    next(a)  	# Will execute Function 1 part 3
    next(b)  	# Will execute Function 2 part 2
    next(b)  	# Will execute Function 2 part 3
    next(b)  	# Will execute Function 2 part 4
    next(a)  	# Will execute Function 1 part 4
    next(a)  	# Will execute Function 1 part 5 and raise StopIteration exception

except StopIteration as e:
    pass

# sub routine과 main routine사이 값이 오고 가는 과정 구현:

def coroutine2(x): # main routine에서 sub routine으로 x를 전달
    # x를 main routine으로부터 받아서 출력
    print('>>> coroutine started : {}'.format(x)) 
    # y는 main routine에서 send로 받을 예정. (x를 send를 통해 sub routine에서 main routine으로 전달 (양방향 데이터 주고받기: 동시성 가능))
    y = yield x 
    # y를 main routine으로부터 받아서 출력
    print('>>> coroutine received : {}'.format(y))
    # x+y를 subroutine에서 main routine으로 전달
    # main routine이 sub routine에게 넘긴것은 z
    # sub routine이 나에게 준것은 x+y
    z = yield x + y 

    # z를 main routine으로부터 받아서 출력
    print('>>> coroutine received : {}'.format(z))

    # 오른쪽 : sub routine이 나에게 주는거
    # 왼쪽: 입력을 받는거 (main routine에게 전달되는 값)


# cr3 = coroutine2(10)

# print(next(cr3)) # yield를 통해 x가 주어진 상태, y 값을 받기위해 대기 중
# cr3.send(100) # y는 100을 받았고 (x는 10이 주어진 상태) yield를 통해 x+y가 주어진 상태, z 값을 받기위해 대기 중
# cr3.send(100) # StopIteration이 걸림.

# 상태값 확인
from inspect import getgeneratorstate

cr3 = coroutine2(10)
print("상태 값 확인")
print(getgeneratorstate(cr3))
print(next(cr3))
print(getgeneratorstate(cr3))
# cr3.send(100)
# print(getgeneratorstate(cr3)) # send를 보내야하니까 여기서는 GEN_SUSPENDED

# x+y를 확인하기위해서는 print()로 확인가능
print("확인")
print(cr3.send(100)) # output = send의 결과로 ">>> coroutine received : 100" 그리고 subroutine이 나에게 주는 값 "110"은 print의 결과로 확인

# Coroutine Ex3
def generator1():
    for x in 'AB': # iterable한 string에서 순차적으로 끝날때까지
        yield x
    for y in range(1,4): # 사실, range가 list를 반환해주는 것도 generator를 활용하는 것임.
        yield y

t1 = generator1()
print(next(t1))
print(next(t1))
print(next(t1))
print(next(t1))
print(next(t1))
# print(next(t1)) # StopIteration 예외 발생

t2 = generator1()
print(list(t2)) # 알아서 next가 호출되어서 list가 생성됨.


# yield from을 활용해보기
def generator2():
    yield from 'AB' 
    yield from range(1,4) 

t3 = generator2()
print(next(t3))
print(next(t3))
print(next(t3))
print(next(t3))
print(next(t3))
# print(next(t3)) # StopIteration 예외 발생

def step_generator(start, stop, step):
    i = 0
    while start + step * i != stop:
        yield start + step * i
        i += 1
    return i


def wrapper_generator():
    count = yield from step_generator(0, 10, 2)
    print(f"Generated {count} numbers")


if __name__ == "__main__":
    for f in wrapper_generator():
        print(f)

counter = 0

def wait_for_b():
    yield "B"

def wait_for_c():
    yield "C"

def task_generator():
    global counter
    id = counter
    counter += 1
    print(f"{id} Processing event A, blocking on B")
    yield from wait_for_b()
    print(f"{id} Processing event B, blocking on C")
    yield from wait_for_c()
    print(f"{id} Processing event C, task done")

def app():
    tasks = {"A": [], "B": [], "C": []}
    while True:
        print(f"Task queue size {len(tasks['A'] + tasks['B'] + tasks['C'])}")
        event = input("> ").strip()

        if event == "A":
            new_task = task_generator()
            waiting_for = new_task.send(None)
            tasks[waiting_for].append(new_task)

        if len(tasks[event]):
            task = tasks[event][0]
            tasks[event].remove(task)
            try:
                waiting_for = task.send(None)
                tasks[waiting_for].append(task)
            except StopIteration:
                pass


if __name__ == "__main__":
    app()