# sinner_thread.py
import threading
import itertools
import time
import sys
class Signal: # 這個類定義一個可變對象，用于從外部控制線程
 go = True

def spin(msg, signal): # 這個函數(shù)會在單獨的線程中運行，signal 參數(shù)是前邊定義的Signal類的實例
 write, flush = sys.stdout.write, sys.stdout.flush
 for char in itertools.cycle('|/-\\'): # itertools.cycle 函數(shù)從指定的序列中反復(fù)不斷地生成元素
  status = char + ' ' + msg
  write(status)
  flush()
  write('\x08' * len(status)) # 使用退格符把光標移回行首
  time.sleep(.1) # 每 0.1 秒刷新一次
  if not signal.go: # 如果 go屬性不是 True，退出循環(huán)
   break

 write(' ' * len(status) + '\x08' * len(status)) # 使用空格清除狀態(tài)消息，把光標移回開頭

def slow_function(): # 模擬耗時操作
 # 假裝等待I/O一段時間
 time.sleep(3) # 調(diào)用sleep 會阻塞主線程，這么做事為了釋放GIL，創(chuàng)建從屬線程
 return 42

def supervisor(): # 這個函數(shù)設(shè)置從屬線程，顯示線程對象，運行耗時計算，最后殺死進程
 signal = Signal()
 spinner = threading.Thread(target=spin,
        args=('thinking!', signal))
 print('spinner object:', spinner) # 顯示線程對象 輸出 spinner object: <Thread(Thread-1, initial)>
 spinner.start() # 啟動從屬進程
 result = slow_function() # 運行slow_function 行數(shù)，阻塞主線程。同時叢書線程以動畫形式旋轉(zhuǎn)指針
 signal.go = False
 spinner.join() # 等待spinner 線程結(jié)束
 return result
def main():
 result = supervisor() 
 print('Answer', result)
if __name__ == '__main__':
 main()

# spinner_asyncio.py
# 通過協(xié)程以動畫的形式顯示文本式旋轉(zhuǎn)指針
import asyncio
import itertools
import sys
@asyncio.coroutine # 打算交給asyncio 處理的協(xié)程要使用 @asyncio.coroutine 裝飾
def spin(msg):
 write, flush = sys.stdout.write, sys.stdout.flush
 for char in itertools.cycle('|/-\\'): # itertools.cycle 函數(shù)從指定的序列中反復(fù)不斷地生成元素
  status = char + ' ' + msg
  write(status)
  flush()
  write('\x08' * len(status)) # 使用退格符把光標移回行首
  try:
   yield from asyncio.sleep(0.1) # 使用 yield from asyncio.sleep(0.1) 代替 time.sleep(.1), 這樣的休眠不會阻塞事件循環(huán)
  except asyncio.CancelledError: # 如果 spin 函數(shù)蘇醒后拋出 asyncio.CancelledError 異常，其原因是發(fā)出了取消請求
   break

 write(' ' * len(status) + '\x08' * len(status)) # 使用空格清除狀態(tài)消息，把光標移回開頭

@asyncio.coroutine
def slow_function(): # 5 現(xiàn)在此函數(shù)是協(xié)程，使用休眠假裝進行I/O 操作時，使用 yield from 繼續(xù)執(zhí)行事件循環(huán)
 # 假裝等待I/O一段時間
 yield from asyncio.sleep(3) # 此表達式把控制權(quán)交給主循環(huán)，在休眠結(jié)束后回復(fù)這個協(xié)程
 return 42

@asyncio.coroutine
def supervisor(): #這個函數(shù)也是協(xié)程，因此可以使用 yield from 驅(qū)動 slow_function
 spinner = asyncio.async(spin('thinking!')) # asyncio.async() 函數(shù)排定協(xié)程的運行時間，使用一個 Task 對象包裝spin 協(xié)程，并立即返回
 print('spinner object:', spinner) # Task 對象，輸出類似 spinner object: <Task pending coro=<spin() running at spinner_asyncio.py:6>>
 # 驅(qū)動slow_function() 函數(shù)，結(jié)束后，獲取返回值。同事事件循環(huán)繼續(xù)運行，
 # 因為slow_function 函數(shù)最后使用yield from asyncio.sleep(3) 表達式把控制權(quán)交給主循環(huán)
 result = yield from slow_function()
 # Task 對象可以取消；取消后會在協(xié)程當前暫停的yield處拋出 asyncio.CancelledError 異常
 # 協(xié)程可以捕獲這個異常，也可以延遲取消，甚至拒絕取消
 spinner.cancel()
 return result

def main():
 loop = asyncio.get_event_loop() # 獲取事件循環(huán)引用
 # 驅(qū)動supervisor 協(xié)程，讓它運行完畢；這個協(xié)程的返回值是這次調(diào)用的返回值
 result = loop.run_until_complete(supervisor())
 loop.close()
 print('Answer', result)
