def main():
global lines
dlines = lines[start:end]
s = elel.join(dlines, line_sp)
fs.wfile(dst, s)
arr0 = lines[0:start]
arr1 = lines[end:lngth]
slines = arr0 + arr1
s = elel.join(slines, line_sp)
fs.wfile(src, s)
def eliminate_ilr(arr_alpha,arr_beta,non_term="A"):
arr_alpha_tmp = elel.mapiv(arr_alpha,lambda i,v:non_term+v)
arr = arr_alpha_tmp + arr_beta
s = elel.join(arr,"|")
s = non_term + " -> " + s
print(s)
arr_beta = elel.mapiv(arr_beta,lambda i,v:v+non_term+"'")
s = elel.join(arr_beta,"|")
s = non_term + " -> " + s
print(s)
arr_alpha = elel.mapiv(arr_alpha,lambda i,v:v+non_term+"'" )
s = elel.join(arr_alpha,"|")
s = non_term + "'" + " -> " + s +"|" + "epsilon"
print(s)
def __init__(self, one, **kwargs):
if (isinstance(one, list)):
self.sarr = one
self.str = elel.join(self.sarr, ",\x20")
else:
self.str = comma_fmt(one)
self.sarr = comma_s2sarr(self.str)
def __init__(self, one, **kwargs):
if (isinstance(one, list)):
self.sarr = one
self.str = elel.join(self.sarr, ";\x20")
else:
self.str = semicolon_fmt(one)
self.sarr = semicolon_s2sarr(self.str)
def encd_arguments(args):
'''
args = [
{
'content': None,
'name': None,
'value': -50.0,
'arguments': None,
'unit': None,
'type': 'percentage'
},
{
'content': None,
'name': None,
'value': ',',
'arguments': None,
'unit': None,
'type': 'literal'
},
{
'content': None,
'name': None,
'value': -50.0,
'arguments': None,
'unit': None,
'type': 'percentage'
},
],
encd_arguments(args)
'''
args = elel.filter(args, lambda ele: (ele['type'] != 'whitespace'))
args = elel.array_map(args, encd_one)
s = '(' + elel.join(args, '') + ')'
return (s)
def main():
global lines
arr0 = lines[0:start]
arr1 = lines[end:lngth]
lines = arr0 + arr1
s = elel.join(lines, line_sp)
fs.wfile(src, s)
def img2txt(img_file, c):
img, d = pixelarr(img_file)
cw = d["cw"]
top = d["top"]
left = d["left"]
lines = img2ansi256indexes(img, c)
lines = centerlize(lines, cw, top, left)
return (elel.join(lines, "\n"))
def img2ansi256indexes(img, c):
lines = elel.init(img.__len__(), [])
for i in range(lines.__len__()):
line = img[i]
line = list(map(find_index, line))
line = elel.join(linefill(line, c), "")
lines[i] = line
return (lines)
def serialize_array(arr):
arr = elel.array_map(arr, lambda ele: ele.serialize())
s = elel.join(arr, "")
s = s.replace('\t', "")
s = s.replace('\r', "")
s = s.replace('\n', "")
s = s.strip('\x20')
s = eses.replace(s, re.compile("[\x20]+"), "\x20")
return (s)
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 gen_guid():
rand = str(uuid.uuid4()).split('-')
uni = str(uuid.uuid1()).split('-')
arr = [rand, uni]
guid = []
for i in range(len(rand)):
index = random.randint(0, 1)
guid.append(arr[index][i])
return (elel.join(guid, '-'))
def eliminate_ilr_s0(m,n):
arr_non_term = elel.init_range(1,m+1,1)
arr_non_term = elel.mapiv(arr_non_term,lambda i,v:"Aa"+str(i))
arr_term = elel.init_range(1,n+1,1)
arr_term = elel.mapiv(arr_term,lambda i,v:"B"+str(i))
arr = arr_non_term + arr_term
s = elel.join(arr,"|")
s = "A -> " + s
return(s)
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_rand_name(**kwargs):
dflt_init_chars = "_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
dflt_other_chars = "_0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
lngth = eftl.dflt_kwargs("len", 4, **kwargs)
init_chs = eftl.dflt_kwargs("init", dflt_init_chars, **kwargs)
other_chs = eftl.dflt_kwargs("other", dflt_other_chars, **kwargs)
init_ch = random.choice(init_chs)
others = random.choices(other_chs, k=lngth - 1)
other = elel.join(others, "")
return (init_ch + other)
def cmds_arr2str(arr, **kwargs):
'''
'''
if ('still_frames' in kwargs):
still_frames = kwargs['still_frames']
else:
still_frames = True
s = elel.join(arr, "\r")
s = "\r" + s + "\r" + "exit()" + "\r"
return (s)
def main():
j = load(sys.argv[1])
pl = sys.argv[2:]
cmdk = elel.join(pl,' ')
cmdt = cmdline.cmdict(dict=j,debug=0)
r = cmdt[cmdk]
if(r):
pobj(r)
else:
pass
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 get_dir_list(ele):
pl = []
parent = ele.getparent()
while (parent != None):
if (parent.tag == 'list_item'):
child = parent.getchildren()[0]
pl = elel.unshift(pl, child.text)
else:
pass
parent = parent.getparent()
return (elel.join(pl, "/"))
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 get_all_valid_attr_noninit_char(s):
chs = elel.cond_select_values_all(s, cond_func=is_valid_attr_noninit_char)
try:
chs.remove("\t")
chs.remove(" ")
chs.remove("\x0c")
except:
pass
else:
pass
rslt = elel.join(chs, '')
return (rslt)
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 encd_square_blk(d, for_display=False):
'''
#for beautifier
#[ \x01
#] \x02
d = {
'content':
[
{
'content': None,
'name': None,
'type': 'ident',
'arguments': None,
'unit': None,
'value': 'title'
},
{
'content': None,
'name': None,
'type': 'literal',
'arguments': None,
'unit': None,
'value': '~='
},
{
'content': None,
'name': None,
'type': 'ident',
'arguments': None,
'unit': None,
'value': 'hello'
}
],
'name': None,
'type': '[] block',
'arguments': None,
'unit': None,
'value': None
}
encd_square_blk(d)
'''
c = cntnt_fmt_norecur(d['content'])
arr = elel.array_map(c, encd_one)
s = elel.join(arr, "")
if (for_display):
s = '\x01' + s + '\x02'
else:
s = '[' + s + ']'
return (s)
def decodeURI(es):
arr = URIstr2arr(es)
lngth = arr.__len__()
for i in range(0, lngth):
e = arr[i]
if ('%' == e[0]):
cond = is_type52(e)
if (cond):
arr[i] = unquote_ch(e)
else:
pass
else:
pass
s = elel.join(arr, '')
return (s)
def repl_cols(dtb,*args):
'''
>>> parr(dtb)
{1000: '3', 2000: '4', 'three': 'aa'}
{1000: '8', 2000: '9', 'three': 'bb'}
{1000: '13', 2000: '14', 'three': 'cc'}
{1000: '18', 2000: '19', 'three': 'dd'}
{1000: '23', 2000: '24', 'three': 'ee'}
>>>
cns = [1000, 2000]
cols = [['x1','x2','x3','x4','x5'],['y1','y2','y3','y4','y5']]
parr(repl_cols(dtb,cns,cols))
>>> parr(repl_cols(dtb,cns,cols))
{'three': 'aa', 1000: 'x1', 2000: 'y1'}
{'three': 'bb', 1000: 'x2', 2000: 'y2'}
{'three': 'cc', 1000: 'x3', 2000: 'y3'}
{'three': 'dd', 1000: 'x4', 2000: 'y4'}
{'three': 'ee', 1000: 'x5', 2000: 'y5'}
>>>
cns = [1000, 2000]
cols = [['xx1','xx2','xx3','xx4','xx5'],['yy1','yy2','yy3','yy4','yy5']]
ncns = ['x','y']
>>> parr(repl_cols(dtb,cns,cols,ncns))
{'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'}
>>>
'''
cnl = get_cnl(dtb)
prefix = elel.join(cnl,"@")
cns = args[0]
cols = args[1]
ncns = (args[2] if(len(args)>2) else cns)
tmpcns = elel.mapv(cns,lambda cn:prefix+'@'+str(cn))
dummy = rename_cols(dtb,cns,tmpcns)
qtbl = dtb2qtbl(dtb)
qtbargs = elel.interleave(ncns,cols)
qtbl = qtbl.repl_cols(tmpcns,*qtbargs)
ndtb = qtbl2dtb(qtbl)
###this is a trick , to keep inplace
dtb.clear()
dtb.extend(ndtb)
###
return(ndtb)
def get_css_rule_str(d):
lines = print_j_str(d.__str__(), with_color=False, fixed_indent=True)
s = elel.join(lines, '\n')
s = s.replace('[\n', '{\n')
s = s.replace(']\n', '}\n')
s = s.replace(':\x20\n', '\n')
s = s.replace(',\x20\n', '\n')
s = convert_token_in_quote(s)
s = s.replace("'", "")
s = html.unescape(s)
s = s.strip('\x20').strip('\n').strip('\x20')
if (s[-1] == "]"):
s = s[:-1] + '}'
else:
pass
regex = re.compile("\n[ ]+\{\n[ ]+;\n[ ]+\}")
s = eses.replace(s, regex, ";")
return (s)
def encd_paren_blk(d):
'''
d = {
'content':
[
{
'content': None,
'name': None,
'value': 'min-width',
'arguments': None,
'unit': None,
'type': 'ident'
},
{
'content': None,
'name': None,
'value': ':',
'arguments': None,
'unit': None,
'type': 'literal'
},
{
'content': None,
'name': None,
'value': 900.0,
'arguments': None,
'unit': 'px',
'type': 'dimension'
}
],
'name': None,
'value': None,
'arguments': None,
'unit': None,
'type': '() block'
}
'''
c = cntnt_fmt_norecur(d['content'])
paren = elel.array_map(c, encd_one)
s = elel.join(paren, "")
s = '(' + s + ')'
#d = scil2dict(paren)
#t = (d,)
return (s)
def repl_col(dtb,cn,col,ncn=None):
'''
>>> parr(dtb)
{400: 1, 1000: 3, 2000: 4}
{400: 6, 1000: 8, 2000: 9}
{400: 11, 1000: 13, 2000: 14}
{400: 16, 1000: 18, 2000: 19}
{400: 21, 1000: 23, 2000: 24}
>>>
>>> parr(repl_col(dtb,400,['a','b','c','d','e']))
{1000: 3, 2000: 4, 400: 'a'}
{1000: 8, 2000: 9, 400: 'b'}
{1000: 13, 2000: 14, 400: 'c'}
{1000: 18, 2000: 19, 400: 'd'}
{1000: 23, 2000: 24, 400: 'e'}
>>>
>>> parr(repl_col(dtb, 400,['aa','bb','cc','dd','ee'],"three"))
{1000: 3, 2000: 4, 'three': 'aa'}
{1000: 8, 2000: 9, 'three': 'bb'}
{1000: 13, 2000: 14, 'three': 'cc'}
{1000: 18, 2000: 19, 'three': 'dd'}
{1000: 23, 2000: 24, 'three': 'ee'}
>>>
'''
if(ncn == None):
ncn = cn
else:
pass
cnl = get_cnl(dtb)
#pandas not support non-string colname,need a trick
tmpcn = elel.join(cnl,"@")
#dont use new dtb, keep inplace
dummy = rename_col(dtb,cn,tmpcn)
#################################
qtbl = dtb2qtbl(dtb)
qtbl = qtbl.repl_col(tmpcn,ncn,col)
ndtb = qtbl2dtb(qtbl)
###this is a trick , to keep inplace
dtb.clear()
dtb.extend(ndtb)
###
return(ndtb)
def creat_rst(kl, vl, **kwargs):
if ("title" in kwargs):
title = kwargs['title']
else:
title = "Usage"
if ("title_bot" in kwargs):
title_bot = kwargs['title_bot']
else:
title_bot = "="
if ("entry_bot" in kwargs):
entry_bot = kwargs['entry_bot']
else:
entry_bot = "-"
title = creat_title(title=title, bot=title_bot)
sarr = []
for i in range(kl.__len__()):
k = kl[i]
v = vl[i]
s = creat_one_rst(k, v, i=i, bot=entry_bot)
sarr.append(s)
s = title + elel.join(sarr, "")
return (s)
def get_path_init(path):
pl = path2pl(path)
return (elel.join(pl[:-1], os.path.sep))
def get_path_tail(path):
pl = path2pl(path)
return (elel.join(pl[1:], os.path.sep))
