pythonのユーティリティ・プログラム 2020冬

• 一覧
• ご予定
• empty.py
  • class Empty
  • to_attr(e, dic={}, **kwds)
  • new( dic={}, **kwds )
  • new_kwds(**kwds)
  • add(e, dic={}, **kwds)
  • copy(e)
  • update(targ, add)
  • is_empty(o)
  • call(f, args=(), dv=None)
  • attr_call(e, attr, args=(), dv=None)
  • to_dic(o)
  • from_dic(o)
  • kwds_pop(targ_dic, **kwds)
  • chg_new(v, f=None, fv=None)
• dbg.py
  • out_lst(lst, pre='')
  • msg_start(msg, show=True)
  • start_save(path, show=True)
  • start_load(path, show=True)
  • quantize(v, exp)
    • 使用例
  • laptime_new(s='')
    • 使用例
• thr.py
  • event_new(...)
  • cond_new(...)
  • que_new(tmout=None, dv=None)
    • 2020/MAY/24
  • lock_new()
  • seq_cnt_new()
  • ev_val_new(ev=None, v_init=None, v_timeout=None, v_cancel=False)
  • timer_new(sec, func, args=())
  • tmr_new( sec, func, args=() )
  • th_new(target=None, args=(), gc=None)
    • 引数 gc=None を追加しました。2020/FEB/21
    • gcに機能を追加しました。2020/MAY/10
  • loop_new(func, args=(), wait_tmout=0)
    • 引数 gc=None を追加しました。2020/FEB/21
  • loop_que_new(func, que_tmout=0, wait_tmout=0, gc=None)
    • 引数 gc=None を追加しました。2020/FEB/21
  • call_after_new()
  • gc_new()
    • gcに機能を追加しました。2020/MAY/10
    • gc_new()の使用例
  • ths_new()
  • sigint_new(cb=None)
  • set_sig_func(sig, func)
• cmd_ut.py
  • call(cmd, defval='', b2s=False)
  • proc_new(cmd, stdin=None, stdout=None, stderr=None, preexec_fn=os.setsid, sudo_pw='')
  • cb_line(cmd, cb, preexec_fn=os.setsid)
    • 例
  • call_show(cmd)
  • call_comm(cmd, in_b)
  • proc_new_comm_tm2(cmd, tmout1, tmout2)
  • cmd_py(name)
  • cmd_stdio_conn(cmd1, cmd2, fifo='fifo')
  • call_stdio_conn(cmd1, cmd2, fifo='fifo', defval='')
  • proc_stdio_conn(cmd1, cmd2, fifo='fifo', sudo_pw='')
  • rm_rf(fn)
  • mk_tmp_dir(pre='tmp_')
• io_ut.py
  • readable(f, tmout=0)
  • read1(f, tmout=0)
  • reader_new(f, tmout=0, to_str=True, no_buf=False)
• tcp_ut.py
  • srv_new( port, cb=None, bufmax=4*1024, tmout=3.0, kill_word='kill_srv' )
  • cli_new( port, host='localhost', bufmax=4*1024, tmout=3.0, kill_word='kill_srv' )
  • コマンドとしての動作
• chat_conn.py
• nkf.py
  • 概要
  • 主な関数
• arg.py
  • new()
  • cmd_new(name, args=[], opts={}, comment='', **kwds)
  • get_name_args(cmds, a=None)
    • オプション指定の有無だけの場合 (2020/MAY/02追加)
    • 実行するコマンドのヘルプメッセージ (2020/MAY/03追加)
    • 残りのコマンドライン引数 (2020/MAY/06追加)
    • オプション指定の有無だけの場合を修正 (2020/MAY/24追加)
• term_ut.py
  • esc_seq_new()
  • new()
  • term.disp
  • term.key
    • 矢印キーの種類
  • buff_new(w, h)
    • puts()で指定可能な文字列の装飾指定
• tm_ut.py
  • now_sec()
  • sec_to_str(sec, delim='')
  • str_to_sec(s)
  • is_date_time_str(s, delim='')
  • sec_to_fn(pre, sec, ext='')
  • fn_to_sec(fn)
  • get_mon3(str_or_int)
  • date432()
  • tm60_to_int(tm60)
  • int_to_tm60(v)
  • tm60_to_str(tm60)
  • str_to_tm60(s)
  • tm60_str_to_int(s)
  • tm60_int_to_str(v)
  • is_tm60_str(s)
  • tm60_show_sum(tm60_str_lst)
    • __main__
• cnt_ut.py
  • cnt_new(n)
  • cnt_map(func, lst)
  • cnt_loop(func_i, n)
• base.py
  • to_str(lst, pre='', delim='\ n', last=False)
  • filter_str(f, s)
  • filter_div(f, lst)
  • add_path(base, add, delim='/')
  • path_lst(name, from__file__)
  • find_path(name, from__file__, dv=None)
  • can_hash(o)
  • rev_dic(dic)
  • dic_update_r(targ, add)
    • 辞書の普通のupdate()メソッドの動作
    • 再帰的なupdate
  • str_find(s, key_h, key_t=None)
  • str_replace_dic(s, dic)
• chide.py
  • enc(s, lst)
    • ヘッダ情報
    • ヘッダ
    • 対象文字列中の変換文字の位置情報
    • 制限
  • dec(s)
  • 使用例
• yaml_ut.py
  • load(s_or_f)
  • load_fn(fn, dv=None)
  • dump(o)
  • dump_no_flow(o)
  • save(o, fn, dv='')
• html_ut.py
  • get_yaml(path, head_only=False)
  • get_obj(path, head_only=False)
  • find_tag(o, tag)
  • find_tag_path(o, tag_path)
  • get_tag_path(path, tag_path)
  • get_title(path, dv='')
• from_to.py
• del_lines.py
• np_ut.py
  • 2020/NOV/27
  • 2021/JAN/28
  • 2021/JAN/29
  • 2021/MAR/23
  • 2021/APR/06
  • 2021/JUN/30
  • to_bytes_head(b)
  • from_bytes_head(b)
  • to_bytes_dtype(lst, dtype)
  • from_bytes_dtype(b, dtype)
  • to_bytes_yaml( o )
  • from_bytes_yaml( b )
  • to_bytes_arr( arr )
  • from_bytes_arr( b )
  • save_bytes(path, b, show=True)
  • load_bytes(path, show=True)
  • save_bytes_dtype(path, lst, dtype, show=True)
  • load_bytes_dtype(path, dtype, show=True)
  • write_bytes_head( f, b )
  • read_bytes_head( f )
  • save(path, o, s_yaml)
    • 簡単な例
    • リストの場合
    • 辞書の場合
  • load(path)
    • 簡単な例
    • リストの場合
  • info(path)
  • サンプルプログラム
  • arr_new(*args)
  • v_len(v)
  • v_unit(v)
  • cross_unit(va, vb)
  • cross_y(vx)
  • cross_z(vx)
  • get_dist_lst(ps, p)
  • q4_rev(q4)
  • q4_mat(q4)
  • q4_rot(q4, q4_targ)
  • q4_rot_v(q4, v)
  • q4_cnv(targ_q4, base_q4)
  • pos_cnv(targ_pos, base_pos, base_q4)
  • pose_cnv(targ_pos, targ_q4, base_pos, base_q4)
  • q4_icnv(targ_q4, base_q4)
  • pos_icnv(targ_pos, base_pos, base_q4)
  • pose_icnv(targ_pos_on_base, targ_q4_on_base, base_pos, base_q4)
  • q4_new_v_arg(v, arg)
  • ypr_to_q4(yaw, pitch, roll)
  • q4_to_ypr(q4)
  • line_plane_cross(line_p, line_v, plane_p, plane_v)
  • line_plane_cross_point( li, pl )
  • plane2_cross_line( pl_a, pl_b )
  • plane3_cross_point( pl3 )
  • point3_circle_point( p3 )
  • point3_circle_touch_v( p3 )
  • point_plane_len(p, plane_p, plane_v)
  • get_plane_z( pl_p, pl_v, x, y )
  • get_arg_from_line_p2(line_p, line_v, ps, pe)
  • get_q4_from_vx_vy(vx, vy)
  • newton( f, a, b, lmt )
  • curve_new(plst, vs=None, ve=None)
    • get_pos_lst( dist=0.5, strict_spc=False )
  • get_plane_from_points(ps)
• snap_ut.py
  • fs_new(mode, sec, size, path)
    • eq(o)のmode判定
  • fs_new_path(dir_path, path)
  • fs_new_str(s)
  • new_fss(fss, sec)
  • new_dir(dir_path)
  • new_fn(fn)
  • cmp_new(snap_old, snap_new)
• snd_ut.py
  • data_new(name_mp3)
  • 変数silent
  • サンプルプログラム
    • 実行例
• pty_spawn.py
• cmds_out.py
  • データファイル例
  • 実行例

#!/usr/bin/env python

from copy import deepcopy

class Empty:
	pass

def get_dic(base, over_wrt):
	d = base.copy()
	d.update( over_wrt )
	return d

def to_attr(e, dic={}, **kwds):
	vars( e ).update( get_dic( dic, kwds ) )
	return e

new = lambda dic={}, **kwds: to_attr( Empty(), dic, **kwds )

new_kwds = new

def add(e, dic={}, **kwds):
	d = get_dic( get_dic( dic, kwds ), vars( e ) )
	vars( e ).update( d )
	return e

copy = lambda e: new( deepcopy( vars( e ) ) )

def update(targ, add):  # not recursive
	dic = vars( targ )
	dic.update( vars( add ) )

is_empty = lambda o: isinstance(o, Empty)

def call(f, args=(), dv=None):
	return f( *args ) if f else dv

def attr_call(e, attr, args=(), dv=None):
	if not e:
		return dv
	f = getattr( e, attr, None )
	return call( f, args, dv )

def to_dic(o):
	t = type( o )
	if t == list:
		return list( map( to_dic, o ) )
	if t == dict:
		f = lambda kv: ( kv[0], to_dic( kv[1] ) )
		return dict( map( f, o.items() ) )
	if is_empty( o ):
		return to_dic( vars( o ) )
	return o

def from_dic(o):
	t = type( o )
	if t == list:
		return list( map( from_dic, o ) )
	if t == dict:
		f = lambda kv: ( kv[0], from_dic( kv[1] ) )
		return new( dict( map( f, o.items() ) ) )
	if is_empty( o ):
		return from_dic( vars( o ) )
	return o

def kwds_pop(targ_dic, **kwds):
	for k in kwds.keys():
		if k in targ_dic:
			kwds[ k ] = targ_dic.pop( k )
	return new( kwds )

def chg_new(v, f=None, fv=None):
	e = new( v=v, prev=None, chg=None )

	def set(v):
		e.chg = e.v != v
		if e.chg:
			e.prev = e.v
			e.v = v

			if f:
				f( e )
			if fv:
				fv( e.v )
		return e.chg

	return to_attr( e, locals() )

# EOF

#!/usr/bin/env python

import sys
import time
from decimal import Decimal

import empty
import base

def f_out(f, s, tail='\n'):
	f.write(s + tail)
	f.flush()

def out(s, tail='\n'):
	f_out(sys.stdout, s, tail)

def err(s, tail='\n'):
	f_out(sys.stderr, s, tail)

def out_exit(s, code=0):
	out(s)
	sys.exit(code)

def err_exit(s, code=1):
	err(s)
	sys.exit(code)

def help_exit(help, code=1):
	s = ' '.join( [ 'Usage:', sys.argv[0], help ] )
	err_exit(s)

def out_lst(lst, pre=''):
	out( base.to_str( lst, pre ) )


def msg_start(msg, show=True):
	if show:
		out( msg + ' ... ', '' )
	def end():
		if show:
			out( 'ok' )
	return end

start_save = lambda path, show=True: msg_start( 'save ' + path, show )
start_load = lambda path, show=True: msg_start( 'load ' + path, show )


quantize= lambda v, exp: Decimal( v ).quantize( Decimal( exp ) )
# Deciaml( '123.456789' ).quantize( Decimal( '0.001' ) )
# --> 123.456


def laptime_new(s=''):
	lst = []

	def get(s=''):
		inf = empty.new( s=s, tm_sec=time.time(), sec=0, dsec=0 )
		if lst:
			inf.sec = inf.tm_sec - lst[ 0 ].tm_sec
			inf.dsec = inf.sec - lst[ -1 ].sec
		return inf

	get_sec = lambda : get().sec

	def rec(s='', do_show=False):
		inf = get( s )
		lst.append( inf )
		if do_show:
			show( inf )

	def show(inf=None):
		if inf:
			i = lst.index( inf ) if inf in lst else -1
			exp = '0.001'
			sec = quantize( inf.sec, exp )
			dsec = quantize( inf.dsec, exp )
			s = '{} {} {} {}'.format( i, inf.s, sec, dsec )
			out( s )
		else:
			out( '----' )
			for inf in lst:
				show( inf )

	rec( s )

	return empty.new( locals() )

# EOF

#!/usr/bin/env python

import time

import dbg

def foo():
	time.sleep( 1.5 )

def hoge():
	time.sleep( 0.3 )

def run():
	lap = dbg.laptime_new( '>foo' )
	foo()
	lap.rec( '<foo' )

	for i in range(3):
		if i % 2 == 0:
			lap.rec( '>hoge' )
			hoge()
			lap.rec( '<hoge', True )
		lap.rec()
	foo()
	inf = lap.get( 'foo2' )
	lap.show( inf )

	foo()
	sec = lap.get_sec()
	dbg.out( 'sec={}'.format( sec ) )

	lap.rec( 'end' )
	lap.show()

if __name__ == "__main__":
	run()
# EOF

#!/usr/bin/env python

import sys
import time
import threading
import signal

import empty

try:
	import queue
except ImportError:
	import Queue as queue

event_new = threading.Event

cond_new = threading.Condition

def que_new(tmout=None, dv=None):
	q = queue.Queue()

	is_empty = lambda : q.empty()

	is_full = lambda : q.full()

	def put(v):
		q.put(v)

	def get(tmout_=None, dv_=None):
		v = dv_ if dv_ != None else dv
		try:
			tm = tmout_ if tmout_ != None else tmout
			v = q.get(timeout=tm)
		except:
			pass
		return v

	return empty.new( locals() )


def lock_new():
	rlock = threading.RLock()

	on = lock = rlock.acquire

	off = unlock = rlock.release

	return empty.new( locals() )

def seq_cnt_new():
	e = empty.new( seq=0 )

	lock = lock_new()

	def get():
		lock.on()
		seq = e.seq
		e.seq += 1
		lock.off()
		return seq

	return empty.to_attr( e, locals() )