if __name__ == '__main__':
 main()

res = yield from foo() # foo 可以是協(xié)程函數(shù)，也可以是返回 Future 或 task 實例的普通函數(shù)

asyncio.async(coro_or_future, *, loop=None)

import asyncio
def run_sync(coro_or_future):
 loop = asyncio.get_event_loop()
 return loop.run_until_complete(coro_or_future)
a = run_sync(some_coroutine())

import asyncio
import aiohttp # 需要pip install aiohttp
from flags import save_flag, show, main, BASE_URL
@asyncio.coroutine # 我們知道，協(xié)程應(yīng)該使用 asyncio.coroutine 裝飾
def get_flag(cc):
 url = "{}/{cc}/{cc}.gif".format(BASE_URL, cc=cc.lower())
  # 阻塞的操作通過協(xié)程實現(xiàn)，客戶代碼通過yield from 把指責委托給協(xié)程，以便異步操作
 resp = yield from aiohttp.request('GET', url) 
 # 讀取也是異步操作
 image = yield from resp.read()
 return image

@asyncio.coroutine
def download_one(cc): # 這個函數(shù)也必須是協(xié)程，因為用到了yield from
 image = yield from get_flag(cc) 
 show(cc)
 save_flag(image, cc.lower() + '.gif')
 return cc

def download_many(cc_list):
 loop = asyncio.get_event_loop() # 獲取事件序號底層實現(xiàn)的引用
 to_do = [download_one(cc) for cc in sorted(cc_list)] # 調(diào)用download_one 獲取各個國旗，構(gòu)建一個生成器對象列表
 # 雖然函數(shù)名稱是wait 但它不是阻塞型函數(shù)，wait 是一個協(xié)程，等傳給他的所有協(xié)程運行完畢后結(jié)束
 wait_coro = asyncio.wait(to_do)
 res, _ = loop.run_until_complete(wait_coro) # 執(zhí)行事件循環(huán)，知道wait_coro 運行結(jié)束；事件循環(huán)運行的過程中，這個腳本會在這里阻塞。
 loop.close() # 關(guān)閉事件循環(huán)
 return len(res)
if __name__ == '__main__':
 main(download_many)

@asyncio.coroutine
def get_flag(cc):
 url = "{}/{cc}/{cc}.gif".format(BASE_URL, cc=cc.lower())
 resp = yield from aiohttp.request('GET', url) 
 image = yield from resp.read()
 return image
# 把yield form 去掉
def get_flag(cc):
 url = "{}/{cc}/{cc}.gif".format(BASE_URL, cc=cc.lower())
 resp = aiohttp.request('GET', url) 
 image = resp.read()
 return image

# 現(xiàn)在是不是清晰多了

import asyncio
import collections
from collections import namedtuple
from enum import Enum
import aiohttp
from aiohttp import web
from flags import save_flag, show, main, BASE_URL
DEFAULT_CONCUR_REQ = 5
MAX_CONCUR_REQ = 1000
Result = namedtuple('Result', 'status data')
HTTPStatus = Enum('Status', 'ok not_found error')

# 自定義異常用于包裝其他HTTP貨網(wǎng)絡(luò)異常，并獲取country_code，以便報告錯誤
class FetchError(Exception):
 def __init__(self, country_code):
  self.country_code = country_code

@asyncio.coroutine
def get_flag(cc):
 # 此協(xié)程有三種返回結(jié)果：
 # 1. 返回下載到的圖片
 # 2. HTTP 響應(yīng)為404 時，拋出web.HTTPNotFound 異常
 # 3. 返回其他HTTP狀態(tài)碼時， 拋出aiohttp.HttpProcessingError
 url = "{}/{cc}/{cc}.gif".format(BASE_URL, cc=cc.lower())
 resp = yield from aiohttp.request('GET', url)
 if resp.status == 200:
  image = yield from resp.read()
  return image
 elif resp.status == 404:
  raise web.HttpNotFound()
 else:
  raise aiohttp.HttpProcessionError(
   code=resp.status, message=resp.reason,
   headers=resp.headers
  )

@asyncio.coroutine
def download_one(cc, semaphore):
 # semaphore 參數(shù)是 asyncio.Semaphore 類的實例
 # Semaphore 類是同步裝置，用于限制并發(fā)請求
 try:
  with (yield from semaphore):
    # 在yield from 表達式中把semaphore 當成上下文管理器使用，防止阻塞整個系統(tǒng)
    # 如果semaphore 計數(shù)器的值是所允許的最大值，只有這個協(xié)程會阻塞
    image = yield from get_flag(cc)
    # 退出with語句后 semaphore 計數(shù)器的值會遞減，
    # 解除阻塞可能在等待同一個semaphore對象的其他協(xié)程實例
 except web.HTTPNotFound:
  status = HTTPStatus.not_found
  msg = 'not found'
 except Exception as exc:
  raise FetchError(cc) from exc
 else:
  save_flag(image, cc.lower() + '.gif')
  status = HTTPStatus.ok
  msg = 'ok'
 return Result(status, cc)

