def combinate(l, repeat=2, **kwargs):
st = eftl.dflt_kwargs("sort", False, **kwargs)
rslt = [each for each in itertools.combinations(l, repeat)]
rslt = list(rslt)
rslt = elel.mapv(rslt, list, [])
rslt = elel.mapv(rslt, sorted, []) if (st) else rslt
return (rslt)
def product(l, repeat=2, **kwargs):
st = eftl.dflt_kwargs("sort", False, **kwargs)
rslt = itertools.product(l, repeat=repeat)
rslt = list(rslt)
rslt = elel.mapv(rslt, list, [])
rslt = elel.mapv(rslt, sorted, []) if (st) else rslt
return (rslt)
def get_attrs_chain(obj):
'''
>>> class tst():
... def __init__(self):
... self._u = "_u"
... self.u = "u"
...
>>> t = tst()
>>>
>>> parr(get_attrs_chain(t))
['_u', 'u']
['__dict__', '__module__', '__weakref__']
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']
>>>
'''
mros = get_mros(obj)
chain = elel.mapv(mros, get_all_attrs)
st_chain = elel.mapv(chain, set)
lngth = len(chain)
owns = []
for i in range(0, lngth - 1):
ownattrs = st_chain[i].difference(st_chain[i + 1])
owns.append(ownattrs)
owns.append(st_chain[-1])
owns = elel.mapv(owns, lambda st: elel.sort(list(st)))
return (owns)
def wfsm2orb(wfsm, jobj):
o = orb.Orb()
eles = wfsmat.wfs_eles(wfsm)
fpls = elel.mapv(eles, lambda ele: ele.fpl)
fapls = elel.mapv(eles, lambda ele: ele.fapl)
tpls = elel.mapv(eles, lambda ele: ele['type'])
ptpls = elel.mapv(eles, lambda ele: ele['ptype'])
#im_pjobj intermediate-pjobj 例如set 对应成list
impjobjs = elel.mapv(eles, lambda ele: ele['im_pjobj'])
for i in range(len(fapls)):
fapl = fapls[i]
fpl = fpls[i]
tp = tpls[i]
ptp = ptpls[i]
pjobj = impjobjs[i]
dflt = orb.Orb()
del dflt._data
#super trick!
dflt.__setattr__(orb._INTERNAL_ATTR_MAP['fpl'], fpl)
dflt.__setattr__('_data', jobj)
dflt.__setattr__('_type', tp)
dflt.__setattr__('_ptype', ptp)
dflt.__setattr__('_im_pjobj', pjobj)
afplfuncs.setdflt_fpl(o, fapl, value=dflt, _inited=True)
#this is a trick
o._ζ = True
return (o)
def creat_api_names(pre,verb,suf):
params = creat_apifix(pre)
rtrns = creat_apifix(suf)
tl = list(itertools.product(params,rtrns))
tl = elel.mapv(rtrns,lambda ele:("",ele)) if(len(params)==0) else tl
tl = elel.mapv(params,lambda ele:(ele,"")) if(len(rtrns)==0) else tl
names = elel.mapv(tl,lambda ele:ele[0]+verb+ele[1])
return(names)
def creat_usage_from_code(cd):
root = ast.parse(cd)
d = wfsdig(root)
body = d['body']
funcs = elel.cond_select_all(d['body'],cond_func=lambda ele:ele['_type'] == 'FunctionDef')
kl = elel.mapv(funcs,lambda func:func['name'])
vl = elel.mapv(funcs,lambda func:[func['body'][0]['value']['s']])
usage = creat_rst(kl,vl)
return(usage)
def creat_timezones_prompt_orb():
root = Orb()
all_timezones = pytz.all_timezones
arr = elel.mapv(all_timezones, lambda ele: ele.split('/'))
arr = elel.mapv(arr, lambda ele: zone_to_an_arr_map_func(ele))
arr.sort()
for i in range(len(arr)):
pl = arr[i]
set_via_pl_from_root(root, pl, an_arr_to_leaf)
return (root)
def get_word_abbr(ounhandled, regex=re.compile('[-_ ]')):
cond = isinstance(regex, type(re.compile('')))
regex = regex if (cond) else re.compile(regex)
unhandled = elel.mapv(ounhandled, lambda r: eses.split(r, regex))
unhandled = elel.mapv(unhandled, lambda r: padding_entry(r))
unhandled = elel.mapv(unhandled, lambda r: elel.interleave(*r))
unhandled = elel.mapv(unhandled, lambda r: elel.join(r, ''))
refd = eded.kvlist2d(unhandled, ounhandled)
abbr = get_one_word_abbr(unhandled)
for k in abbr:
v = abbr[k]
abbr[k] = refd[v]
return (abbr)
def _repl_cols(df,poses,*args,**kwargs):
df = copy.deepcopy(df)
args = list(args)
if(isinstance(args[0],dict)):
kl,vl = eded.d2kvlist(args[0])
else:
if(isinstance(args[1],list)):
kl = elel.select_evens(args)
vl = elel.select_odds(args)
else:
kl,vl = elel.brkl2kvlist(args,df.index.__len__()+1)
if(isinstance(poses[0],int)):
pass
else:
colnames = poses
clocs_array = []
for i in range(colnames.__len__()):
clocs = _cn2clocs(colnames[i],**kwargs)
clocs_array.append((clocs,i))
if("whiches" in kwargs):
whiches = kwargs['whiches']
clocs_array = elel.mapv(clocs_array,lambda ele:ele[0])
clocs = elel.batexec(lambda clocs,which:clocs[which],clocs_array,whiches)
poses = clocs
else:
#by default replace all
nkl = []
nvl = []
nclocs = []
for i in range(clocs_array.__len__()):
clocs = clocs_array[i][0]
index = clocs_array[i][1]
tmpkl = elel.init(clocs.__len__(),kl[i])
tmpvl = elel.init(clocs.__len__(),vl[i])
nkl = elel.concat(nkl,tmpkl)
nvl = elel.concat(nvl,tmpvl)
nclocs = elel.concat(nclocs,clocs)
#batsort
poses = nclocs
kl,vl = elel.batsorted(nclocs,nkl,nvl)
poses = elel.mapv(poses,lambda pos:pos+1)
poses.sort()
for i in range(0,poses.__len__()):
pos = poses[i]
df.insert(pos,kl[i],vl[i],kwargs['allow_duplicates'])
pos = pos -1
all_clocs = elel.init_range(0,df.columns.__len__(),1)
all_clocs.remove(pos)
df = df.iloc[:,all_clocs]
return(df)
def qtbl2dtb(qtbl):
'''
from qtable.qtable import *
from xdict.jprint import pobj,pdir,parr
qtbl
qtbl = Qtable(mat= np.arange(25).reshape((5,5)),index=['a','c','d','a','e'],columns=['one', 'two', 'three','one','four'])
parr(qtbl2dtb(qtbl))
>>> qtbl
one two three one four
a 0 1 2 3 4
c 5 6 7 8 9
d 10 11 12 13 14
a 15 16 17 18 19
e 20 21 22 23 24
>>>
>>> parr(qtbl2dtb(qtbl))
{'one': 3, 'two': 1, 'three': 2, 'four': 4}
{'one': 8, 'two': 6, 'three': 7, 'four': 9}
{'one': 13, 'two': 11, 'three': 12, 'four': 14}
{'one': 18, 'two': 16, 'three': 17, 'four': 19}
{'one': 23, 'two': 21, 'three': 22, 'four': 24}
'''
ks = qtbl.columns
mat = qtbl.to_mat()
depth = len(qtbl.index)
dtb = elel.mapv(mat,lambda row:eded.kvlist2d(ks,row))
return(dtb)
def plmat2edfspls(plmat):
plmat = wfsfpls2plmat(wfsfpls,**kwargs)
plmat = plmat_fill_pbreadth(plmat)
plmat = plmat_fill_children(plmat)
edfsel = m2edfsel(plmat)
edfspls = elel.mapv(edfsel,lambda ele:ele.fpl)
return(edfspls)
def m2full_fpls(m):
"""
包括start 与 end 的 全路径
"""
fdfs_locl = m2full_dfs_locl(m)
full_fpls = elel.mapv(fdfs_locl,lambda loc:loc2ele(loc,m).fpl)
return(full_fpls)
def linefill(line, c):
def map_func(colorId, c):
c = spaint.paint_str(c, color_sec=[(0, 2, colorId, colorId)])
return (c)
line = elel.mapv(line, map_func, [c])
return (line)
def get_cates():
res = req.get(URL)
html_txt = res.text
root = LXHTML(html_txt)
cates = engine.xpath(root,"//h3")
for i in range(len(cates)):
nd = cates[i]
cate = CATEGORY_MD[nd.text]
tb = engine.rsib(nd)
a = engine.xpath(tb,"tr/td/a")
tags = elel.mapv(a,lambda ele:ele.text[1:-1])
ntags = []
for tag in tags:
if(tag == "!DOCTYPE"):
tag = "<doctype>"
ntags.append(tag)
elif(tag == "!--...--"):
tag = "<comment>"
ntags.append(tag)
elif(tag == 'h1> to <h6'):
arr = ["h1","h2","h3","h4","h5","h6"]
ntags.extend(arr)
else:
ntags.append(tag)
CATES[cate] = ntags
fs.rjson("category.json",CATES)
return(CATES)
def csv2jsd(src_fn,colname0,colname1,**kwargs):
from_file = efun.dflt_kwargs('from_file',True)
fmt_key = efun.dflt_kwargs('fmt_key',fmt_mime_key)
dtb = csv2dtb(src_fn,from_file)
l = elel.mapv(dtb,lambda ele:{js_key_encd(fmt_key(ele[colname0])):ele[colname1]})
d = dldl.dlist2dict(l)
return(d)
def append_rows(dtb,*rowargs):
'''
>>> parr(dtb)
{'three': 'aa', 'x': 'xx1', 'y': 'yy1'}
{'three': 'bb', 'x': 'xx2', 'y': 'yy2'}
{'three': 'cc', 'x': 'xx3', 'y': 'yy3'}
{'three': 'dd', 'x': 'xx4', 'y': 'yy4'}
{'three': 'ee', 'x': 'xx5', 'y': 'yy5'}
{'three': 'ff', 'x': 'xx6', 'y': 'yy6'}
{'three': 'gg', 'x': 'xx7', 'y': 'yy7'}
>>>
>>> parr(append_rows(dtb,[1,2,3],[11,22,33]))
{'three': 'aa', 'x': 'xx1', 'y': 'yy1'}
{'three': 'bb', 'x': 'xx2', 'y': 'yy2'}
{'three': 'cc', 'x': 'xx3', 'y': 'yy3'}
{'three': 'dd', 'x': 'xx4', 'y': 'yy4'}
{'three': 'ee', 'x': 'xx5', 'y': 'yy5'}
{'three': 'ff', 'x': 'xx6', 'y': 'yy6'}
{'three': 'gg', 'x': 'xx7', 'y': 'yy7'}
{'three': 1, 'x': 2, 'y': 3}
{'three': 11, 'x': 22, 'y': 33}
>>>
'''
cnl = get_cnl(dtb)
rows = elel.mapv(rowargs,rowarg2row,[cnl])
dtb.extend(rows)
return(dtb)
def get_dirs(cfgdict):
rslt = d2h(cfgdict)
prdict = rslt['prdict']
dirs = list(prdict['h:o'].values())
dirs.remove([])
dirs = elel.mapv(dirs, fs.pl2path)
return (dirs)
def get_children(plnd):
'''
这一步会填充ele.pbreadth,因为get_children之后,父节点就脱离了,完全依赖pbreadth
这一步会填充ele.ftag,因为当前层的key(dict) seq(list,tuple) dummy_seq(set)会在这一层决定
这一步会填充ele.sibseq, 在兄弟中是第几个
这一步会填充ele.depth, 在兄弟中是第几个
这一步会填充ele.fpl, 在兄弟中是第几个
这一步会填充ele['type'] 这个spec info
'''
fpl = plnd.ele.fpl #current fpl will be used as children pfpl
jobj = plnd.jobj #current jobj
if (isinstance(jobj, dict)):
ftagl, _ = eded.d2kvlist(jobj) #get keys-list (ftagl)
elif (isinstance(jobj, list) or isinstance(jobj, tuple)
or isinstance(jobj, set)):
ftagl = elel.init_range(0, len(jobj), 1)
else:
ftagl = [] #others all leaf-plnds
#####
pfpl = fpl
chfpls = elel.mapv(ftagl, plfunc.ppl2pl,
[pfpl]) #get children-full-pathlist
#######
pjobj = jobj
pele = plnd.ele
children = elel.mapiv(
chfpls, init_plnd, [pele, pjobj]
) #get all-children,init_plnd-will-fill-pbreadth=ftag=sibseq,fill-parent-ele-children
return (children)
def sdfspls2wfspls(sdfspls,**kwargs):
groups = sdfspls2groups(sdfspls,**kwargs)
vname = eftl.dflt_kwargs("vname","fpl",**kwargs)
plmat = emem.mapv(groups,map_func=lambda ele:ele[vname])
plmat = ltlt.to_list(plmat)
wfsel = m2wfsel(plmat)
wfspls = elel.mapv(wfsel,lambda ele:ele['fpl'])
return(wfspls)
def get_cvl(dtb,colname):
'''
>>> get_cvl(dtb,'one')
[3, 8, 13, 18, 23]
>>>
'''
return(elel.mapv(dtb,lambda row:row[colname]))
def get_global_events():
res = req.get(URL)
html_txt = res.text
root = LXHTML(html_txt)
ele = engine.xpath(root, "//div[@id='intro']")[0]
sibs = engine.following_sibs(ele)[:-2]
global_events = elel.mapv(sibs, engine.xpath, ["table"])
for i in range(len(global_events)):
tb = global_events[i][0]
tds = engine.xpath(tb, "tr/td")
ns = elel.select_interval(tds, 3)
descs = elel.select_interval(tds[2:], 3)
ns = elel.mapv(ns, lambda ele: txt.iter_text(ele).strip(" "))
descs = elel.mapv(descs, lambda ele: txt.iter_text(ele).strip(" "))
GLOBAL_EVENTS[CATEGORY_EN[i]] = eded.kvlist2d(ns, descs)
fs.wjson("global_events.json", GLOBAL_EVENTS)
return (GLOBAL_EVENTS)
def fapl2fpl(fapl):
'''
>>> plfuncs.fapl2fpl(['body', 'l0_', 'type'])
['body', 0, 'type']
>>>
'''
fpl = elel.mapv(fapl,kastr.fatag2ftag)
return(fpl)
def nds2rsh(nds):
'''
rsh = nds2rsh(nds)
'''
sdfsnds = nds2sdfsnds(nds)
depths = elel.mapv(sdfsnds,lambda nd:ndgetdepth(nd,nds))
lns = elel.mapiv(depths,lambda i,depth:" "*depth+"v"+str(sdfsnds[i].val))
rsh = elel.join(lns,"\n")
return(rsh)
def binlist2num(binlist, **kwargs):
bigend = eftl.dflt_kwargs('bigend', True, **kwargs)
if (bigend):
pass
else:
binlist = elel.fcp(binlist)
binlist.reverse()
arr = elel.mapv(binlist, str)
s = elel.join(arr)
return (int(s, 2))
def creat_code_blk(cmds_arr):
s = arr2str(cmds_arr)
arr = s.split("\n")
head1 = " ::"
head2 = " "
arr = elel.mapv(arr, lambda s: (" " + s))
arr = elel.prepend(arr, head2)
arr = elel.prepend(arr, head1)
s = elel.join(arr, "\n") + "\n\n"
return (s)
def _get_combination_num(combi, arr):
'''
>>> _get_combination_num(["c","e"],["a","b","c","d","e"])
20 1 0 1 0 0
e d c b a
>>>
'''
mp = _get_combination_map(arr)
combi = elel.mapv(combi, lambda ele: arr.index(ele))
num = elel.reduce_left(combi, lambda acc, ele: acc + 2**ele, 0)
return (num)
def mat2dtb(m,cnl):
'''
>>> parr(mat2dtb(m,cnl))
{'one': 3, 'two': 1, 'three': 2, 'four': 4}
{'one': 8, 'two': 6, 'three': 7, 'four': 9}
{'one': 13, 'two': 11, 'three': 12, 'four': 14}
{'one': 18, 'two': 16, 'three': 17, 'four': 19}
{'one': 23, 'two': 21, 'three': 22, 'four': 24}
>>>
'''
return(elel.mapv(m,rvl2row,[cnl]))
def s2d(s, sp="@"):
s = s.strip("\n")
lines = s.split("\n")
tl = elel.mapv(lines, lambda line: tuple(line.split(sp)))
d = eded.tlist2dict(tl)
for k in d:
v = d[k]
d[k] = {}
d[k]['cn_desc'] = v
d[k]['return'] = {"cn_desc": "", "values": []}
return (d)
def creat_projhd(projname, desc):
l0 = ".. contents:: Table of Contents\n"
l1 = " :depth: 5\n\n\n"
l2 = "*" + projname + "*\n"
l3 = "=" * (len(l2) - 1) + "\n"
descs = desc.split("\n")
descs = elel.mapv(descs, lambda ele: "- " + ele)
l4 = elel.join(descs, "\n")
l5 = "\n\n\n"
s = l0 + l1 + l2 + l3 + l4 + l5
print(s)
return (s)
def _infos2group(infos):
def map_func(ele):
ele.pop(0)
return (ele)
indexes = elel.cond_select_indexes_all(infos,
cond_func=lambda info:
(info.type == NEWLINE))
groups = elel.broken_seqs(infos, indexes)
groups = elel.remove_all(groups, [])
groups = elel.mapv(groups, map_func)
groups = elel.remove_all(groups, [])
groups = elel.mapv(groups, _group2str)
try:
groups = elel.remove_last(groups, "\n")
groups = elel.remove_first(groups, "\n")
except:
pass
else:
pass
return (groups)
