import os

path_root = './_posts/'
files = os.listdir(path_root)
files = [path_root + x for x in files if x.endswith('.md')]
insert_line = 'typora-root-url: ../../source'

for file in files:
    with open(file) as f:
        lines = f.readlines()

    if any([insert_line in x for x in lines]):
        continue

    lines.insert(2, insert_line + '\n') // 在哪一行插入都行
    with open(file, 'w') as f:
        f.writelines(lines)

from collections import defaultdict, Counter
from string import ascii_lowercase
import re
import numpy as np

def prefix_beam_search(ctc, lm=None, k=25, alpha=0.30, beta=5, prune=0.001):
	"""
	Performs prefix beam search on the output of a CTC network.

	Args:
		ctc (np.ndarray): The CTC output. Should be a 2D array (timesteps x alphabet_size)
		lm (func): Language model function. Should take as input a string and output a probability.
		k (int): The beam width. Will keep the 'k' most likely candidates at each timestep.
		alpha (float): The language model weight. Should usually be between 0 and 1.
		beta (float): The language model compensation term. The higher the 'alpha', the higher the 'beta'.
		prune (float): Only extend prefixes with chars with an emission probability higher than 'prune'.

	Retruns:
		string: The decoded CTC output.
	"""

	lm = (lambda l: 1) if lm is None else lm # if no LM is provided, return 1
	W = lambda l: re.findall(r'\w+[\s|>]', l)
	alphabet = list(ascii_lowercase) + [' ', '>', '%']
	F = ctc.shape[1]
	ctc = np.vstack((np.zeros(F), ctc)) # just add an imaginative zero'th step 
	T = ctc.shape[0]

	# STEP 1: Initiliazation
	O = '' # means empty
	Pb, Pnb = defaultdict(Counter), defaultdict(Counter)
	Pb[0][O] = 1 # balnk prob is 1
	Pnb[0][O] = 0 # non blank prob is 0
	A_prev = [O]
	# END: STEP 1

	# STEP 2: Iterations and pruning
	for t in range(1, T):
		pruned_alphabet = [alphabet[i] for i in np.where(ctc[t] > prune)[0]]
		for l in A_prev: # A_prev is a string list
            
			if len(l) > 0 and l[-1] == '>': # < means end-character
				Pb[t][l] = Pb[t - 1][l]
				Pnb[t][l] = Pnb[t - 1][l]
				continue  

			for c in pruned_alphabet:
				c_ix = alphabet.index(c)
				# END: STEP 2
				
				# STEP 3: “Extending” with a blank
				if c == '%': # % means blank, index is -1
					Pb[t][l] += ctc[t][-1] * (Pb[t - 1][l] + Pnb[t - 1][l])
				# END: STEP 3
				
				# STEP 4: Extending with the end character
				else:
					l_plus = l + c
					if len(l) > 0 and c == l[-1]:
						Pnb[t][l_plus] += ctc[t][c_ix] * Pb[t - 1][l]
						Pnb[t][l] += ctc[t][c_ix] * Pnb[t - 1][l]
				# END: STEP 4

					# STEP 5: Extending with any other non-blank character 
                    # and LM constraints
                    #
					elif len(l.replace(' ', '')) > 0 and c in (' ', '>'):
						lm_prob = lm(l_plus.strip(' >')) ** alpha
						Pnb[t][l_plus] += lm_prob * ctc[t][c_ix] * (Pb[t - 1][l] + Pnb[t - 1][l])
					else:
						Pnb[t][l_plus] += ctc[t][c_ix] * (Pb[t - 1][l] + Pnb[t - 1][l])
					# END: STEP 5

					# STEP 6: Make use of discarded prefixes
                    # 可能l_plus已经存在过，但在上一步的时候扔掉了，这里相当于补回来
					if l_plus not in A_prev:
						Pb[t][l_plus] += ctc[t][-1] * (Pb[t - 1][l_plus] + Pnb[t - 1][l_plus])
						Pnb[t][l_plus] += ctc[t][c_ix] * Pnb[t - 1][l_plus]
					# END: STEP 6

		# STEP 7: Select most probable prefixes
		A_next = Pb[t] + Pnb[t]
		sorter = lambda l: A_next[l] * (len(W(l)) + 1) ** beta
		A_prev = sorted(A_next, key=sorter, reverse=True)[:k]
		# END: STEP 7

	return A_prev[0].strip('>')

# -*- coding: utf-8 -*-
import os
from contextlib import closing
import threading
import requests

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/57.0.2987.133 Safari/537.36'
}

out_dir = './out'  # 输出文件夹
thread_num = 4    # 线程数

if not os.path.exists(out_dir):
    os.mkdir(out_dir)

def download(img_url, img_name):
    if os.path.isfile(os.path.join(out_dir, img_name)):
        return
    with closing(requests.get(img_url, stream=True, headers=headers)) as r:
        rc = r.status_code
        if 299 < rc or rc < 200:
            print 'returnCode%s\t%s' % (rc, img_url)
            return
        content_length = int(r.headers.get('content-length', '0'))
        if content_length == 0:
            print 'size0\t%s' % img_url
            return
        with open(os.path.join(out_dir, img_name), 'wb') as f:
            for data in r.iter_content(1024):
                f.write(data)

def get_imgurl_generate():
    for i in range(1, 161):
        yield ("http://mp3.aikeu.com/15626/{}.mp3".format(i), "{}.mp3".format(i))

lock = threading.Lock()

def loop(imgs):
    print 'thread %s is running...' % threading.current_thread().name

    while True:
        try:
            with lock:
                img_url, img_name = next(imgs)
        except StopIteration:
            break
        try:
            download(img_url, img_name)
        except:
            print 'exceptfail\t%s' % img_url
    print 'thread %s is end...' % threading.current_thread().name

img_gen = get_imgurl_generate()

for i in range(0, thread_num):
    t = threading.Thread(target=loop, name='LoopThread%s' %i, args=(img_gen,))
    t.start()