@asyncio.coroutine
def downloader_coro(cc_list):
 counter = collections.Counter()
 # 創(chuàng)建一個 asyncio.Semaphore 實例，最多允許激活MAX_CONCUR_REQ個使用這個計數(shù)器的協(xié)程
 semaphore = asyncio.Semaphore(MAX_CONCUR_REQ)
 # 多次調(diào)用 download_one 協(xié)程，創(chuàng)建一個協(xié)程對象列表
 to_do = [download_one(cc, semaphore) for cc in sorted(cc_list)]
 # 獲取一個迭代器，這個迭代器會在future運行結(jié)束后返回future
 to_do_iter = asyncio.as_completed(to_do)
 for future in to_do_iter:
  # 迭代允許結(jié)束的 future 
  try:
   res = yield from future # 獲取asyncio.Future 對象的結(jié)果（也可以調(diào)用future.result）
  except FetchError as exc:
   # 拋出的異常都包裝在FetchError 對象里
   country_code = exc.country_code
   try:
    # 嘗試從原來的異常 （__cause__）中獲取錯誤消息
    error_msg = exc.__cause__.args[0]
   except IndexError:
    # 如果在原來的異常中找不到錯誤消息，使用所連接異常的類名作為錯誤消息
    error_msg = exc.__cause__.__class__.__name__
   if error_msg:
    msg = '*** Error for {}: {}'
    print(msg.format(country_code, error_msg))
   status = HTTPStatus.error
  else:
   status = res.status
  counter[status] += 1
 return counter

def download_many(cc_list):
 loop = asyncio.get_event_loop()
 coro = downloader_coro(cc_list)
 counts = loop.run_until_complete(coro)
 loop.close()
 return counts
if __name__ == '__main__':
 main(download_many)

with (yield from semaphore):
 image = yield from get_flag(cc)

@asyncio.coroutine
def download_one(cc, semaphore):
 try:
  with (yield from semaphore):
   image = yield from get_flag(cc)
 except web.HTTPNotFound:
  status = HTTPStatus.not_found
  msg = 'not found'
 except Exception as exc:
  raise FetchError(cc) from exc
 else:
  # 這里是改動部分
  loop = asyncio.get_event_loop() # 獲取事件循環(huán)的引用
  loop.run_in_executor(None, save_flag, image, cc.lower() + '.gif')
  status = HTTPStatus.ok
  msg = 'ok'
 return Result(status, cc)

def stage1(response1):
 request2 = step1(response1)
 api_call2(request2, stage2)
 
def stage2(response2):
 request3 = step3(response3)
 api_call3(request3, stage3) 

 def stage3(response3):
  step3(response3) 
api_call1(request1, stage1)

@asyncio.coroutine
def three_stages(request1):
 response1 = yield from api_call1(request1)
 request2 = step1(response1)
 response2 = yield from api_call2(requests)
 request3 = step2(response2)
 response3 = yield from api_call3(requests)
 step3(response3) 
 
loop.create_task(three_stages(request1)

@asyncio.coroutine
def http_get(url):
 resp = yield from aiohttp.request('GET', url)
 if resp.status == 200:
  ctype = resp.headers.get('Content-type', '').lower()
  if 'json' in ctype or url.endswith('json'):
   data = yield from resp.json()
  else:
   data = yield from resp.read()
  return data
 elif resp.status == 404:
  raise web.HttpNotFound()
 else:
  raise aiohttp.HttpProcessionError(
   code=resp.status, message=resp.reason,
   headers=resp.headers)

@asyncio.coroutine
def get_country(cc):
 url = "{}/{cc}/metadata.json".format(BASE_URL, cc=cc.lower())
 metadata = yield from http_get(url)
 return metadata['country']

@asyncio.coroutine
def get_flag(cc):
 url = "{}/{cc}/{cc}.gif".format(BASE_URL, cc=cc.lower())
 return (yield from http_get(url))

@asyncio.coroutine
def download_one(cc, semaphore):
 try:
  with (yield from semaphore):
   image = yield from get_flag(cc)
  with (yield from semaphore):
   country = yield from get_country(cc)
 except web.HTTPNotFound:
  status = HTTPStatus.not_found
  msg = 'not found'
 except Exception as exc:
  raise FetchError(cc) from exc
 else:
  country = country.replace(' ', '_')
  filename = '{}--{}.gif'.format(country, cc)
  print(filename)
  loop = asyncio.get_event_loop()
  loop.run_in_executor(None, save_flag, image, filename)
  status = HTTPStatus.ok
  msg = 'ok'
 return Result(status, cc)

image = yield from http_get(url)
return image