def ev_val_new(ev=None, v_init=None, v_timeout=None, v_cancel=False):
	e = empty.new()
	e.ev = ev if ev else event_new()

	def init():
		e.v = v_init
		e.dirty = False
		e.ev.clear()

	def set(v):
		e.v = v
		e.dirty = True
		e.ev.set()

	def cancel():
		e.ev.set()

	def wait(tmout):
		init()
		if not e.ev.wait( tmout ):
			return v_timeout
		if not e.dirty:
			return v_cancel
		return e.v

	init()
	return empty.add( e, locals() )


def timer_new(sec, func, args=()):
	e = empty.new( timer=None )

	def f():
		e.timer = False # expired
		if func:
			func( *args )

	def cancel():
		if e.timer:
			e.timer.cancel()
			e.timer = None

	def start():
		if not e.timer:
			e.timer = threading.Timer( sec, f )
			e.timer.start()

	def restart():
		cancel()
		start()

	def is_timeout():
		return e.timer == False

	return empty.to_attr( e, locals() )


def tmr_new( sec, func, args=() ):
	e = empty.new( stat='init' )
	cond = cond_new()

	def f():
		cond.acquire()

		wsec = None
		if e.stat == 'start':
			e.stat = 'wait'
			wsec = sec

		cond.wait( wsec )

		tmout = False
		if e.stat == 'wait':
			e.stat = 'init'
			tmout = True

		cond.release()

		if tmout and func:
			func( *args )

	th = loop_new( f )

	def stat_if_set( stat_if, stat_set ):
		cond.acquire()
		ret = not stat_if or e.stat == stat_if
		if ret:
			e.stat = stat_set
			cond.notify()
		cond.release()
		return ret

	def start():
		return stat_if_set( 'init', 'start' )

	def cancel():
		return stat_if_set( 'wait', 'init' )

	def quit():
		th.quit_ev.set()
		stat_if_set( '', 'quit' )
		th.stop()  # do not call from th

	th.start()

	return empty.add( e, locals() )


def th_new(target=None, args=(), gc=None):
	e = empty.new()

	quit_ev = threading.Event()
	th = None

	def func(*args):
		if e.target:
			e.target( *e.args )
		if gc:
			gc.put( e )
	def start():
		e.th = threading.Thread( target=func, args=e.args )
		e.th.daemon = True
		e.th.start()
		if gc:
			gc.lst.add( e )
	def join():
		if e.th:
			e.th.join()
			if gc:
				gc.lst.rm( e )
	def stop():
		quit_ev.set()
		join()

	return empty.to_attr( e, locals() )

def loop_new(func, args=(), wait_tmout=0, gc=None):
	th = th_new( gc=gc )

	def f():
		while not th.quit_ev.wait(wait_tmout):
			func(*args)
	th.target = f
	return th

def loop_que_new(func, que_tmout=0, wait_tmout=0, gc=None):
	que = que_new(que_tmout)

	def f():
		v = que.get()
		if v != None:
			func(v)

	th = loop_new( f, (), wait_tmout, gc )
	th.que = que
	return th

def call_after_new():
	def f( v ):
		( func, args, kwds ) = v
		func( *args, **kwds )

	th = loop_que_new( f, que_tmout=1.0 )
	th.start()

	def put( func, *args, **kwds ):
		th.que.put( ( func, args, kwds ) )

	def wait_flush():
		while not th.que.is_empty():
			time.sleep( 1 )

	def stop():
		th.stop()

	return empty.new( locals() )

def gc_new():
	def func(th_):
		th_.join()

	th = loop_que_new( func, que_tmout=1.0 )
	th.start()

	def put(th_):
		th.que.put( th_ )

	def lst_new():
		lst = []

		def add(th_):
			lst.append( th_ )

		def rm(th_):
			if th_ in lst:
				lst.remove( th_ )

		def quit_ev_set():
			for th_ in lst:
				th_.quit_ev.set()

		return empty.new( locals() )

	lst = lst_new()

	def stop(delay_sec=None):
		lst.quit_ev_set()

		if delay_sec:
			time.sleep( delay_sec )
		while not th.que.is_empty():
			time.sleep( 1 )
		th.stop()

	return empty.new( locals() )


def ths_new():
	lst = []
	lock = lock_new()

	def add(th):
		if th not in lst:
			lock.on()
			lst.append( th )
			lock.off()
	def rm(th):
		if th in lst:
			lock.on()
			lst.remove( th )
			lock.off()
	def gc():
		cth = threading.current_thread()
		bak_n = len( lst )
		for th in lst[ : ]:
			if th.goal and th.th != cth:
				rm( th )
				th.join()
		n = len( lst )
		#dbg.out( 'gc {} --> {}'.format( bak_n, n ) )

	def func(th):
		gc()
		if th.target:
			th.target( *th.args )
			gc()
		th.goal = True

	def start(th):
		gc()
		th.goal = False
		add( th )

		th.th = threading.Thread( target=func, args=( th, ) )
		th.th.daemon = True
		th.th.start()

	def stop_all(tm_out=5.0):
		for th in lst[ : ]:
			th.quit_ev.set()
		st = time.time()
		while lst and time.time() - st <= tm_out:
			gc()
			time.sleep( 1 )

	return empty.new( locals() )

ths = ths_new()


def sigint_new(cb=None):
	e = empty.new( done=False )

	cond = cond_new()

	def wait():
		cond.acquire()
		cond.wait()
		cond.release()

	def hdl(sig, frame):
		cond.acquire()
		e.done = True
		cond.notify_all()
		cond.release()

	th = None
	if cb:
		def func():
			wait()
			cb()
		th = loop_new( func )
		th.start()

	def fini():
		if th:
			th.stop()

	signal.signal( signal.SIGINT, hdl )

	return empty.to_attr( e, locals() )

def set_sig_func(sig, func):
	bak = signal.getsignal( sig )

	def hdl(sig, frame):
		func()
		if callable( bak ):
			bak( sig, frame )

	signal.signal( sig, hdl )

# EOF

#!/usr/bin/env python

import os
import subprocess
import signal
import six
import time

import empty
import io_ut
import tm_ut
import dbg

PIPE = subprocess.PIPE
SIGKILL = signal.SIGKILL
SIGINT = signal.SIGINT

def call(cmd, defval='', b2s=False):
	try:
		s = subprocess.check_output( cmd, shell=True )
		if six.PY3 and b2s:
			s = s.decode()
		return s
	except:
		return defval

def kill_pid(pid, sig=SIGKILL):
	os.killpg(pid, sig)

def proc_new(cmd, stdin=None, stdout=None, stderr=None, preexec_fn=os.setsid, sudo_pw=''):
	proc = None
	try:
		if sudo_pw:
			cmd = 'sudo -S ' + cmd
		proc = subprocess.Popen( cmd, shell=True, stdin=stdin, stdout=stdout, stderr=stderr, preexec_fn=preexec_fn )
		if sudo_pw:
			proc.stdin.write(sudo_pw + '\n')
			proc.stdin.flush()
	except:
		pass

	def is_alive():
		if not proc:
			return False
		proc.poll()
		return proc.returncode == None

	def kill(sig=SIGKILL):
		if proc and is_alive():
			if sudo_pw:
				cmd = 'echo {} | sudo -S kill -{} -{} >/dev/null 2>&1'.format(sudo_pw, sig, proc.pid)
				call(cmd)
			else:
				kill_pid(proc.pid, sig)

	def wait(timeout=None):
		if six.PY2:
			proc.wait()
		else:
			proc.wait(timeout)

	def communicate(input=None, timeout=None):
		if not proc:
			return (None, None)
		if six.PY2:
			return proc.communicate(input)
		return proc.communicate(input, timeout)

	get_stdin = lambda : proc.stdin if proc else None
	get_stdout = lambda : proc.stdout if proc else None
	get_stderr = lambda : proc.stderr if proc else None

	def write_stdin_flush(b):
		stdin = get_stdin()
		if stdin:
			stdin.write(b)
			stdin.flush()

	def read_stdout(defval=None):
		stdout = get_stdout()
		return stdout.read() if stdout else defval

	return empty.new( locals() )

def cb_line(cmd, cb, preexec_fn=os.setsid):
	proc = proc_new( cmd, stdout=PIPE, preexec_fn=preexec_fn )
	f = proc.get_stdout()

	while True:
		s = f.readline().decode()
		if not s:
			break
		cb( s )

	proc.kill()
	proc.wait()

def call_show(cmd):
	# show stdout stderr, and return bool
	proc = proc_new( cmd )
	proc.wait()
	return proc.proc.returncode == 0

def call_comm(cmd, in_b):
	proc = proc_new(cmd, stdin=PIPE, stdout=PIPE)
	out_b = proc.communicate(in_b)[0]
	proc.wait()
	return out_b

def proc_new_comm_tm2(cmd, tmout1, tmout2):
	proc = proc_new(cmd, stdin=PIPE, stdout=PIPE)
	kill = proc.kill
	wait = proc.wait

	stdout = proc.get_stdout()
	rdr = io_ut.reader_new( stdout, tmout2, no_buf=True )

	def write(s):
		proc.write_stdin_flush( s.encode() )

	def read():
		if not io_ut.readable(stdout, tmout1):
			return None # timeout
		return rdr.read() # use tmout2

	def comm(s):
		write(s)
		return read()

	return empty.new( locals() )

def cmd_py(name):
	path = name + '.py'
	if os.path.exists(path):
		return './' + path

	return 'python -m ' + name

def cmd_stdio_conn(cmd1, cmd2, fifo='fifo'):
	cmd = 'rm -f {} ; mkfifo {} ; {} < {} | {} > {} ; rm -f {}'
	return cmd.format( fifo, fifo, cmd1, fifo, cmd2, fifo, fifo )

def call_stdio_conn(cmd1, cmd2, fifo='fifo', defval=''):
	cmd = cmd_stdio_conn( cmd1, cmd2, fifo )
	return call( cmd, defval )

def proc_stdio_conn(cmd1, cmd2, fifo='fifo', sudo_pw=''):
	cmd = cmd_stdio_conn( cmd1, cmd2, fifo )
	return proc_new( cmd, sudo_pw=sudo_pw )

def rm_rf(fn):
	if os.path.exists(fn):
		cmd = 'rm -rf {}'.format(fn)
		call(cmd)
		return cmd
	return ''

def mk_tmp_dir(pre='tmp_'):
	name = pre
	while True:
		sec = tm_ut.now_sec()
		name = tm_ut.sec_to_fn( pre, sec )
		if not os.path.exists( name ):
			break
		time.sleep( 1 )
	call( 'mkdir ' + name )
	return name

# EOF

#!/usr/bin/env python

import os
import select
import six
import empty
import dbg

def no_buffering(f):
	if six.PY2:
		return os.fdopen(f.fileno(), 'r', 0)
	return os.fdopen(f.fileno(), 'rb', buffering=0)

readable = lambda f, tmout=0: select.select([f], [], [], tmout)[0] == [f]

def read1(f, tmout=0):
	if readable(f, tmout):
		return f.read(1) # EOF is b'' or ''
	return None # timeout

def reader_new(f, tmout=0, to_str=True, no_buf=False):
	# return '' is EOF
	# return None is timeout

	if no_buf:
		f = no_buffering(f)

	e = empty.new()

	readable_ = lambda : readable(f, tmout)
	e.readable = readable_

	e.type = None

	def read1_():
		b = read1(f, tmout)
		if b == None:
			return None # timeout
		if e.type == None or e.type != type(b):
			e.type = type(b)
		if to_str and  e.type == bytes:
			return b.decode() # EOF is ''
		return b # EOF is '' or b''
	e.read1 = read1_

	def read():
		lst = []
		r1 = None
		while True:
			r1 = read1_()
			if not r1: # None is timeout , '' or b'' is EOF
				break
			lst.append(r1)

		if not lst:
			if r1 == None: # timeout
				return None
			r0 = '' if e.type in (str, None) else b''
			return r0

		r0 = '' if type(lst[0]) == str else b''
		return r0.join(lst)

	def read_to(k): # to_str=True only
		buf = ''
		while True:
			r1 = read1_()
			if not r1: # None is timeout , '' is EOF
				return buf if buf else r1
			buf += r1
			if buf.endswith(k):
				break
		return buf

	e.buf = ''

	def pop_buf():
		(r, e.buf) = (e.buf, '')
		return r

	def readline(): # to_str=True only
		while True:
			c = read1_()
			if c == None: # timeout
				break
			if c == '': # EOF
				return pop_buf()
			e.buf += c
			if c in ('\n', '\r'):
				return pop_buf() # '\n', '\r' contained
		return None # timeout

	e.lines = []

	def pop_lines():
		(r, e.lines) = (e.lines, [])
		return r

	def readlines(): # to_str=True only
		# delim is "\n" line
		# return list of str
		# return [] is EOF
		# return None is timeout

		while True:
			s = readline()
			if s == None: # timeout
				break
			if s == '': # EOF
				return pop_lines()
			e.lines.append(s)
			if s == '\n': # delim
				return pop_lines() # delim contained
		return None # timeout

	return empty.to_attr( e, locals() )


if __name__ == "__main__":
	import cmd_ut
	import yaml

	cmd = 'ls ; echo "" ; ls ; echo ""'
	proc = cmd_ut.proc_new(cmd, stdout=cmd_ut.PIPE)
	f = proc.get_stdout()
	rdr = reader_new(f)

	while True:
		lst = rdr.readlines()
		if lst == []:
			break
		if lst:
			for s in lst:
				dbg.out(s, '')
# EOF

#!/usr/bin/env python

import sys
import socket
import select
import time

import empty
import thr
import dbg

readable = lambda f, tmout=0: select.select( [ f ], [], [], tmout )[ 0 ] == [ f ]

def recv_sock( f, bufmax=4*1024, tmout=3.0 ):
	if not readable( f, tmout ):
		return None  # time out
	dbg.out( 'readable' )
	return f.recv( bufmax ).decode( 'utf-8' )  # '' EOF

def recv_sock_loop( f, is_quit, bufmax=4*1024, tmout=3.0 ):
	s = None
	while s is None:
		if is_quit():
			return False  # quit
		s = recv_sock( f, bufmax, tmout )
		dbg.out( 's={}'.format( s ) )
	return s

def send_sock( f, s ):
	try:
		f.sendall( s.encode( 'utf-8' ) )
	except:
		pass

def pipe_sock( f, f_, is_quit, bufmax=4*1024, tmout=3.0 ):
	while not is_quit():
		s = recv_sock_loop( f, is_quit, bufmax, tmout )
		if not s:
			break
		send_sock( f_, s )

def srv_new( port ):
	ss = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
	ss.setsockopt( socket.SOL_SOCKET, socket.SO_REUSEADDR, 1 )
	ss.bind( ( '', port ) )
	ss.listen( 5 )

	def accept( tmout ):
		if not readable( ss, tmout ):
			return None
		( cs, adr ) = ss.accept()
		return cs

	def close():
		ss.close()

	def accept_loop( cb, is_quit, tmout ):
		while not is_quit():
			cs = accept( tmout )
			if not cs:
				continue

			def func():
				cb( cs )
				cs.close()

			th = thr.th_new( func )
			thr.ths.start( th )
		close()

	return empty.new( locals() )

