def get_cell_info(cell, pos=np.array([0., 0.]), mirror_x=False, rot180=False):
global gid
gid += 1
if not cell.name in cell_to_data:
res = []
for e in cell.elements:
if isinstance(e, gdspy.CellReference):
rd = get_cell_info(
e.ref_cell,
e.origin,
mirror_x=e.x_reflection,
rot180=e.rotation is not None,
)
res.extend(rd)
elif isinstance(e, gdspy.Polygon):
assert len(e.points) == 4
res.append(cmisc.Attributize(pos=e.points, layer=e.layer, type='poly', cell_name=cell.name))
for label in cell.labels:
res.append(
cmisc.Attributize(
pos=label.position,
layer=label.layer,
text=label.text,
type='label',
cell_name=cell.name
)
)
cell_to_data[cell.name] = res
seen_gid = {}
seen_gid[None] = gid
gid += 1
nres = []
finalid = 0
for e in cell_to_data[cell.name]:
ne = e._do_clone()
ne.pos = np.array(e.pos)
if rot180: ne.pos = -ne.pos
if mirror_x:
ne.pos = ne.pos * np.array([1, -1])
ne.pos += pos
ne.idx = finalid
finalid+=1
cid = ne.get('cellid', None)
if cid not in seen_gid:
seen_gid[cid] = gid
gid += 1
ne.cellid = seen_gid[cid]
ne.cell_name = ne.cell_name
nres.append(ne)
return nres
def r2_extract_all(filename, offset=0):
import r2pipe
p = r2pipe.open(filename)
p.cmd('aac')
p.cmd('aa')
def do_cmd(x):
return cmisc.Attributize.RecursiveImport(p.cmdj(x))
res = cmisc.Attributize()
funcs = cmisc.Attributize({d['name']:d for d in do_cmd('aflj')})
strs= do_cmd('izj')
xrefs = do_cmd('axj')
for x in strs:
x.value = base64.b64decode(x.string)
x.xrefs = defaultdict(list)
for f in funcs.values():
f.outdeg = defaultdict(lambda: 0)
f.coderefs_funcs = defaultdict(list)
f.codexrefs_funcs = defaultdict(list)
f.coderefs_funcs_list = []
f.codexrefs_funcs_list = []
f.refs_str = []
funcs_inter = Intervals([(cbase.Range1D(offset +x.offset, n=x.size-1), x) for x in funcs.values()])
strs_inter = Intervals([(cbase.Range1D(offset +x.vaddr, n=x.size-1), x) for x in strs])
for xref in xrefs:
xref['addr'] += offset
xref['from'] += offset
a = strs_inter.find(xref['addr'])
b = funcs_inter.find(xref['from'])
if not a or not b: continue
#print(a.value, b.name, hex(v), hex(k))
ref_obj = cmisc.Attributize(src=b, sink=a, addr=xref.addr, raw=xref)
a.xrefs[b.name].append(ref_obj)
b.refs_str.append(ref_obj)
for f in funcs.values():
for xref in f.get('codexrefs', []):
xref.addr += offset
u = funcs_inter.find(xref.addr)
if u is None: continue
ref_obj = cmisc.Attributize(src=u, sink=f, addr=xref.addr, raw=xref)
f.codexrefs_funcs[u.name].append(ref_obj)
u.coderefs_funcs[f.name].append(ref_obj)
f.codexrefs_funcs_list.append(ref_obj)
u.coderefs_funcs_list.append(ref_obj)
u.outdeg[f.name] += 1
return cmisc.Attributize(funcs_inter=funcs_inter, strs_inter=strs_inter, f=funcs, s=strs)
def r2_extract_all(filename):
import r2pipe
p = r2pipe.open(filename)
p.cmd('aac')
def do_cmd(x):
return cmisc.Attributize.RecursiveImport(p.cmdj(x))
res = cmisc.Attributize()
funcs = cmisc.Attributize({d['name']: d for d in do_cmd('aflj')})
strs = do_cmd('izj')
xrefs = do_cmd('axj')
xrefs = {v['addr']: v for v in xrefs}
for x in strs:
x.value = base64.b64decode(x.string)
x.xrefs = []
for f in funcs.values():
f.outdeg = defaultdict(lambda: 0)
funcs_inter = Intervals([(cbase.Range1D(x.offset, n=x.size - 1), x)
for x in funcs.values()])
strs_inter = Intervals([(cbase.Range1D(x.vaddr, n=x.size - 1), x)
for x in strs])
for k, v in xrefs.items():
a = strs_inter.find(v)
b = funcs_inter.find(k)
if not a or not b: continue
#print(a.value, b.name, hex(v), hex(k))
a.xrefs.append(b)
for f in funcs.values():
f.codexrefs_funcs = []
for xref in f.codexrefs:
u = funcs_inter.find(xref.addr)
if u is None: continue
f.codexrefs_funcs.append(
cmisc.Attributize(func=u.name, addr=xref.addr, obj=u))
u.outdeg[f.name] += 1
return cmisc.Attributize(funcs_inter=funcs_inter,
strs_inter=strs_inter,
f=funcs,
s=strs)
def __init__(self, start_off=0, ptr_size=8, **kw):
avail_fmt = {4: 'I', 8: 'Q'}
assert ptr_size in avail_fmt
self.default_fmt = avail_fmt[ptr_size]
self.kw = cmisc.Attributize(elem=kw.copy())
self.tb = []
self.start_off = start_off
def real_decode(ctx):
d = Z.pickle.load(open(ctx.infile, 'rb'))
samples_per_prn = d.samples_per_chip * d.chips_per_prn
pl = []
conf = cmisc.Attributize(
sample_rate=d.sample_rate,
sps=d.samples_per_chip * d.chips_per_prn,
symbol_rate=d.prn_freq,
n_acq_symbol=20,
max_doppler_shift=0,
doppler_space_size=1,
SNR_THRESH=10,
jitter=0,
)
start_pos = samples_per_prn
cx = d.signal
cur_ctx = cmisc.Attr(orig_sig=cx, cleaned_sig=cx[start_pos:])
prevs = []
for i in range(len(d.orig_data)):
if i == -1:
print('goot')
g = K.GraphHelper(run_in_jupyter=0)
x = g.create_plot(plots=[
np.abs(cx),
np.abs(d.signal[start_pos:start_pos + len(cx)])
])
g.run()
return
conf.pulse_shape = get_l1ca_pulse(d.orig_data[i].sat,
d.samples_per_chip)
p = OpaXpsk(conf)
cur_ctx.i = i
dd = process_bits_xpsk(p, cur_ctx, 20 - 2 * i, d.orig_data[i].doppler,
prevs, start_pos, d.orig_data[i])
cur_ctx.cleaned_sig = dd.nsig
prevs.append(dd)
start_pos = dd.nstart_pos
bits = dd.bits >= 0.5
print(dd.bits, len(bits))
print(Z.min_substr_diff(d.orig_data[i].bin_data, bits))
print(Z.min_substr_diff(d.orig_data[i].bin_data, 1 ^ bits))
print(d.orig_data[i].bin_data)
print()
#d2 = process_bits_xpsk(p, d1.nsig[samples_per_prn:], 5)
print(Z.DataOp.Power_Db(cx))
return
for i in range(1, 6):
conf.pulse_shape = get_l1ca_pulse(i, d.samples_per_chip)
p = OpaXpsk(conf)
r = p.analyse_chip(d.orig_data[i].doppler, cx)
print(r)
break
def compute_nxt_mp_stats(self, mp, rmp, target_str, have_str):
res = cmisc.Attributize(conflict=0, new=0)
nmp = dict(mp)
nrmp = dict(rmp)
for target_c, have_c in zip(target_str, have_str):
if have_c in nmp and nmp[have_c] != target_c: res.conflict = 1
if target_c in nrmp and nrmp[target_c] != have_c: res.conflict = 1
if res.conflict: break
if have_c not in nmp:
nmp[have_c] = target_c
nrmp[target_c] = have_c
res.new = 1
return res, nmp, nrmp
def xxd(self, addr, sz, word_size=None, endian='little', num_cols=4):
if word_size is None:
word_size = self.arch.reg_size
return xxd.FromBuf(
self.read(addr, sz),
cmisc.Attributize(
reverse=0,
num_cols=num_cols,
head=-1,
skip_head=0,
word_size=word_size,
endian=endian,
offset=addr,
))
def parse_netlist(s, layer1, layer2):
lines = s.splitlines()[1:]
tmp = (layer1, layer2)
merges = []
for line in lines:
content = line.strip().split(' ')
na = int(content[0])
pos = 1
group = []
for i in range(na):
idx = int(content[pos])
group.append(idx)
pos += 1
merges.append(cmisc.Attributize(group=group))
return merges
def get_next_cnds(self, mp, get_all=0):
rmp = {v: k for k, v in mp.items()}
space = self.space
lst = []
for n in self.ng_data.keys():
if n == 1: continue
for col in self.cols:
target_str_list = self.ng_baseline[n]['ngram_' +
col['name']].values[:7]
target_prob_list = self.ng_baseline[n][col['name']].values[:7]
for (target_str, target_prob) in zip(target_str_list,
target_prob_list):
cur_coldata = self.ng_with_space[n][col['name']]
for cx in cur_coldata:
stats, _, _ = self.compute_nxt_mp_stats(
mp, rmp, target_str, cx.s)
if stats.conflict or not stats.new: continue
lst.append(
cmisc.Attributize(
score=self.compute_score1(
target_prob,
cx.p_norm,
cx.p_raw,
target_prob_list[0],
cur_coldata[0].p_norm,
n,
),
target_str=target_str,
have_str=cx.s,
target_prob=target_prob,
have_prob=cx.p_raw,
have_norm_prob=cx.p_norm,
col_name=col['name'],
))
lst.sort(key=lambda x: x.score)
if get_all: return lst
if not lst: return None
lbd = lst[0].score * 2
probs = [math.exp(x.score / lbd) for x in lst]
return self.compute_next_mp(mp, random.choices(lst, weights=probs))
def test(ctx):
if 0:
x = permv(1)
v0=nf ** (nr)
vbase = -keystream.offset % nf
v = vbase + v0 * x
#print(keystream.rasta_standard(keystream.key, keystream.rounds, keystream.n, v0, M))
print(keystream.rasta_standard(keystream.key, keystream.rounds, keystream.n, v, M))
return
with Connection('arcade.fluxfingers.net', 1820) as conn:
s = Solver(conn)
reslist =[s.query_last(i) for i in range(keystream.n)]
data = cmisc.Attributize()
data.reslist = reslist
data.chall = s.chall
pickle.dump(data, open(flags.data_file, 'wb'))
def compute_ng_with_space(self):
space = self.space
res = cmisc.defaultdict(lambda: cmisc.defaultdict(list))
for n in range(1, 6):
tmp = cmisc.defaultdict(list)
res[n] = tmp
for col in self.cols:
if col['start'] and col['end']:
if n + 2 not in self.ng_data: continue
have = cmisc.asq_query(self.ng_data[n + 2]).where(
lambda x: (space not in x[0][1:-1] and x[0][0] == space
and x[0][-1] == space))
elif col['start']:
if n + 1 not in self.ng_data: continue
have = cmisc.asq_query(self.ng_data[n + 1]).where(
lambda x: (space not in x[0][1:] and x[0][0] == space))
elif col['end']:
if n + 1 not in self.ng_data: continue
have = cmisc.asq_query(
self.ng_data[n + 1]).where(lambda x: (space not in x[
0][:-1] and x[0][-1] == space))
else:
have = cmisc.asq_query(
self.ng_data[n]).where(lambda x: space not in x[0])
if col['start']: have = have.select(lambda x: (x[0][1:], x[1]))
if col['end']: have = have.select(lambda x: (x[0][:-1], x[1]))
have = have.to_list()
probs = [x[1] for x in have]
probs = normalize_probs(probs)
have = [
cmisc.Attributize(s=x[0], p_norm=p, p_raw=x[1])
for x, p in zip(have, probs)
]
tmp[col['name']] = have
cmisc.ppx.pprint(res[n])
return res
def make_dep(**kw): return cmisc.Attributize(default=False, **kw)
def test_run_notebook(ctx):
a = 123
u = cmisc.Attributize()
run_notebook()
def test_try_kernel(ctx):
a = 123
u = cmisc.Attributize()
create_kernel(runid=ctx.runid)
def to_attr(self):
self.v = cmisc.Attributize(self.v)
return self