def cli_conn( port ):
	cs = socket.socket( socket.AF_INET, socket.SOCK_STREAM )
	try:
		host = 'localhost'
		cs.connect( ( host, port ) )
	except:
		return None
	return cs

def uniq_cnt_new():
	e = empty.new()
	e.i = 0

	lock = thr.lock_new()

	def get():
		lock.on()
		v = e.i
		e.i += 1
		lock.off()
		return v

	def get_str():
		return str( get() )

	return empty.add( e, locals() )

def srv_id( port, is_quit_, bufmax=4*1024, tmout=3.0 ):

	e = empty.new()
	e.killed_all = False

	def is_quit():
		return is_quit_() or e.killed_all

	def cb( f ):
		dbg.out( 'cb' )

		ids = {}

		def srv_boot( id ):
			if id in ids:
				send_sock( f, 'already boot id' )
				f.close()
				return

			e = empty.new()
			e.f = f
			e.dic = {}
			e.uniq_cnt = uniq_cnt_new()
			ids[ id ] = e
			send_sock( f, 'ok' )

		def srv_rep( id, k ):
			if id not in ids:
				send_sock( f, 'not found id' )
				f.close()
				return

			e = ids.get( id )
			if k not in e.dic:
				send_sock( f, 'not found k' )
				f.close()
				return

			lst = e.dic.get( k )
			if not lst or len( lst ) != 1:
				send_sock( f, 'invalid state' )
				f.close()
				return

			f_ = lst[ 0 ]
			lst.append( f )

			send_sock( f, 'ok' )

			pipe_sock( f, f_, is_quit, bufmax, tmout )
			if k in e.dic:
				e.dic.pop( k )
			f.close()
			f_.close()

		def conn_id( id ):
			if id not in ids:
				send_sock( f, 'not found id' )
				f.close()
				return

			e = ids.get( id )
			k = e.uniq_cnt.get_str()
			e.dic[ k ] = [ f ]

			send_sock( e.f, k )

			lst = []
			while True:
				if is_quit():
					f.close()
					return
				lst = e.dic.get( k, [] )
				if len( lst ) >= 2:
					break
				time.sleep( 1.0 )

			( f, f_ ) = lst[ : 2 ]

			send_sock( f, 'ok' )

			pipe_sock( f, f_, is_quit, bufmax, tmout )
			if k in e.dic:
				e.dic.pop( k )
			f.close()
			f_.close()

		def kill_id( id ):
			e = ids.pop( id )
			ks = e.dic.keys()
			for k in ks:
				lst = e.dic.pop( k )
				for f_ in lst:
					f_.close()
			e.f.close()

		def srv_kill( id ):
			if id not in ids:
				send_sock( f, 'not found id' )
				f.close()
				return

			kill_id( id )
			send_sock( f, 'ok' )
			f.close()

		def kill_all():
			for id in ids.keys():
				kill_id( id )
			send_sock( f, 'ok' )
			f.close()
			e.killed_all = True


		s = recv_sock_loop( f, is_quit, bufmax, tmout )

		dbg.out( 'cb s={}'.format( s ) )

		if s:
			lst = s.split()
			n = len( lst )
			if n == 2 and lst[ 0 ] == 'srv_boot':
				# srv_boot id
				id = lst[ 1 ]
				srv_boot( id )
			elif n == 2 and lst[ 0 ] == 'srv_kill':
				# srv_kill id
				id = lst[ 1 ]
				srv_kill( id )
			elif n == 3 and lst[ 0 ] == 'srv_rep':
				# srv_rep id k
				( id, k ) = lst[ 1 : ]
				srv_rep( id, k )
			elif n == 1 and lst[ 0 ] == 'kill_all':
				# kill_all
				kill_all()
			elif n == 1:
				# id
				conn_id( id )
			else:
				f.close()
		else:
			f.close()


	srv = srv_new( port )
	dbg.out( 'srv={}'.format( srv ) )

	srv.accept_loop( cb, is_quit, tmout )


def msg_ret_None( s ):
	dbg.out( s )
	return None

def conn_send_recv_ok_confirm( port, s, is_quit ):
	f = cli_conn( port )
	if not f:
		return msg_ret_None( 'failed conn' )

	send_sock( f, s )

	s = recv_sock_loop( f, is_quit )
	if not s:
		return msg_ret_None( 'no recv' )
	if s != 'ok':
		return msg_ret_None( s )
	return f

def srv_id_boot_id( port, id, is_quit ):
	s = 'srv_boot ' + id
	return conn_send_recv_ok_confirm( port, s, is_quit )

def srv_id_accept( port, f, is_quit, bufmax=4*1024, tmout=3.0 ):
	s = recv_sock_loop( f, is_quit, bufmax, tmout )
	if not s:
		return msg_ret_None( 'no recv' )
	id = s
	s = 'srv_rep ' + id
	return conn_send_recv_ok_confirm( port, s, is_quit )

def srv_id_conn_id( port, id, is_quit ):
	s = id
	return conn_send_recv_ok_confirm( port, s, is_quit )

def srv_id_kill_id( port, id, is_quit ):
	s = 'srv_kill ' + id
	return conn_send_recv_ok_confirm( port, s, is_quit )

def srv_id_kill_all( port, is_quit ):
	s = 'kill_all'
	return conn_send_recv_ok_confirm( port, s, is_quit )

def run():

	port = 12345

	is_quit = lambda : False

	def f():
		srv_id( port, is_quit )

	th = thr.th_new( f )
	thr.ths.start( th )


	id = 'foo'
	ss = srv_id_boot_id( port, id, is_quit )
	dbg.out( 'ss={}'.format( ss ) )

	def acc_f( cs ):
		s = recv_sock_loop( cs, is_quit )
		send_sock( cs, s.upper() )

	def acc():
		while not is_quit():
			cs = srv_id_accept( port, ss, is_quit )
			if cs:
				th = thr.th_new( acc_f )
				thr.ths.start( th )

	th_acc = thr.th_new( acc )
	thr.ths.start( th_acc )


	f = srv_id_conn_id( port, id, is_quit )
	if f:
		send_sock( f, 'abc' )
		s = recv_sock_loop( f, is_quit )
		if s:
			dbg.out( s )


	srv_id_kill_id( port, id, is_quit )

	srv_id_kill_all( port, is_quit )

	thr.ths.stop_all()

if __name__ == "__main__":
	run()
# EOF

#!/usr/bin/env python

import sys
import socket
import time
import threading
import thr
import empty
import io_ut
import dbg
import arg

tmout = 3.0

def str_div(s, delim):
	i = s.index(delim) if delim in s else len(s)
	return (s[:i], s[i+len(delim):])

readable = lambda fd: io_ut.readable(fd, tmout)

def rest_new():
	e = empty.new()
	e.s = ''

	def clear():
		e.s = ''
	def get():
		(r, e.s) = str_div(e.s, '\n')
		return r
	def add_get(s):
		e.s = e.s + s
		return get()

	return empty.to_attr( e, locals() )

def recv_base(fd, rest, dis_conn_func, conn_func=None):
	s = rest.get()
	if s:
		return s
	if conn_func:
		fd = conn_func()
		if not fd:
			return False # no connection
	if not readable(fd):
		return None # timeout
	try:
		bufmax = 8 * 1024
		s = fd.recv(bufmax)
	except:
		return dis_conn_func(False)
	if not s:
		return dis_conn_func(False)
	#try:
	#	s = s.decode('utf-8')
	#except:
	#	pass
	return rest.add_get(s)

def send_base(s, fd, dis_conn_func, conn_func=None):
	if conn_func:
		fd = conn_func()
		if not fd:
			return False # no connection
	try:
		s = s.encode('utf-8')
	except:
		pass
	try:
		fd.sendall(s+'\n')
	except:
		return dis_conn_func(False)
	return True

def conn_lst_new(): # for srv_accept_conn_new
	lst = []

	def add(conn):
		if conn not in lst:
			lst.append(conn)
	def remove(conn):
		if conn in lst:
			lst.remove(conn)
	def get_by_name(name):
		for conn in lst:
			if conn.name == name:
				return conn
		return None

	others = lambda conn: list( filter( lambda o: o.name != conn.name, lst ) )
	names = lambda : list( map( lambda conn: conn.name, lst ) )
	other_names = lambda conn: list( map( lambda o: o.name, others(conn) ) )

	def shutdown():
		start = time.time()
		while time.time() - start < 5:
			lst_ = filter( lambda conn: conn.name, lst )
			if not lst_:
				break
			for conn in lst_:
				conn.send_from('srv', 'shutdown')
			time.sleep(1)

	return empty.new( locals() )

def srv_accept_conn_new(fd, conn_lst):
	e = empty.new_kwds(name=None, lock_name=None)
	cond = threading.Condition()
	rest = rest_new()

	def dis_conn(v=None):
		if e.name:
			send_others('srv', 'logout ' + e.name)
			e.name = None
		rest.clear()
		if fd:
			fd.close()
		conn_lst.remove(e)
		return v

	recv = lambda : recv_base(fd, rest, dis_conn)
	send = lambda s: send_base(s, fd, dis_conn)

	def name_modify(org):
		if ' ' in org:
			org = org.replace(' ', '_')
		id = 2
		name = org
		while conn_lst.get_by_name(name):
			name = org + '_' + str(id)
			id += 1
		return name

	def login():
		if not send('who?'):
			return dis_conn(False)
		name = None
		lmt = time.time() + 30
		while time.time() < lmt:
			name = recv()
			if name != None:
				break
		if not name:
			return dis_conn(False)

		e.name = name_modify(name)

		if not send(e.name):
			return dis_conn(False)

		send_others('srv', 'login ' + e.name)

		return True

	def lock_name_set(name):
		cond.acquire()
		if e.lock_name != name:
			if name != None:
				while e.lock_name != None:
					cond.wait()
				e.lock_name = name
			else:
				e.lock_name = None
				cond.notify()
		cond.release()

	def send_from(from_name, s):
		s = '{}> {}'.format(from_name, s)
		f = False
		cond.acquire()
		if e.lock_name == from_name:
			r = send(s)
		else:
			while e.lock_name != None:
				cond.wait()
			e.lock_name = from_name
			r = send(s)
			e.lock_name = None
			cond.notify()
		cond.release()
		return r

	def send_others(from_name, s):
		if not from_name:
			from_name = 'srv'
		for to in conn_lst.others(e):
			to.send_from(from_name, s)

	def recv_to_names():
		s = recv()
		if not s:
			return s
		to_names = []
		while s.startswith('@'):
			(name, s) = str_div(s[1:], ' ')
			to_names.append(name)
		if not to_names:
			to_names = conn_lst.other_names(e)
		return (s, to_names)

	conn_lst.add(e)
	return empty.to_attr( e, locals() )

def srv_th_func(conn, th_quit, srv_quit):
	if not conn.login():
		return

	conn_lst = conn.conn_lst

	def is_lock_unlock(s):
		r = False
		for k in ('lock', 'unlock'):
			if not s.startswith(k+' '):
				continue
			name = s[len(k)+1:]
			o = conn_lst.get_by_name(name)
			if not o:
				break
			conn.lock_name_set(o.name if k == 'lock' else None)
			o.lock_name_set(conn.name if k == 'lock' else None)
			r = True
		return r

	def srv_proc(s):
		r = "? '{}'".format(s) # err
		if s == 'kill':
			srv_quit.set()
			return
		elif s in ('exit', 'quit', 'bye'):
			th_quit.set()
			return
		elif s == 'names':
			r = ' '.join( conn_lst.names() )
		elif s == 'other_names':
			r = ' '.join( conn_lst.other_names(conn) )
		elif is_lock_unlock(s):
			return
		conn.send_from('srv', r)

	while not th_quit.wait(0):
		r = conn.recv_to_names()
		if r == False:
			break
		if not r: # None or ''
			continue
		(s, to_names) = r

		for to_name in to_names:
			if to_name == 'srv':
				srv_proc(s)
				continue
			to = conn_lst.get_by_name(to_name)
			if to:
				to.send_from(conn.name, s)
	conn.dis_conn()

def srv(port):
	srv_quit = threading.Event()

	ss = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
	ss.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
	ss.bind(('', port))
	ss.listen(5)

	ths = []
	conn_lst = conn_lst_new()

	while not srv_quit.wait(0):
		if not readable(ss):
			continue
		(fd, adr) = ss.accept()
		conn = srv_accept_conn_new(fd, conn_lst)

		th = thr.th_new(srv_th_func)
		th.args = (conn, th.quit_ev, srv_quit)
		ths.append(th)
		th.start()

	conn_lst.shutdown()

	ss.close()
	for th in ths:
		th.stop()

def cli_new(host, port, name0, watch_func=None):
	e = empty.new_kwds(fd=None, name=None)

	e.watch_func = watch_func # func(name, 'login' or 'logout')
	others = []
	rest = rest_new()

	def dis_conn(v=None):
		if e.name:
			e.name = None
		rest.clear()
		if e.fd:
			e.fd.close()
			e.fd = None
		return v

	def conn():
		if e.fd == None:
			e.fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
			try:
				e.fd.connect((host, port))
			except:
				time.sleep(tmout)
				return dis_conn(False)
		return e.fd # for recv_base, send_base

	recv = lambda : recv_base(e.fd, rest, dis_conn, conn)
	send = lambda s: send_base(s, e.fd, dis_conn, conn)

	def login():
		if not e.name:
			if recv() != 'who?':
				return dis_conn(False)
			if not send(name0):
				return False
			s = recv()
			if not s:
				return dis_conn(False)
			e.name = s

			if e.watch_func:
				others.extend( others_get() )
				for o in others:
					e.watch_func(o, 'login')
		return e.name

	def send_to(name, s):
		if not login():
			return False
		if name:
			s = '@{} {}'.format(name, s)
		return send(s)

	def split_from(s):
		k = '> '
		return str_div(s, k) if k in s else ('', s)

	def recv_split():
		if not login():
			return False
		s = recv()
		if s in (False, None):
			return s
		(f, s) = split_from(s)

		if e.watch_func and f == 'srv':
			for k in ('login', 'logout'):
				if s.startswith(k+' '):
					name = s[len(k)+1:]
					e.watch_func(name, k)
		return (f, s)

	def recv_from(name):
		r = recv_split()
		if not r:
			return r
		(f, s) = r
		return s if f == name else False # not dis_conn

	lock = lambda name: send_to('srv', 'lock ' + name)
	unlock = lambda name: send_to('srv', 'unlock ' + name)

	def send_recv_name(name, s):
		send_to(name, s)
		return recv_from(name)

	def send_recv_lst_name_lock(name, lst):
		if not lst:
			return []
		lock(name)
		rvs = list( map( lambda s: send_recv_name(name, s), lst ) )
		unlock(name)
		return rvs

	def names_get():
		send_to('srv', 'names')
		s = recv_from('srv')
		return s.split(' ') if s else []

	others_get = lambda : list( filter( lambda name: name != e.name, names_get() ) )

	return empty.to_attr( e, locals() )

if __name__ == "__main__":
	s = arg.new().pop()
	if not s:
		dbg.help_exit( '<port>' )
	srv( int(s) )
# EOF

#!/usr/bin/env python

import sys
import six
import subprocess as sp
import cmd_ut

enc = lambda s: s.encode('utf-8') if six.PY2 else s.encode()
dec = lambda b: unicode(b, 'utf-8') if six.PY2 else b.decode()

def get_stdin():
	fi = sys.stdin if six.PY2 else sys.stdin.buffer
	return fi.read() # b

def put_stdout(b):
	fo = sys.stdout if six.PY2 else sys.stdout.buffer
	fo.write(b)

opt_dic = {
	'ISO-2022-JP': '-j',
	'EUC-JP': '-e',
	'Shift_JIS': '-s',
	'UTF-8': '-u',
	'ASCII': '',
}

which_nkf = []

def get_which_nkf():
	if which_nkf == []:
		which_nkf.append( cmd_ut.call( 'which nkf' ) )
	return which_nkf[ 0 ]

def guess(b, style_opt=False):
	def func():
		if get_which_nkf():
			r = cmd_ut.call_comm( enc('nkf -g'), b )
			return dec( r ).strip()

		for b1 in b:
			if b1 >= b'\x80':
				return 'UTF-8'  # !
		return 'ASCII'

	opt = func()
	return opt_dic.get(opt, '-u') if style_opt else opt

def cvt(b, opt, do_guess=False):
	if opt not in opt_dic.values():
		opt = opt_dic.get(opt, '-u')
	if opt == '':
		return b
	if do_guess:
		from_opt = guess(b, True)
		if from_opt == '' or from_opt == opt:
			return b
	return cmd_ut.call_comm( enc('nkf ' + opt), b )

def to_utf8(b):
	opt = guess(b, True)
	u8 = b if opt in ('-u', '') else cvt(b, '-u')
	return (u8, opt)

def utf8_to(u8, opt):
	return u8 if opt in ('-u', '') else cvt(u8, opt)

def to_str(b):
	(u8, opt) = to_utf8(b)
	return ( dec(u8), opt )

def str_to(s, opt):
	return utf8_to( enc(s), opt )

def str_width(s):
	return sum( map( lambda c: 1 if ord(c) < 0x80 else 2, s ) )

if __name__ == "__main__":
	b = get_stdin()
	opt = guess(b)
	u8 = cvt(b, '-u')
	s = dec(u8)
	# ...
	u8 = enc(s)
	b = cvt(u8, opt)
	put_stdout(b)
# EOF

--- nkf.py.0    2020-01-28 22:50:54.000000000 +0900
+++ nkf.py      2020-10-09 22:18:30.000000000 +0900
@@ -24,9 +24,25 @@
 'ASCII': '',
 }

+which_nkf = []
+
+def get_which_nkf():
+       if which_nkf == []:
+               which_nkf.append( cmd_ut.call( 'which nkf' ) )
+       return which_nkf[ 0 ]
+
 def guess(b, style_opt=False):
-       b = cmd_ut.call_comm( enc('nkf -g'), b )
-       opt = dec(b).strip()
+       def func():
+               if get_which_nkf():
+                       r = cmd_ut.call_comm( enc('nkf -g'), b )
+                       return dec( r ).strip()
+
+               for b1 in b:
+                       if b1 >= b'\x80':
+                               return 'UTF-8'  # !
+               return 'ASCII'
+
+       opt = func()
 return opt_dic.get(opt, '-u') if style_opt else opt

 def cvt(b, opt, do_guess=False):

#!/usr/bin/env python

import sys
import yaml

import empty
import base
import dbg

def new():
	av = sys.argv[1:] # copy

	idx = lambda s: av.index(s) if s in av else -1

	def idx_startswith(s):
		for i in range( len(av) ):
			if av[i].startswith(s):
				return i
		return -1

	def pop_str(k, dv=''):
		i = idx(k)
		if i >= 0 and i+1 < len(av):
			av.pop(i) # skip k
			v = av.pop(i)
			return v
		i = idx_startswith(k)
		if i >= 0:
			v = av.pop(i)
			return v[ len(k): ]
		return dv

	def pop_v(k, dv=None):
		s = pop_str(k)
		if s == '':
			return dv
		return yaml.load(s)

	def pop(dv='', avoid_k='-'):
		for i in range( len(av) ):
			if avoid_k and av[i].startswith(avoid_k):
				continue
			return av.pop(i)
		return dv

	def is_pop(s):
		i = idx(s)
		if i < 0:
			return False
		av.pop(i)
		return True

	get_av = lambda : av

	return empty.new( locals() )


def cmd_new(name, args=[], opts={}, comment='', **kwds):
	return empty.new( name=name, args=args, opts=opts, comment=comment, **kwds )

def get_name_args(cmds, a=None):

#	cmds = [
#		cmd_new( 'create' ),
#		cmd_new( 'commit' ),
#		cmd_new( 'log' ),
#		cmd_new( 'curr', comment='show current id' ),
#		cmd_new( 'ids', comment='show all id' ),
#		cmd_new( 'tails', comment='show tail ids' ),
#		cmd_new( 'checkout', [ 'id' ] ),
#		cmd_new( 'check', comment='show dirty' ),
#		cmd_new( 'fixlink', comment='fix link info' ),
#		cmd_new( 'push', [ 'to_path' ] ),
#		cmd_new( 'pull', [ 'from_path' ] ),
#	]
#
#	cmd = get_name_args( cmds )
#
#	obj has obj.create(), obj.commit() ...
#
#	func = getattr( obj, cmd.name )
#	func( *cmd.args )

	dic = dict( map( lambda cmd: ( cmd.name, cmd ), cmds ) )

	def get_help_str(cmd, max_n=0):
		def cnv(v):
			if v == '':
				return '""'
			if v is False:
				return ''
			return v

		def f(kv):
			(k, v) = kv
			lst = [ '[', '-' + k, str( cnv( v ) ), ']' ]
			return base.to_str( filter( lambda e: e, lst ), delim=' ' )

		opts = list( map( f, cmd.opts.items() ) )
		lst = [ cmd.name ] + opts + cmd.args
		s = base.to_str( lst, delim=' ' )

		if max_n < 0: # auto
			max_n = len( s )

		if max_n > 0 and cmd.comment:
			s += ' ' * ( max_n - len( s ) )
			s += ' # ' + cmd.comment
		return s

	def help():
		msg = 'cmd arg ...\n'
		max_n = max( map( lambda cmd: len( get_help_str( cmd ) ), cmds ) )
		msg += base.to_str( map( lambda cmd: get_help_str( cmd, max_n ), cmds ), '  ' )
		dbg.help_exit( msg )

	if not a:
		a = new()
	name = a.pop()
	if name not in dic:
		help()

	cmd = dic.get( name )

	def pop_key_v(key, dv):
		if dv is False:
			return a.is_pop( key )
		return a.pop_v( key, dv )

	opts = cmd.opts.copy()
	for (k, dv) in opts.items():
		key = '-' + k # signel '-'
		v = pop_key_v( key, dv )
		if v != dv:
			opts[ k ] = v

	n = len( cmd.args )
	av = a.get_av()
	if len( av ) < n:
		help()

	args = list( map( lambda i: av.pop( 0 ), range( n ) ) )
	s = get_help_str( cmd, -1 )

	return cmd_new( cmd.name, args, opts, help=s, a=a )
# EOF

#!/usr/bin/env python

import arg
import dbg

def add(a, b):
	return a + b

def inc(a):
	return add( a, 1 )

def dec(a, step, n):
	return a - step * n

cmds = [
	arg.cmd_new( 'add', [ 'v1', 'v2' ], comment='add v1 v2' ),
	arg.cmd_new( 'inc', [ 'v' ], comment='increment v' ),
	arg.cmd_new( 'dec', [ 'v' ], opts={ 'step': 1, 'n': 1 }, comment='v - step * n' ),
]

cmd = arg.get_name_args( cmds )

dbg.out( 'cmd.name={} cmd.args={} cmd.opts={}'.format( cmd.name, cmd.args, cmd.opts ) )

func = eval( cmd.name )

args = list( map( float, cmd.args ) )

dbg.out( 'func={} args={}'.format( func, args ) )

ret = func( *args, **cmd.opts )

dbg.out( 'ret={}'.format( ret ) )

# EOF

#!/usr/bin/env python

import arg
import dbg

def show(n):
	dbg.out( 'n={}'.format( n ) )

cmds = [
	arg.cmd_new( 'show', opts={ 'n': 0 } )
]

cmd = arg.get_name_args( cmds )
f = eval( cmd.name )
f( **cmd.opts )

# EOF

#!/usr/bin/env python

import os
import empty
import cmd_ut
import io_ut

def esc_seq_new():
	esc = lambda s: chr(0x1b) + '[' + s
	esc_ex = lambda d, v: esc( '?{}{}'.format(d, 'h' if v else 'l' ) )
	cursor_show = lambda v: esc_ex( 25, v )
	mov = lambda x, y: esc( '{};{}H'.format(y+1, x+1) )
	scroll = lambda m: esc( '{}{}'.format( abs(m), 'S' if m > 0 else 'T' ) )
	cls = esc('2J')
	reset = esc('0m')
	rev = esc('7m')
	uline = esc('4m')
	return empty.new( locals() )

def get_wh():
	w = int( cmd_ut.call('tput cols').strip() )
	h = int( cmd_ut.call('tput lines').strip() )
	return (w, h)

dev = '/dev/tty'

def stty(s, v=True):
	if not v:
		s = '-' + s
	cmd = 'stty {} < {}'.format(s, dev)
	cmd_ut.call(cmd)

def new():
	esc_seq = esc_seq_new()

	fr = open(dev, 'r')
	fw = open(dev, 'w')

	def get_xy():
		cmds = [
			#'echo -en "\e[6n"',
			'echo -en "\x1b[6n"',
			'read -sd"[" dmy',
			'read -sd"R" row_col',
			'echo -n $row_col >&2',
		]
		cmd = "bash -c '{}'".format( '\n'.join(cmds) )

		proc = cmd_ut.proc_new(cmd, stderr=cmd_ut.PIPE)
		s = proc.communicate()[1].decode()
		proc.wait()

		(row, col) = map( int, s.split(';') )
		(x, y) = (col-1, row-1)
		return (x, y)

	def disp_new():
		(w, h) = wh = get_wh()

		def out(s):
			fw.write(s)
			fw.flush()
			return s

		cursor_show = lambda v: out( esc_seq.cursor_show(v) )
		mov = lambda x, y: out( esc_seq.mov(x, y) )
		scroll = lambda m: out( esc_seq.scroll(m) )
		cls = lambda : out( esc_seq.cls )
		reset = lambda : out( esc_seq.reset )
		rev = lambda : out( esc_seq.rev )
		uline = lambda : out( esc_seq.uline )

		return empty.new( locals(), get_xy=get_xy )

	disp = disp_new()

	def key_new():
		def init():
			stty( 'echo', False )
			stty( 'icanon', False )
			disp.cursor_show( False )

		def fini():
			disp.cursor_show( True )
			stty( 'icanon', True )
			stty( 'echo', True )

		readable = lambda : io_ut.readable( fr )

		def get_block():
			s = os.read( fr.fileno(), 10 )
			if type(s) != str:
				s = ''.join( map( chr, s ) ) # !!! decode()?
			return s

		get = lambda : get_block() if readable() else ''


		ctl = lambda s: chr( 1 + ord(s) - ord('a') ) # control key
		esc = esc_seq.esc # esc key

		allow_tbls = ((
			( 'u', 'd', 'l', 'r' ),
			( esc('A'), esc('B'), esc('D'), esc('C') ), # allow
			( ctl('p'), ctl('n'), ctl('b'), ctl('f') ), # emacs
			( 'k', 'j', 'h', 'l' ), # vi
		), (
			# PAGE
			( 'pu', 'pd', 'pl', 'pr' ),
			( esc('5~'), esc('6~'), esc('8~'), esc('7~') ), # allow
			( chr(0xf6), ctl('v'), ctl('a'), ctl('e') ), # emacs
			( 'b', 'f', '^', '$' ), # less, vi
		))

		allow_dic = {}
		for tbl in allow_tbls:
			lst0 = tbl[0]
			for lst in tbl[1:]:
				for (k, v) in zip(lst, lst0):
					allow_dic[k] = v

		k_to_allow = lambda k, dv='': allow_dic.get( k, dv )
			# return 'u', 'd', 'l', 'r', 'pu', 'pd', pl', 'pr'

		dxy_dic = { 'l': (-1,0), 'r': (1,0), 'u': (0,-1), 'd': (0,1) }
		d_to_dxy = lambda d, dv=None: dxy_dic.get( d, dv )

		k_to_dxy = lambda k, dv=None: d_to_dxy( k_to_allow(k), dv )

		is_ok = lambda k: k in ('\n', ' ')
		is_cancel = lambda k: k in ( chr(0x1b) )
		is_allow = lambda k: k_to_allow(k) != ''

		return empty.new( locals() )

	key = key_new()


	def buff_new(w, h):

		def c_new(c=' ', rev=False, uline=False):

			def set_attr(prev):
				if rev == prev.rev and uline == prev.uline:
					return
				if rev == False or uline == False:
					disp.reset()
				if rev:
					disp.rev()
				if uline:
					disp.uline()

			def reset(disp):
				if rev or uline:
					disp.reset()

			return empty.new( locals() )

		def arr_xy_new(w, h):
			arr = list( map( lambda y: list( map( lambda x: c_new(), range( w ) ) ), range( h ) ) )

			get = lambda x, y: arr[y][x]

			def set(x, y, c):
				arr[y][x] = c
				return c

			return empty.new( locals() )

		arr_xy = arr_xy_new( w, h )

		def ids_new(w, h):
			xy_to_id = lambda x, y: y * w + x
			id_to_xy = lambda id: ( id % w, id // w )

			lst = []

			def add(x, y):
				id = xy_to_id( x, y )
				if id not in lst:
					lst.append( id )
					lst.sort()

			get = lambda : list( map( id_to_xy, lst ) )

			def clear():
				del lst[:]

			return empty.new( locals() )

		ids = ids_new( w, h )

		def init_by():
			(bx, by) = disp.get_xy()
			sc = max( h - ( disp.h - by ), 0 )
			if sc > 0:
				disp.scroll( sc )
				by -= sc
			return by

		by = init_by()

		def putc(x, y, c):
			prev = arr_xy.get( x, y )
			if vars( prev ) != vars( c ):
				arr_xy.set( x, y, c )
				ids.add( x, y )

		def fill(x, y, w_, h_, c):
			for j in range( h_ ):
				for i in range( w_ ):
					x_ = ( x + i ) % w
					y_ = ( y + j ) % h
					putc( x_, y_, c )

		def puts(x, y, s):
			# \tr1 \tr0 \tu0 \tu1

			lst = s.split('\n')
			(rev, uline) = ( False, False )
			for (j, s) in enumerate( lst ):
				i = 0
				while s:
					(c, s) = ( s[0], s[1:] )
					if c == '\t' and len(s) >= 2:
						(k, v, s) = ( s[0], s[1], s[2:] )
						v = ( v != '0' )
						if k == 'r':
							rev = v
						elif k == 'u':
							uline = v
						continue
					putc( x + i, y + j, c_new( c, rev, uline ) )
					i += 1

		def update():
			disp.reset()
			(cx, cy, cc) = ( w, h, c_new() )
			for (x, y) in ids.get():
				if not( y == cy and x == cx ):
					disp.mov( x, by + y )
					(cx, cy) = ( x, y )
				c = arr_xy.get( x, y )
				c.set_attr( cc )
				disp.out( c.c )
				(cx, cy, cc) = ( cx + 1, y, c )
			ids.clear()
			cc.reset( disp )

		def fini():
			disp.reset()
			disp.mov( w - 1, by + h - 1 )
			disp.out( '\n' )

		return empty.new( locals() )

	return empty.new( locals() )
# EOF

#!/usr/bin/env python

import term_ut

if __name__ == "__main__":
	term = term_ut.new()
	buff = term.buff_new( 32, 16 )
	buff.fill( 0, 0, 24, 12, buff.c_new( '.' ) )
	buff.fill( 4, 4, 24, 12, buff.c_new( '-' ) )

	lst = [
		'\tr1' + 'hello' + '\tr0',
		'',
		'foo',
		'',
		'\tu1' + 'bar' + '\tr1' + 'hoge' + '\tr0' + 'fuga',
	]
	s = '\n'.join( lst )
	buff.puts( 2, 2, s )
	buff.update()
	buff.fini()
# EOF

#!/usr/bin/env python

import sys
import os
import time
import base

now_sec = lambda : time.time()

sample = '2020-01-23_12.34.56'

len_digit = lambda s: len( base.filter_str( lambda c: c.isdigit(), s ) )

def is_format_delim(delim):
	if len( delim ) <= 1:
		return False
	n = len_digit( delim )
	smp_n = len_digit( sample )
	return n == smp_n or n == smp_n - 2

def sec_to_str(sec, delim=''):
	if is_format_delim( delim ):
		s = sec_to_str( sec ) # 202001223123456
		if len_digit( delim ) < len( s ):
			s = s[ 2: ]
		lst = list( s ) # [ '2', '0', ... ]
		f = lambda c: lst.pop( 0 ) if c.isdigit() else c
		return base.to_str( map( f, delim ), delim='' )

	t = time.localtime(sec)

	def v_to_s(v):
		s = str(v)
		w = 4 if len(s) > 2 else 2
		return ('0' * w + s)[-w:]

	return delim.join( map( v_to_s, t[:6] ) )

def str_to_sec(s):
	s = ''.join( map( lambda c: c if c.isdigit() else '-', s ) )

	lst = []
	if '-' in s:
		lst = list( map( int, s.split('-') ) )
	else:
		div = lambda s, n: ( s[:n], s[n:] )

		if len(s) > 2 * 6:
			(t, s) = div(s, 4)
			lst.append( int(t) )
		while s:
			(t, s) = div(s, 2)
			lst.append( int(t) )
	while len(lst) < 9:
		lst.append(0)

	y = lst[0]
	if y < 100:
		lst[0] += 2000 if y < 50 else 1900

	return time.mktime( time.struct_time(lst) )

def is_date_time_str(s, delim=''):
	if not is_format_delim( delim ):
		delim = sec_to_str( 0, delim )
		if len( s ) == len( delim ) - 2:
			delim = delim[ 2: ]

	if len( s ) != len( delim ):
		return False

	def f(st):
		(s, t) = st
		return s.isdigit() if t.isdigit() else s == t
	return all( map( f, zip( s, delim ) ) )

def sec_to_fn(pre, sec, ext=''):
	name = pre + sec_to_str(sec)
	return name + ( '.' + ext if ext else '' )

def fn_to_sec(fn):
	(name, ext) = os.path.splitext(fn)
	tail_num = lambda s: tail_num( s[:-1] ) + s[-1] if s and s[-1].isdigit() else ''
	return str_to_sec( tail_num(name) )

mon3_lst = [ 'dmy', 'JAN', 'FEB', 'MAR', 'APR', 'MAY', 'JUN', 'JUL', 'AUG', 'SEP', 'OCT', 'NOV', 'DEC' ]

def get_mon3(str_or_int):
	v = str_or_int
	if type( v ) != int:
		v = int( v )
	return mon3_lst[ v ]

def date432():
	s = sec_to_str( now_sec(), delim='0000 00 00 000000' )
	lst = s.split()[ : 3 ]
	lst[ 1 ] = get_mon3( lst[ 1 ] )
	return '/'.join( lst )


def tm60_to_int(tm60):
	if tm60 < 0:
		return -tm60_to_int( -tm60 )

	(H, L) = ( tm60 // 100, tm60 % 100 )
	(H, L) = ( H + L // 60, L % 60 )

	if H > 0:
		H = tm60_to_int( H ) * 60
	return H + L

def int_to_tm60(v):
	if v < 0:
		return -int_to_tm60( -v )

	(H, L) = ( v // 60, v % 60 )

	if H >= 60:
		H = int_to_tm60( H )
	return H * 100 + L

def tm60_to_str(tm60):
	if tm60 < 0:
		return "-" + tm60_to_str( -tm60 )

	f = lambda s: ':'.join( ( f( s[ : -2 ] ), s[ -2 : ] ) ) if len( s ) > 2 else s
	return f( str( tm60 ) )

def str_to_tm60(s):
	if s.startswith( '-' ):
		return -str_to_tm60( s[ 1 : ] )
	sum = 0
	for s in s.split( ':' ):
		sum = sum * 100 + int( s )
	return sum

tm60_str_to_int = lambda s: tm60_to_int( str_to_tm60( s ) )

tm60_int_to_str = lambda v: tm60_to_str( int_to_tm60( v ) )

def is_tm60_str(s):
	if s.startswith( '-' ):
		s = s[ 1 : ]
	s = s.replace( ':', '' )
	return s.isdigit()

def tm60_show_sum(tm60_str_lst):
	lst = list( map( tm60_str_to_int, tm60_str_lst ) )

	n = len( lst )
	dif_lst = list( map( lambda i: lst[ i + 1 ] - lst[ i ], range( n - 1 ) ) )

	(a, b) = ( [], [] )
	for i in range( n - 1 ):
		t = a if i % 2 == 0 else b
		t.append( dif_lst[ i ] )

	sum_a = sum( a )
	sum_b = sum( b )
	sum_ab = sum_a + sum_b

	f = lambda lst: list( map( tm60_int_to_str, lst ) )

	lst = f( lst )
	dif_lst = f( dif_lst )
	( sum_a, sum_b, sum_ab ) = f( ( sum_a, sum_b, sum_ab ) )

	for i in range( n ):
		print( lst[ i ] )
		if i < n - 1:
			print( '\t' * ( i % 2 + 1 ) + dif_lst[ i ] )

	print( '-' * 16 )
	print( '\t' + sum_a )
	print( '\t\t' + sum_b )
	print( sum_ab )

if __name__ == "__main__":
	s = sys.stdin.read()
	s = s.replace( '-', ' ' )
	lst = s.split()
	lst = list( filter( is_tm60_str, lst ) )
	tm60_show_sum( lst )

# EOF

#!/usr/bin/env python

import time

import empty
import thr
import dbg

def cnt_new(n):
	e = empty.new()
	e.i = 0
	e.p = 0
	e.s_n = 0

	e.st_sec = None
	e.st_i = None
	e.ed_sec = None

	def calc_rsec():
		now = time.time()
		i = e.i
		rsec = -1
		if e.st_sec is None:
			e.st_sec = now
			e.st_i = i
		else:
			rsec = ( now - e.st_sec ) * ( n - i ) / ( i - e.st_i )
		return rsec

	def sec_to_str(sec):
		v = int( sec )
		s = ''
		while v > 0:
			a = str( v % 60 )
			v = v // 60
			if v > 0:
				a = ':' + ( '0' + a )[ -2 : ]
			s = a + s
		return s

	def show(s):
		bk = '\b' * e.s_n
		bk = bk + ( ' ' * e.s_n ) + bk
		e.s_n = len( s )
		dbg.out( bk + s, '' )

	def th_f():
		p = int( 100 * e.i / n )
		if p > e.p:
			e.p = p
			show( '{}%  rest {}'.format( p, sec_to_str( calc_rsec() ) ) )

	th = thr.loop_new( th_f, wait_tmout=1.0 )
	thr.ths.start( th )

	def up():
		if e.i < n:
			e.i += 1
			if e.i == n:
				e.ed_sec = time.time()

	def show_all_sec(fmt):
		st_sec = e.st_sec if e.st_sec else time.time()
		ed_sec = e.ed_sec if e.ed_sec else time.time()
		s = sec_to_str( ed_sec - st_sec )
		dbg.out( fmt.format( s ) )

	def stop(show_fmt=''):
		show( '' )
		th.quit_ev.set()
		if show_fmt:
			show_all_sec( show_fmt )

	return empty.add( e, locals() )

def cnt_map(func, lst, show_fmt=''):
	cnt = cnt_new( len( lst ) )

	def f(v):
		cnt.up()
		return func( v )

	rlst = map( f, lst )
	cnt.stop( show_fmt )
	return rlst

def cnt_loop(func_i, n, show_fmt=''):
	cnt = cnt_new( n )
	for i in range( n ):
		cnt.up()
		func_i( i )
	cnt.stop( show_fmt )

# EOF

#!/usr/bin/env python

import os

import empty


def to_str(lst, pre='', delim='\n', last=False):
	s = delim.join( map( lambda s: pre + s, lst ) )
	if last:
		s += delim
	return s

def filter_str(f, s):
	return ''.join( filter(f, s) )

def filter_div(f, lst):
	not_f = lambda e: not f(e)
	return ( list( filter( f, lst ) ), list( filter( not_f, lst ) ) )

def add_path(base, add, delim='/'):
	lst = []
	if base:
		lst.append( base )
	if add:
		lst.append( add )
	return delim.join( lst )

def path_lst(name, from__file__):
	lst = [ name ]
	dir_ = os.path.dirname( from__file__ )
	if dir_ != '.':
		lst.append( os.path.join( dir_, name ) )

	return list( filter( os.path.exists, lst ) )

def find_path(name, from__file__, dv=None):
	lst = path_lst( name, from__file__ )
	return lst[0] if lst else dv


def can_hash(o):
	try:
		hash( o )
		return True
	except:
		pass
	return False

def rev_dic(dic):
	items = filter( lambda kv: can_hash( kv[ 1 ] ), dic.items() )
	return dict( map( reversed, items ) )


def dic_update_r(targ, add):
	for (k, v) in add.items():
		tv = targ.get( k )
		if type( v ) == dict and type( tv ) == dict:
			dic_update_r( tv, v )
		else:
			targ[ k ] = v


def str_find(s, key_h, key_t=None):
	if key_h not in s:
		return None
	i = s.index( key_h )
	i_in = i + len( key_h )
	s_ = s[ i_in : ]

	if key_t:
		if key_t not in s_:
			return None
		j_in = i_in + s_.index( key_t )
		j = j_in + len( key_t )
	else:
		dlims = ' \t\n'
		f = lambda dlim: s_.index( dlim ) if dlim in s_ else len( s_ )
		j = j_in = i_in + min( map( f, dlims ) )

	s_in = s[ i_in : j_in ]

	return empty.new( locals() )


def str_replace_dic(s, dic):
	keys = [
		( '${', '}' ),
		( '$(', ')' ),
		( '$', None ),
	]

	while True:
		bak = s
		for (key_h, key_t) in keys:
			r = str_find( s, key_h, key_t )
			if r and r.s_in in dic:
				s = s [ : r.i ] + dic.get( r.s_in ) + s [ r.j : ]
				break
		if s == bak:
			break
	return s

# EOF

#!/usr/bin/env python

import empty

rep = lambda s, i, c: s[ : i ] + c + s[ i + 1 : ]

def enc(s, lst):
	lst = list( filter( lambda c2: c2[ 0 ] in s, lst ) )

	e = empty.new()
	e.s = s

	def cvt(c2):
		(c_s, c_d) = c2
		ps = []
		while c_s in e.s:
			i = e.s.index( c_s )
			e.s = rep( e.s, i, c_d )
			ps.append( i )

		ps = '_'.join( map( str, ps ) )
		return '/'.join( [ 's', c_d, str( ord( c_s ) ), ps ] )

	h = '/'.join( map( cvt, reversed( lst ) ) )
	return h + ' ' + e.s

def dec(s):
	if ' ' not in s:
		return s

	def get_hs(s):
		i = s.index( ' ' )
		(h, s) = ( s[ : i ], s[ i + 1 : ] )
		if '/' not in h:
			return None
		h = h.split( '/' )
		if len( h ) % 4 != 0:
			return None
		return empty.new( h=h, s=s )

	e = get_hs( s )
	if not e:
		return s

	def cvt(cmd, c_d, c_s, ps):
		if cmd != 's':
			return False
		c_s = chr( int( c_s ) )
		ps = list( map( int, ps.split( '_' ) ) )
		for i in ps:
			if e.s[ i ] != c_d:
				return False
			e.s = rep( e.s, i, c_s )
		return True

	while e.h:
		(h4, e.h) = ( e.h[ : 4 ], e.h[ 4 : ] )
		if not cvt( * h4 ):
			return s
	return e.s

def sample():
	s = 'abc.FOO.xyz/KONDOH_bar'
	lst = [ 'b.', 'O_' ]
	s_e = enc( s, lst )
	s_d = dec( s_e )
	print( s )
	print( s_e )
	print( s_d )

if __name__ == "__main__":
	sample()
# EOF

#!/usr/bin/env python

import yaml
import six

load = yaml.load # str, file

def load_fn(fn, dv=None):
	o = dv
	with open(fn, 'rb') as f:
		try:
			o = load(f)
		except:
			pass
	return o

dump = yaml.dump

def dump_no_flow(o):
	def represent_str(dumper, instance):
		tag = 'tag:yaml.org,2002:str'
		style = '|' if '\n' in instance else None
		return dumper.represent_scalar( tag, instance, style=style )

	for typ in [ str ] + ( [ unicode ] if six.PY2 else [] ):
		yaml.add_representer(typ, represent_str)

	return dump( o, default_flow_style=False, allow_unicode=True, encoding='utf-8' )

def save(o, fn, dv=''): # no_flow
	s = dump_no_flow(o)
	with open(fn, 'wb') as f:
		try:
			f.write(s)
		except:
			return dv
	return s

# EOF

#!/usr/bin/env python

import os
import yaml

import cmd_ut
import nkf
import arg
import dbg

search_dirs = [ os.path.dirname( __file__ ) ]

def get_cmd(path):
	cmd = 'cat'
	ps = [ 'http', 'https' ]
	if any( map( lambda p: path.startswith( p + '://' ), ps ) ):
		cmd = 'wget -q -O-'
	elif not path.startswith( '/' ) and not os.path.exists( path ):
		for d in search_dirs:
			t = os.path.join( d, path )
			if os.path.exists( t ):
				path = t
				break
	return cmd + ' ' + path

def get_yaml(path, head_only=False):
	cmd = get_cmd( path ) + ' | '
	if head_only:
		cmd += cmd_ut.cmd_py( 'from_to' ) + ' "<head>" "</head>" | '
	cmd += cmd_ut.cmd_py( 'ezhtml' ) + ' h'
	b = cmd_ut.call( cmd )
	(s, opt) = nkf.to_str( b )
	return s

def get_obj(path, head_only=False):
	s = get_yaml( path, head_only )
	o = yaml.load( s )
	if head_only:
		o = { 'html': [ o ] }
	return o

def find_tag(o, tag):
	# Ex. tag 'body'
	t = type( o )

	if t == dict:  # len 1
		(k, v) = list( o.items() )[ 0 ]
		if k.split()[ 0 ].lower() == tag:
			return v
		return find_tag( v, tag )

	if t == list:
		v = None
		for d in o:
			v = find_tag( d, tag )
			if v != None:
				break
		return v

	return None

def find_tag_path(o, tag_path):
	# Ex. tag_path 'html/head/title'

	tags = tag_path.split( '/' )

	v = None
	for tag in tags:
		v = find_tag( o, tag )
		if v == None:
			break
		o = v
	return v

def get_tag_path(path, tag_path):
	head_only = tag_path.startswith( 'html/head' )
	o = get_obj( path, head_only=head_only )
	s = find_tag_path( o, tag_path )
	return s

def get_title(path, dv=''):
	s = get_tag_path( path, 'html/head/title' )
	return s if s else dv

if __name__ == "__main__":
	a = arg.new()
	path = a.pop( 'http://kondoh.html.xdomain.jp/index.html' )
	s = get_title( path )
	print( nkf.enc( s ) )
# EOF

def get_tag_path(path, tag_path):
	head_only = tag_path.startswith( 'html/head' )
	o = get_obj( path )
	s = find_tag_path( o, tag_path )
	return s

(2020/NOV/16 head_only追加)

#!/usr/bin/env python

import sys

import empty
import dbg

def run():
	av = sys.argv[ 1 : ]
	if len( av ) < 2:
		dbg.help_exit( 'from_word to_word' )

	(from_word, to_word) = av[ : 2 ]

	e = empty.new()
	e.show = False

	def cnv(s):
		if e.show:
			if to_word in s:
				i = s.index( to_word ) + len( to_word )
				e.show = False
				return s[ : i ] + cnv( s[ i : ] )
			return s
		else:
			if from_word in s:
				i = s.index( from_word )
				e.show = True
				return cnv( s[ i : ] )
			return ''

	while True:
		s = sys.stdin.readline()
		if not s:
			break
		s = cnv( s )
		sys.stdout.write( s )

if __name__ == "__main__":
	run()
# EOF

#!/usr/bin/env python

import sys

import dbg

def make_lines(s):
	if not s:
		return []
	if '\n' not in s:
		return [ s ]
	i = s.index( '\n' )
	return [ s[ : i + 1 ] ] + make_lines( s[ i + 1 : ] )

def run():
	av = sys.argv[ 1 : ]
	if len( av ) < 1:
		dbg.help_exit( 'pat_file' )

	pat_lines = []
	with open( av[ 0 ], 'r' ) as f:
		pat_lines = make_lines( f.read() )

	#dbg.out( 'pat_lines={}'.format( pat_lines ) )

	buf_lines = []

	def clear():
		del buf_lines[ : ]

	def flush():
		s = ''.join( buf_lines )
		clear()
		return s

	def cnv(s):
		i = len( buf_lines )
		if s == pat_lines[ i ]:
			buf_lines.append( s )
			if len( buf_lines ) == len( pat_lines ):
				clear()
			return ''

		if buf_lines:
			s = flush() + s
		return s

	while True:
		s = sys.stdin.readline()
		if not s:
			break
		s = cnv( s )
		sys.stdout.write( s )

	sys.stdout.write( flush() )

if __name__ == "__main__":
	run()
# EOF

#!/usr/bin/env python

import numpy as np
import math

import empty
import yaml_ut
import dbg


def pos_trans_arr(arr, pos):
	return arr - np.array( [ pos.x, pos.y, pos.z ] )

def pos_trans(xs, ys, zs, pos):
	arr = np.array( [ xs, ys, zs ] ).T
	arr = pos_trans_arr( arr, pos )
	return arr.T

def pa_trans(xs, ys, zs, pa):
	(xs, ys, zs) = pos_trans( xs, ys, zs, pa.p )

	s = math.sin( -pa.a )
	c = math.cos( -pa.a )
	(xs, ys) = ( c * xs - s * ys, s * xs + c * ys )

	return [ xs, ys, zs ]

def pa_trans_arr(arr, pa):
	(xs, ys, zs) = arr.T
	(xs, ys, zs) = pa_trans( xs, ys, zs, pa )
	return np.array( [ xs, ys, zs ] ).T


def get_d2(arr, p):
	(xs, ys, zs) = ( arr - p ).T
	d2_lst = xs * xs + ys * ys + zs * zs
	return d2_lst


def get_near_bools(xs, ys, zs, dist):
	d2 = xs * xs + ys * ys + zs * zs
	bools = d2 <= dist * dist
	return bools

def get_near_bools_arr(arr, dist):
	(xs, ys, zs) = arr.T
	return get_near_bools( xs, ys, zs, dist )

def get_near_arr(arr, dist):
	bools = get_near_bools_arr( arr, dist )
	return arr[ bools, : ]


def to_bytes_head(b):
	h = np.int32( len( b ) ).tobytes()
	return h + b

def from_bytes_head(b):
	(h, b) = ( b[ : 4 ], b[ 4 : ] )
	n = np.frombuffer( h, dtype=np.int32 )[ 0 ]
	(b, t) = ( b[ : n ], b[ n : ] )
	return ( b, t )

def to_bytes_dtype(lst, dtype):
	b = np.array( lst, dtype=dtype ).tobytes()
	return to_bytes_head( b )

def from_bytes_dtype(b, dtype):
	(b, t) = from_bytes_head( b )
	arr = np.frombuffer( b, dtype=dtype ).copy()
	return (arr, t)

def to_bytes_yaml( o ):
	return to_bytes_head( yaml_ut.dump( o ).encode( 'utf-8' ) )

def from_bytes_yaml( b ):
	( b, t ) = from_bytes_head( b )
	o = yaml_ut.load( b.decode( 'utf-8' ) )
	return ( o, t )

def to_bytes_arr( arr ):
	dic = {}
	dic[ 'dtype' ] = str( arr.dtype )
	dic[ 'shape' ] = list( arr.shape )
	b = to_bytes_yaml( dic )
	b += to_bytes_head( arr.tobytes() )
	return b

def from_bytes_arr( b ):
	( dic, b ) = from_bytes_yaml( b )
	dtype = dic.get( 'dtype', 'float32' )
	shape = dic.get( 'shape' )
	( arr, t ) = from_bytes_dtype( b, dtype )
	if shape:
		shape = [ -1 ] + list( shape[ 1 : ] )
		arr = arr.reshape( shape )
	return ( arr, t )

def save_bytes(path, b, show=True):
	end = dbg.start_save( path, show )
	with open( path, 'wb' ) as f:
		f.write( b )
	end()

def load_bytes(path, show=True):
	end = dbg.start_load( path, show )
	b = b''
	with open( path, 'rb' ) as f:
		b = f.read()
	end()
	return b

def save_bytes_dtype(path, lst, dtype, show=True):
	save_bytes( path, to_bytes_dtype( lst, dtype ), show )

def load_bytes_dtype(path, dtype, show=True):
	(arr, t) = from_bytes_dtype( load_bytes( path, show ), dtype )
	return (arr, t )

def write_bytes_head( f, b ):
	f.write( to_bytes_head( b ) )

def read_bytes_head( f ):
	h = f.read( 4 )
	if not h:
		return h
	n = np.frombuffer( h, dtype=np.int32 )[ 0 ]
	return f.read( n )


def get_inf(dic):
	name = dic.get( 'name' )
	is_list = 'type_list' in dic
	typ = dic.get( 'type_list' if is_list else 'type' )
	n = dic.get( 'n', 1 )
	nest = type( typ ) == list
	dtype = eval( typ ) if not nest else None
	dtype_sz = np.dtype( dtype ).itemsize if dtype else None

	def set_n(n):
		dic[ 'n' ] = n

	return empty.new( locals() )


def tobytes_dic(o, dic):
	inf = get_inf( dic )

	v = getattr( o, inf.name, None )
	arr = v if inf.is_list else None
	if arr:
		inf.set_n( len( arr ) )

	if inf.nest:
		dics = inf.typ
		f = lambda o: tobytes( o, dics )
		if not inf.is_list:
			return f( v )
		return b''.join( map( f, arr ) )

	if type( arr ) == bytes:
		return arr

	if not inf.is_list:
		arr = [ v ]

	if arr and type( arr ) != np.ndarray or type( arr[ 0 ] ) != inf.dtype:
		arr = np.array( arr, dtype=inf.dtype )
		inf.set_n( len( arr ) )

	return arr.tobytes()

def tobytes(o, dics):
	f = lambda dic: tobytes_dic( o, dic )
	return b''.join( map( f, dics ) )


def frombytes_dic(buf, dic):
	inf = get_inf( dic )

	if inf.nest:
		dics = inf.typ
		lst = []
		for i in range( inf.n ):
			(o, buf) = frombytes( buf, dics )
			lst.append( o )

		v = lst if inf.is_list else lst[ 0 ]
		return ( inf.name, v, buf )

	v = np.frombuffer( buf, dtype=inf.dtype, count=inf.n )
	n = inf.dtype_sz * inf.n
	buf = buf[ n: ]

	if not inf.is_list and inf.n == 1:
		v = v[ 0 ]

	if inf.dtype == np.uint8:
		v = v.tobytes()
	return ( inf.name, v, buf )

def frombytes(buf, dics):
	o = empty.new()

	for dic in dics:
		(name, v, buf) = frombytes_dic( buf, dic )
		setattr( o, name, v )

	return ( o, buf )


def save(path, o, s_yaml):
	dics = yaml_ut.load( s_yaml )

	buf = tobytes( o, dics )

	s_yaml = yaml_ut.dump_no_flow( dics ).decode()

	n = s_yaml.count( '\n' )
	s = str( n ) + '\n' + s_yaml

	with open( path, 'wb' ) as f:
		f.write( s.encode() )
		f.write( buf )

def info(path):
	buf = b''
	with open( path, 'rb' ) as f:
		s = f.readline()
		n = int( s )
		for i in range( n ):
			buf += f.readline()
		pos = f.tell()

	s_yaml = buf.decode()
	return ( s_yaml, pos )

def load(path):
	(s_yaml, pos) = info( path )

	buf = b''
	with open( path, 'rb' ) as f:
		f.seek( pos )
		buf = f.read()

	dics = yaml_ut.load( s_yaml )

	(o, buf) = frombytes( buf, dics )
	return o


# vec

arr_new = lambda *args: np.array( args )

p000 = arr_new( 0, 0, 0 )
v100 = arr_new( 1, 0, 0 )
v010 = arr_new( 0, 1, 0 )
v001 = arr_new( 0, 0, 1 )

v_len = lambda v: np.dot( v, v ) ** 0.5

def v_unit(v):
	d = v_len( v )
	return v / d if d != 0 else v001

cross_unit = lambda va, vb: v_unit( np.cross( va, vb ) )

cross_y = lambda vx: cross_unit( v001, vx )

cross_z = lambda vx: cross_unit( vx, cross_y( vx ) )


def get_dist_lst(ps, p):
	return ( ( ps - p ).T ** 2 ).sum( axis=0 ) ** 0.5


# q4

def q4_rev(q4):
	(x, y, z, w) = q4
	return arr_new( -x, -y, -z, w )

def q4_mat(q4):
	(x, y, z, w) = q4
	return np.array( [
		[ w, -z, y, x ],
		[ z, w, -x, y ],
		[ -y, x, w, z ],
		[ -x, -y, -z, w ],
	] )

def q4_rot(q4, q4_targ):
	return q4_mat( q4 ).dot( q4_targ )

def q4_rot_v(q4, v):
	v4 = arr_new( v[ 0 ], v[ 1 ], v[ 2 ], 0 )
	q4_ = q4_rev( q4 )
	r4 = q4_rot( q4_rot( q4, v4 ), q4_ )
	return r4[ : 3 ]  # [ x, y, z ]


def q4_cnv(targ_q4, base_q4):
	return q4_rot( q4_rev( base_q4 ), targ_q4 )

def pos_cnv(targ_pos, base_pos, base_q4):
	return q4_rot_v( q4_rev( base_q4 ), targ_pos - base_pos )

def pose_cnv(targ_pos, targ_q4, base_pos, base_q4):
	pos = pos_cnv( targ_pos, base_pos, base_q4 )
	q4 = q4_cnv( targ_q4, base_q4 )
	return ( pos, q4 )


def q4_icnv(targ_q4, base_q4):
	return q4_rot( base_q4, targ_q4 )

def pos_icnv(targ_pos, base_pos, base_q4):
	return q4_rot_v( base_q4, targ_pos ) + base_pos

def pose_icnv(targ_pos_on_base, targ_q4_on_base, base_pos, base_q4):
	pos = pos_icnv( targ_pos_on_base, base_pos, base_q4 )
	q4 = q4_icnv( targ_q4_on_base, base_q4 )
	return ( pos, q4 )


def q4_new_v_arg(v, arg):
	L = v_len( v )
	if L == 0:
		return arr_new( 0, 0, 0, 1 )
	s = math.sin( arg * 0.5 )
	(x, y, z) = v * ( s / L )
	w = math.cos( arg * 0.5 )
	return arr_new( x, y, z, w )

def q4_to_v_arg( q4 ):
	( x, y, z, w ) = q4
	v = arr_new( x, y, z )
	s = v_len( v )
	if s == 0:
		return ( v001, 0 )  # !
	c = w
	arg_h = math.atan2( s, c )
	return ( v_unit( v ), arg_h * 2 )

def get_arg( va, vb, v_rot=None ):
	if v_rot is not None:
		va = np.cross( v_rot, va )
		vb = np.cross( v_rot, vb )
	va = v_unit( va )
	vb = v_unit( vb )
	crs = np.cross( va, vb )
	arg = math.atan2( v_len( crs ), np.dot( va, vb ) )
	if v_rot is not None and np.dot( crs, v_rot ) < 0:
		arg = -arg
	return arg

def std_arg( arg ):
	return math.atan2( math.sin( arg ), math.cos( arg ) )

def posi_arg( arg ):
	arg = std_arg( arg )
	if arg < 0:
		if abs( arg ) < 0.5 * math.pi / 180:
			return 0  # !
		arg += 2 * math.pi
	return arg

def rot_v( v_rot, arg, v_targ ):
	q4 = q4_new_v_arg( v_rot, arg )
	return q4_rot_v( q4, v_targ )

def rot_li_pos( li_rot, arg, p_targ ):
	( c, v_rot ) = li_rot
	return c + rot_v( v_rot, arg, p_targ - c )


def ypr_to_q4(yaw, pitch, roll):
	# yaw, pitch, roll: radian

	yaw_ = q4_new_v_arg( v001, yaw )
	pitch_ = q4_new_v_arg( v010, pitch )
	roll_ = q4_new_v_arg( v100, roll )

	return q4_rot( roll_, q4_rot( pitch_, yaw_ ) )

def q4_to_ypr(q4):
	v = q4_rot_v( q4, v001 )

	roll = 0
	(x, y, z) = v
	if y != 0 or z != 0:
		roll = math.atan2( -y, z )

	v = q4_rot_v( q4_new_v_arg( v100, -roll ), v )

	pitch = 0
	(x, y, z) = v
	if z != 0 or x != 0:
		pitch = math.atan2( x, z )

	v = v100
	v = q4_rot_v( q4, v )
	v = q4_rot_v( q4_new_v_arg( v100, -roll ), v )
	v = q4_rot_v( q4_new_v_arg( v010, -pitch ), v )

	yaw = 0
	(x, y, z) = v
	if x != 0 or y != 0:
		yaw = math.atan2( y, x )

	return ( yaw, pitch, roll )  # radian



def line_plane_cross(line_p, line_v, plane_p, plane_v):
	# ( ( line_p + L * line_v ) - plane_p ) dot plane_v == 0
	# ( line_p - plane_p ) dot plane_v + L * ( line_v dot plane_v ) == 0
	# L = ( plane_p - line_p ) dot plane_v / ( line_v dot plane_v )

	L = np.dot( plane_p - line_p, plane_v ) / np.dot( line_v, plane_v )
	return line_p + L * line_v

def line_plane_cross_point( li, pl ):
	( li_p, li_v ) = li
	( pl_p, pl_v ) = pl
	if np.dot( li_v, pl_v ) == 0:
		return None
	return line_plane_cross( li_p, li_v, pl_p, pl_v )

def plane2_cross_line( pl_a, pl_b ):
	( ap, av ) = pl_a
	( bp, bv ) = pl_b
	if all( av == bv ):
		return None
	v = cross_unit( av, bv )
	tv = cross_unit( av, v )
	p = line_plane_cross_point( [ ap, tv ], pl_b )
	if p is None:
		return None
	return [ p, v ]

def plane3_cross_point( pl3 ):
	li = plane2_cross_line( pl3[ 0 ], pl3[ 1 ] )
	if li is None:
		return None
	return line_plane_cross_point( li, pl3[ 2 ] )

def point3_circle_point( p3 ):
	( p0, p1, p2 ) = p3
	pl0 = [ ( p0 + p1 ) * 0.5, p1 - p0 ]
	pl1 = [ ( p1 + p2 ) * 0.5, p2 - p1 ]
	pl2 = [ p1, cross_unit( p0 - p1, p2 - p1 ) ]
	return plane3_cross_point( [ pl0, pl1, pl2 ] )

def point3_circle_touch_v( p3 ):
	c = point3_circle_point( p3 )
	if c is None:
		return None
	v3 = p3 - c
	rot_v = np.cross( v3[ 0 ], v3[ 1 ] )
	return list( map( lambda v: cross_unit( rot_v, v ), v3 ) )

def point_plane_len(p, plane_p, plane_v):
	return np.abs( np.dot( plane_p - p, plane_v ) / np.dot( plane_v, plane_v ) )

def get_plane_z( pl_p, pl_v, x, y ):
	return ( np.dot( pl_v, pl_p ) - pl_v[ 0 ] * x - pl_v[ 1 ] * y ) / pl_v[ 2 ]


def get_arg_from_line_p2(line_p, line_v, ps, pe):
	os = line_plane_cross( line_p, line_v, ps, line_v )
	oe = line_plane_cross( line_p, line_v, pe, line_v )

	vs = v_unit( ps - os )
	ve = v_unit( pe - oe )
	c = ( vs + ve ) * 0.5

	dx = v_len( c )
	dy = v_len( vs - c )
	arg = 2 * math.atan2( dy, dx )

	if np.dot( np.cross( vs, c ), line_v ) < 0:
		arg = -arg
	return arg

def get_q4_from_vx_vy(vx, vy):
	vx = v_unit( vx )
	vy = v_unit( vy )
	vz = cross_unit( vx, vy )

	dx = vx - v100
	dy = vy - v010
	dz = vz - v001

	lx = v_len( dx )
	ly = v_len( dy )
	lz = v_len( dz )

	if lx >= lz and ly >= lz:
		rot_v = cross_unit( dx, dy )
		arg_x = get_arg_from_line_p2( p000, rot_v, v100, vx )
		arg_y = get_arg_from_line_p2( p000, rot_v, v010, vy )
		arg = ( arg_x + arg_y ) * 0.5
	elif ly >= lx and lz >= lx:
		rot_v = cross_unit( dy, dz )
		arg_y = get_arg_from_line_p2( p000, rot_v, v010, vy )
		arg_z = get_arg_from_line_p2( p000, rot_v, v001, vz )
		arg = ( arg_y + arg_z ) * 0.5
	else:
		rot_v = cross_unit( dz, dx )
		arg_z = get_arg_from_line_p2( p000, rot_v, v001, vz )
		arg_x = get_arg_from_line_p2( p000, rot_v, v100, vx )
		arg = ( arg_z + arg_x ) * 0.5

	return q4_new_v_arg( rot_v, arg )

def corr_q4_by_ps_pe(ps, pe, targ_q4):
	vx = pe - ps
	inc_vz = pos_icnv( v001, p000, targ_q4 )
	vy = cross_unit( inc_vz, vx )
	base_q4 = get_q4_from_vx_vy( vx, vy )
	return q4_cnv( targ_q4, base_q4 )


def newton( f, a, b, lmt ):
	va = f( a )
	vb = f( b )
	if va * vb > 0:
		return None

	while abs( b - a ) > lmt:
		if va == 0:
			return a
		if vb == 0:
			return b

		c = ( a + b ) * 0.5
		vc = f( c )
		if va * vc >= 0:
			( a, va ) = ( c, vc )
		else:
			( b, vb ) = ( c, vc )
	return c


def curve_new(plst, vs=None, ve=None):
	# plst = [ [ x, y, z ], [ x, y, z], ... ]

	n = len( plst )
	Ls = np.zeros( n )
	Ds = np.zeros_like( plst )
	dlst = np.zeros_like( plst )

	for i in range( n - 1 ):
		ps = plst[ i ]
		pe = plst[ i + 1 ]
		Ls[ i ] = v_len( pe - ps)
		Ds[ i ] = ( pe - ps ) / Ls[ i ]

	for i in range( n - 2 ):
		ds = Ds[ i ]
		de = Ds[ i + 1 ]
		dlst[ i + 1 ] = ( ds + de ) * 0.5

	dlst[ 0 ] = Ds[ 0 ] * 2 - dlst[ 1 ] if vs is None else v_unit( vs )
	dlst[ -1 ] = Ds[ n - 2 ] * 2 - dlst[ -2 ] if ve is None else v_unit( ve )


	def get_ABCDL(ps, pe, ds, de, L):
		# 3A * LL + 2B L + C = de
		# A * LLL + B LL + C L + D = pe

		# 3A * LLL + 2B LL + C L = de L
		# 2A * LLL + 2B LL + 2C L + 2D = 2 pe

		# A * LLL - C L - 2 D = de L - 2 pe
		# A = ( de L - 2 pe + C L + 2 D ) / LLL
		# A = ( ( de + C ) * L + 2 * ( D - pe ) ) / LLL

		# 2B L = de - C - 3A * LL
		# B = ( de - C - 3A * LL ) / 2L

		C = ds
		D = ps
		A = ( ( de + C ) * L + 2 * ( D - pe ) ) / L ** 3
		B = ( de - C - 3 * A * L * L ) / ( 2 * L )
		return [ A, B, C, D, L ]

	def get_ABCDL_i( i ):
		return get_ABCDL( plst[ i ], plst[ i + 1 ], dlst[ i ], dlst[ i + 1 ], Ls[ i ] )

	ABCDLs = []
	for i in range( n - 1 ):
		ABCDL = get_ABCDL_i( i )
		ABCDLs.append( ABCDL )

	def update_ABCDLs( i ):
		if 0 <= i and i < len( ABCDLs ):
			ABCDLs[ i ] = get_ABCDL_i( i )

	def update_dlst( i, v ):
		# i < len( plst )
		dlst[ i ] = v
		update_ABCDLs( i )
		update_ABCDLs( i - 1 )

	def get_pos_lst( dist=0.5, strict_spc=False ):
		get_pos = lambda A, B, C, D, t: A * t ** 3 + B * t ** 2 + C * t + D

		def get_pos_idx_rate( i, rate ):
			( A, B, C, D, L ) = ABCDLs[ i ]
			t = L * rate
			return get_pos( A, B, C, D, t )

		lst = []
		n = len( ABCDLs )

		if strict_spc:
			( i, rate ) = ( 0, 0 )
			p = get_pos_idx_rate( i, rate )
			lst.append( p )
			while i < n:
				f = lambda r: v_len( get_pos_idx_rate( i, r ) - lst[ -1 ] ) - dist
				rate = newton( f, rate, 1.0, 0.001 )
				if rate is None:
					i += 1
					rate = 0
				else:
					p = get_pos_idx_rate( i, rate )
					lst.append( p )
			p = get_pos_idx_rate( n - 1, 1.0 )
			lst.append( p )
		else:
			for i in range( n ):
				(A, B, C, D, L) = ABCDLs[ i ]
				m = max( int( L / dist ), 1 )
				for j in range( m ):
					t = L * j / m
					lst.append( get_pos( A, B, C, D, t ) )
				if i == n - 1:
					lst.append( get_pos( A, B, C, D, L ) )
		return lst

	return empty.new( locals() )


def get_plane_from_points(ps):
	pl_p = np.mean( ps, axis=0 )

	adj = ps - pl_p
	mat = np.cov( adj.T )
	(w, v) = np.linalg.eig( mat )

	sort = w.argsort()[::-1]
	#w = w[ sort ]
	v = v[ : , sort ]

	pl_v = v[ : , 2 ]

	if pl_v.dtype == np.complex128:
		return None  # !

	return ( pl_p, pl_v )

# EOF

#!/usr/bin/env python

import empty
import np_ut
import arg
import dbg

def data():
	o = empty.new()
	o.header = empty.new()
	o.header.seq = 1
	o.header.stamp = empty.new()
	o.header.stamp.secs = 2
	o.header.stamp.nsecs = 3

	p0 = empty.new()
	p0.stamp = empty.new()
	p0.stamp.secs = 4
	p0.stamp.nsecs = 5
	p0.data = b'\x06\x07\x08'

	p1 = empty.new()
	p1.stamp = empty.new()
	p1.stamp.secs = 9
	p1.stamp.nsecs = 10
	p1.data = b'\x0b\x0c\x0d'

	o.packets = [ p0, p1 ]

	s_yaml = '''
	- name: header
	  type:
	  - { name: seq, type: np.uint32 }
	  - name: stamp
	    type:
	    - { name: secs, type: np.int32 }
	    - { name: nsecs, type: np.int32 }
	- name: packets
	  type_list:
	  - name: stamp
	    type:
	    - { name: secs, type: np.int32 }
	    - { name: nsecs, type: np.int32 }
	  - { name: data, type_list: np.uint8 }
	'''.replace( '\t', '' )

	return ( o, s_yaml )

def data_1():
	o = empty.new()
	o.n = 3
	o.pos = empty.new()
	o.pos.x = 12.3
	o.pos.y = 45.6

	s_yaml = '''
	- { name: n, type: np.int32 }
	- name: pos
	  type:
	  - { name: x, type: np.float32 }
	  - { name: y, type: np.float32 }
	'''.replace( '\t', '' )

	return ( o, s_yaml )

def data_2():
	o = empty.new()
	o.int_0_9 = list( range( 10 ) )
	o.v_lst = [ 1, 0.5, 99 ]

	s_yaml = '''
	- { name: int_0_9, type_list: np.int32 }
	- { name: v_lst, type_list: np.float32 }
	'''.replace( '\t', '' )

	return ( o, s_yaml )

def test_obj_yaml(sample=None):
	s = 'data'
	if sample:
		s = 'data_{}'.format( sample )
	f = eval( s )
	return f()

def test_save(path, sample):
	(o, s_yaml) = test_obj_yaml( sample )
	np_ut.save( path, o, s_yaml )

def test_info(path):
	(s_yaml, pos) = np_ut.info( path )
	dbg.out( s_yaml )
	dbg.out( 'pos={}'.format( pos ) )

def test_load(path, sample):
	o = np_ut.load( path )

	d = empty.to_dic( o )
	dbg.out( 'd={}'.format( d ) )

	(o_, s_yaml) = test_obj_yaml( sample )
	d_ = empty.to_dic( o_ )
	dbg.out( 'd_={}'.format( d_ ) )

if __name__ == "__main__":
	cmds = [
		arg.cmd_new( 'test_save', [ 'path' ], opts={ 'sample': None } ),
		arg.cmd_new( 'test_info', [ 'path' ] ),
		arg.cmd_new( 'test_load', [ 'path' ], opts={ 'sample': None } ),
	]
	cmd = arg.get_name_args( cmds )

	f = eval( cmd.name )
	f( *cmd.args, **cmd.opts )
# EOF

#!/usr/bin/env python

import os

import empty
import tm_ut
import base
import cmd_ut

to_str = base.to_str
cmd_call = lambda cmd: cmd_ut.call( cmd, b2s=True )
cmd_lst = lambda cmd: sorted( cmd_call( cmd ).strip().split('\n') )


# fs

# #define S_IFMT 0170000           /* type of file */
# #define        S_IFIFO  0010000  /* named pipe (fifo) */
# #define        S_IFCHR  0020000  /* character special */
# #define        S_IFDIR  0040000  /* directory */
# #define        S_IFBLK  0060000  /* block special */
# #define        S_IFREG  0100000  /* regular */
# #define        S_IFLNK  0120000  /* symbolic link */
# #define        S_IFSOCK 0140000  /* socket */
# #define        S_IFWHT  0160000  /* whiteout */
# #define S_ISUID 0004000  /* set user id on execution */
# #define S_ISGID 0002000  /* set group id on execution */
# #define S_ISVTX 0001000  /* save swapped text even after use */
# #define S_IRUSR 0000400  /* read permission, owner */
# #define S_IWUSR 0000200  /* write permission, owner */
# #define S_IXUSR 0000100  /* execute/search permission, owner */

mode_type_dic = {
	'S_IFMT':   0o170000,
	'S_IFIFO':  0o010000,
	'S_IFCHR':  0o020000,
	'S_IFDIR':  0o040000,
	'S_IFBLK':  0o060000,
	'S_IFREG':  0o100000,
	'S_IFLNK':  0o120000,
	'S_IFSOCK': 0o140000,
	'S_IFWHT':  0o160000,
	'S_ISUID':  0o004000,
	'S_ISGID':  0o002000,
	'S_ISVTX':  0o001000,
	'S_IRUSR':  0o000400,
	'S_IWUSR':  0o000200,
	'S_IXUSR':  0o000100,
}

def is_mode_type(mode, name):
	mask = mode_type_dic.get( 'S_IFMT', 0 )
	v = mode_type_dic.get( name, 0 )
	return mode & mask == v

is_mode_dir = lambda mode: is_mode_type( mode, 'S_IFDIR' )
is_mode_slink = lambda mode: is_mode_type( mode, 'S_IFLNK' )


def fs_new(mode, sec, size, path):
	def to_txt():
		lst = ( oct( mode ), tm_ut.sec_to_str( sec, tm_ut.sample ), str( size ), path )
		return to_str( lst, delim=' ' )

	def eq_mode(o_mode):
		(a, b) = ( mode, o_mode )

		is_allow_grp = ( lambda :
			( is_mode_slink( a ) and is_mode_slink( b ) ) or
			( is_mode_type( a, 'S_IFREG' ) and is_mode_type( b, 'S_IFREG' ) ) )

		if is_allow_grp():
			# 0120777 2018-10-13_00.36.06 13 argmnt/ido.sh
			# 0o120755 2018-10-13_00.36.06 13 argmnt/ido.sh
			mask_clr = 0o22
			a &= ~mask_clr
			b &= ~mask_clr

		return a == b

	eq = lambda o: eq_mode( o.mode ) and o.sec == sec and o.size == size and o.path == path

	return empty.new( locals() )

def fs_new_path(dir_path, path):
	st = os.lstat( os.path.join( dir_path, path ) )
	return fs_new( st.st_mode, int( st.st_mtime ), st.st_size, path )

def fs_new_str(s):
	lst = s.split( ' ' )
	(mode, sec, size, path) = lst[:3] + [ to_str( lst[3:], delim=' ' ) ]
	return fs_new( int( mode, 8 ), tm_ut.str_to_sec( sec ), int( size ), path )


# snap

def new_fss(fss, sec):
	get_paths = lambda : list( map( lambda fs: fs.path, fss ) )
	get_txt = lambda: to_str( map( lambda fs: fs.to_txt(), fss ), last=True )

	def write(fn):
		s = tm_ut.sec_to_str( sec, tm_ut.sample ) + '\n' + get_txt()
		with open( fn, 'w' ) as f:
			f.write( s )

	return empty.new( locals() )

def new_dir(dir_path):
	sec = tm_ut.now_sec()
	dir_paths = cmd_lst( 'find {} -type f -o -type l'.format( dir_path ) ) # files and symlinks
	dir_paths = filter( lambda s: s, dir_paths )
	paths = list( map( lambda s: os.path.relpath( s, start=dir_path ), dir_paths ) )
	fss = list( map( lambda path: fs_new_path( dir_path, path ), paths ) )
	return new_fss( fss, sec )

def new_fn(fn):
	s = ''
	with open( fn, 'r' ) as f:
		s = f.read().strip()
	lst = s.split( '\n' )
	(sec, lst) = ( tm_ut.str_to_sec( lst[ 0 ] ), lst[ 1: ] )
	fss = list( map( fs_new_str, lst ) )
	return new_fss( fss, sec )

def cmp_new(snap_old, snap_new):
	old = snap_old.get_paths()
	new = snap_new.get_paths()

	rm = list( filter( lambda p: p not in new, old ) )
	add = list( filter( lambda p: p not in old, new ) )
	com = list( filter( lambda p: p in old, new ) )

	fss_old = snap_old.fss
	fss_new = snap_new.fss
	fss_old_com = list( filter( lambda fs: fs.path in com, fss_old ) )
	fss_new_com = list( filter( lambda fs: fs.path in com, fss_new ) )

	(same, chg) = ( [], [] )
	for (fs_a, fs_b) in zip( fss_old_com, fss_new_com ):
		if fs_a.eq( fs_b ):
			same.append( fs_b.path )
		else:
			chg.append( fs_b.path )

	is_same = lambda : not ( rm + add + chg )

	e = empty.new()

	get_k_str = lambda k: to_str( getattr( e, k, '' ), pre=k+' ' )

	def get_ks_str(ks):
		ks = filter( lambda k: getattr(e, k), ks )
		return to_str( map( get_k_str, ks ) )

	rm_add_chg_str = lambda : get_ks_str( ( 'rm', 'add', 'chg' ) )

	return empty.to_attr( e, locals() )
# EOF

#!/usr/bin/env python

import os
import yaml
import numpy as np

import empty
import thr
import cmd_ut
import yaml_ut
import dbg

thr_gc = thr.gc_new()

silent = False

def dbg_out(s, tail='\n'):
	if not silent:
		dbg.out( s, tail )

def wait_msg_new(msg, tail='OK'):
	dbg_out( msg + ' ', '' )
	th = thr.loop_new( dbg_out, ( '.', '' ), wait_tmout=1.0, gc=thr_gc )
	th.start()

	def stop():
		th.stop()
		dbg_out( ' ' + tail )

	return empty.new( locals() )


def cmd_wait_msg(cmd, msg):
	wait_msg = wait_msg_new( msg )
	cmd_ut.call( cmd )
	wait_msg.stop()


def rm(name):
	cmd = 'rm -f ' + name
	cmd_wait_msg( cmd, 'del ' + name )


def load_bytes(name):
	wait_msg = wait_msg_new( 'load ' + name )
	b = bytes( [] )
	with open( name, 'rb' ) as f:
		b = f.read()
	wait_msg.stop()
	return b

def load_bytes_part( name, from_byte=None, to_byte=None ):
	if from_byte is None and to_byte is None:
		return load_bytes( name )

	if from_byte is None:
		from_byte = 0

	if to_byte is None:
		st = os.lstat( name )
		to_byte = st.st_size

	b = bytes( [] )
	with open( name, 'rb' ) as f:
		if from_byte > 0:
			f.seek( from_byte )
		b = f.read( to_byte - from_byte )
	return b

def save_bytes(name, b):
	wait_msg = wait_msg_new( 'save ' + name )
	with open( name, 'wb' ) as f:
		f.write( b )
	wait_msg.stop()


def cvt(name, from_ext, to_ext, raw_opt=''):
	cmd = ''

	if from_ext == 'mp3' and to_ext == 'wav':
		cmd = 'lame --decode {}.mp3 > /dev/null 2>&1'.format( name )

	elif from_ext == 'wav' and to_ext == 'raw':
		cmd = 'sox {}.wav {}.raw'.format( name, name )

	elif from_ext == 'wav' and to_ext == 'inf':
		cmd = 'sox --info {}.wav > {}.inf'.format( name, name )

	elif from_ext == 'raw' and to_ext == 'wav':  # raw_opt
		cmd = 'sox {} {}.raw {}.wav'.format( raw_opt, name, name )

	elif from_ext == 'wav' and to_ext == 'mp3':
		cmd = 'lame {}.wav {}.mp3 > /dev/null 2>&1'.format( name, name )

	if cmd:
		cmd_wait_msg( cmd, 'cvt {}.{} to {}.{}'.format( name, from_ext, name, to_ext ) )


def make(name, ext, direc='load', raw_opt=''):
	if os.path.exists( '{}.{}'.format( name, ext ) ):
		return

	rule = {
		'load': { 'raw': 'wav', 'inf': 'wav', 'wav': 'mp3' },
		'save': { 'mp3': 'wav', 'wav': 'raw' },
	}

	from_ext = rule.get( direc, {} ).get( ext )
	if not from_ext:
		dbg.err_exit( 'not found {}.{}'.format( name, ext ) )

	make( name, from_ext, direc, raw_opt )
	cvt( name, from_ext, ext, raw_opt )

	if direc == 'save':
		rm( '{}.{}'.format( name, from_ext ) )


def inf_new(name):
	make( name, 'inf', 'load' )

	dic = yaml_ut.load_fn( name + '.inf', {} )

	r = float( dic.get( 'Sample Rate', 44100 ) )

	b = 16
	s = dic.get( 'Precision' )
	if s.endswith( '-bit' ):
		b = int( s[ : -len( '-bit' ) ] )

	c = int( dic.get( 'Channels', 2 ) )

	e = 'signed-integer'
	s = dic.get( 'Sample Encoding', 'Signed' )
	if 'Signed' not in s:
		e = 'unsigned-integer'

	get_raw_opt = lambda r_rate=1.0: '-t raw -r {} -b {} -c {} -e {}'.format( r * r_rate, b, c, e )

	lst = dic.get( 'Duration', '' ).split()
	k = 'samples'
	i = lst.index( k ) if k in lst else -1
	smp_n = int( lst[ i - 1 ] ) if i > 0 else -1

	byte_per_smp = c * ( b // 8 )
	smp_sec = lambda sec: int( sec * r )
	smp_to_sec = lambda m: m / r
	byte_sec = lambda sec: smp_sec( sec ) * byte_per_smp
	byte_to_sec = lambda n: smp_to_sec( n // byte_per_smp )

	is_unsigned = lambda : e == 'unsigned-integer'
	get_dtype = lambda : '{}int{}'.format( 'u' if is_unsigned() else '', b )

	return empty.new( locals() )


def data_new(name_mp3):

	(name, mp3) = os.path.splitext( name_mp3 )

	inf = inf_new( name )

	def bytes_to_arr(b):
		arr = np.frombuffer( b, inf.get_dtype() )
		arr = np.array( arr, dtype='float64' )

		half = 2 ** ( inf.b - 1 )
		if inf.is_unsigned():
			arr -= half
		return arr / half

	def arr_to_bytes(arr):
		half = 2 ** ( inf.b - 1 )
		arr = arr * half

		arr = np.maximum( arr, -half )
		arr = np.minimum( arr, half - 1 )

		if inf.is_unsigned():
			arr += half

		arr = np.array( arr, dtype=inf.get_dtype() )
		return arr.tobytes()

	e = empty.new()
	e.raw_bytes = None
	e.exists_raw = False

	def make_raw():
		if not e.exists_raw:
			make( name, 'raw', 'load' )
			e.exists_raw = True

	def get_bytes_cache(start_sec=0, end_sec=-1):
		if e.raw_bytes == None:
			make_raw()
			e.raw_bytes = load_bytes( name + '.raw' )

		if start_sec == 0 and end_sec < 0:
			return e.raw_bytes

		start = inf.byte_sec( start_sec )
		end = inf.byte_sec( end_sec ) if end_sec >= 0 else len( e.raw_bytes )
		return e.raw_bytes[ start : end ]

	def get_bytes( start_sec=0, end_sec=-1, cache=True ):
		if cache:
			return get_bytes_cache( start_sec, end_sec )

		make_raw()
		from_byte = inf.byte_sec( start_sec )
		to_byte = inf.byte_sec( end_sec ) if end_sec >= 0 else None
		return load_bytes_part( name + '.raw', from_byte, to_byte )

	def get_arr(start_sec=0, end_sec=-1):
		b = get_bytes( start_sec, end_sec )
		return bytes_to_arr( b )

	def save_bytes_to(b, save_name):
		(sname, ext) = os.path.splitext( save_name )
		if not ext or ext not in ( 'raw', 'wav', 'mp3' ):
			ext = 'mp3'

		rm( save_name )
		save_bytes( sname + '.raw', b )
		if ext != 'raw':
			make( sname, ext, 'save', inf.get_raw_opt() )

	def save_arr(arr, save_name):
		b = arr_to_bytes( arr )
		save_bytes_to( b, save_name )

	return empty.add( e, locals() )


# EOF

#!/usr/bin/env python

import os
import sys
import pty
import dbg

if __name__ == "__main__":
	cmd = sys.argv[1:]
	if cmd:
		pty.spawn( cmd )
	else:
		dbg.help_exit( 'cmd ...' )
# EOF

#!/usr/bin/env python

import empty
import thr
import cmd_ut
import yaml_ut
import base
import dbg

thr_gc = thr.gc_new()

def ecmd_new(cmd, id, que):
	proc = cmd_ut.proc_new( cmd, stdout=cmd_ut.PIPE )
	que.put( 'start cmd ' + cmd )
	f = proc.get_stdout()

	def stop():
		proc.kill()
		proc.wait()
		que.put( 'stop cmd ' + cmd )

	def th_f():
		while True:
			s = f.readline().decode()
			if not s:
				break
			s = s.strip()
			if s:
				que.put( id + ': ' + s )

	thr.th_new( th_f, gc=thr_gc ).start()

	return empty.new( locals() )

def run():
	data_fn = 'cmds_out.yaml'
	fn = base.find_path( data_fn, __file__ )
	if not fn:
		dbg.err_exit( data_fn + ' ?' )

	d = yaml_ut.load_fn( fn )
	lst = d.get( 'cmds', [] )
	rdic = d.get( 'replace', {} )

	th_show = thr.loop_que_new( dbg.out, 1.0, gc=thr_gc )
	th_show.start()

	ecmds = []
	for d in lst:
		o = empty.new( d, cmd='', id='' )
		if o.cmd:
			o.cmd = base.str_replace_dic( o.cmd, rdic )

			ecmd = ecmd_new( o.cmd, o.id, th_show.que )
			ecmds.append( ecmd )

	sigint = thr.sigint_new()
	sigint.wait()
	sigint.fini()

	for ecmd in ecmds:
		ecmd.stop()
	th_show.stop()
	thr_gc.stop()

if __name__ == "__main__":
	run()
# EOF

cmds:
- id: ping
  cmd: ping $HOST

- id: date
  cmd: while true; do date; sleep $(WAIT); done

- id: header file
  cmd: find /usr/include -type f | sed -e "s/^/echo /" -e "s/$/; sleep ${FIND_WAIT}/" | sh

replace:
  HOST: www.google.com
  WAIT: "5"
  FIND_WAIT: "2"

# EOF