def import_footprint(self, name): s = None for f in self.files: s = sexpdata.load(open(f, 'r')) if _convert_sexp_symbol_to_string(s[1]) == name: break if s is None: raise Exception("Footprint %s not found" % (name)) return self._import_footprint(s)
def load_execution_time(execution_stats_file): with open(execution_stats_file) as f: execution_stats_sexp = sexpdata.load(f) m = inlining_tree.sexp_to_map(execution_stats_sexp) execution_time = inlining_tree.geometric_mean([ inlining_tree.parse_time(inlining_tree.unpack_atom(x)) for x in m["raw_execution_time"] ]) return execution_time
def main (argv=sys.argv): with open (argv[1]) as f: tree = sexpdata.load (f) pads = get_pth_pads (tree) vias = get_vias (tree) annulus_test (tree, pads, vias) stacked_via_test (tree, pads, vias)
def main(): rotations = load_rotations() if len(sys.argv) <2: print("Please supply filename on command line") raise Exception("No filename") filename = sys.argv[1] with open(filename) as f: doc = sexpdata.load(f) file_dir = os.path.dirname(filename) if len(file_dir) > 0: os.chdir(os.path.dirname(filename)) handle_doc(doc, rotations)
def detect(fn): if os.path.isdir(fn) and '.pretty' in fn: return "3" try: l = sexpdata.load(open(fn, 'r')) if (l[0] == S('module')): return "3" return None except IOError: # allow new .kicad_mod files! if '.kicad_mod' in fn: return "3" return None except: return None
def list_names(self): l = [] for f in self.files: s = sexpdata.load(open(f, 'r')) name = _convert_sexp_symbol_to_string(s[1]) fp = self._import_footprint(s) desc = None for x in fp: if x['type'] == 'meta': if 'desc' in x: desc = x['desc'] break l.append((name, desc)) return l
def parse_solution(src: IO[str]) -> Dict[Definition, int]: condition = src.readline().strip() if condition != 'sat': raise ValueError("Not satisfiable") model = sexpdata.load(src) model = strip_symbols(model) if model[0] != 'model': raise ValueError("Top-level element is not a model") definitions: Dict[str, int] = {} for definition in model[1:]: if definition[0] != 'define-fun': continue name = definition[1] value = definition[4] definitions[name] = value values: Dict[Definition, int] = { Definition.from_name(x): y for x, y in definitions.items() } return values
def parse_kicad_sym(path): result = {} with io.open(path, 'r', encoding='utf-8') as dcm: top = sexpdata.load(dcm) assert (top[0] == Symbol('kicad_symbol_lib')) for symbol in [s for s in top[1:] if s[0] == Symbol('symbol')]: comp = None datasheet = '' description = '' for prop in [p for p in symbol[1:] if p[0] == Symbol('property')]: if prop[1] == "Value": comp = prop[2] elif prop[1] == "Datasheet": datasheet = prop[2] elif prop[1] == "ki_description": description = prop[2] if comp is not None: result[comp] = (description, '' if datasheet == '' else f'[Datasheet]({datasheet})') return result
def main(): model = sys.argv[1] version = sys.argv[2] version = version.lower() all_data = [] for exp in py_common.INITIAL_EXPERIMENTS: fname = "./report_plots/reward_assignment/data/%s/%s/feature_reward_pair_%s.sexp" % ( model, exp, version.lower()) print "Loading data from", fname with open(fname, "r") as f: all_data.extend(parse(sexpdata.load(f), exp_name=exp)) if not os.path.exists("report_plots/machine_learning/%s/%s" % (model, version)): os.makedirs("report_plots/machine_learning/%s/%s" % (model, version)) with open( "report_plots/machine_learning/%s/%s/data.pickle" % (model, version), "wb") as f: pickle.dump(all_data, f)
# Extract the bookmark data from the DJVU document retval = 0 retval = retval | os.system( "djvused %s -u -e 'print-outline' > %s/bmarks.out" % (args.src, workpath)) print("Bookmarks extracted.") # Check for zero-length outline if os.stat("%s/bmarks.out" % workpath).st_size > 0: # Extract the metadata from the PDF document retval = retval | os.system( "pdftk %s dump_data_utf8 > %s/pdfmetadata.out" % (args.dest, workpath)) print("Original PDF metadata extracted.") # Parse the sexpr pdfbmarks = walk_bmarks(sexpdata.load(open(workpath + '/bmarks.out')), 0) # Integrate the parsed bookmarks into the PDF metadata p = re.compile('NumberOfPages: [0-9]+') metadata = open("%s/pdfmetadata.out" % workpath, 'r').read() for m in p.finditer(metadata): loc = int(m.end()) newoutput = metadata[:loc] + "\n" + pdfbmarks[:-1] + metadata[loc:] # Update the PDF metadata open("%s/pdfmetadata.in" % workpath, 'w').write(newoutput) retval = retval | os.system( "pdftk %s update_info_utf8 %s output %s" % (args.dest, workpath + '/pdfmetadata.in', finaldest))
def parse_uniprot_ecs(uniprot_seq_ids_file, raise_on_error=True, logger=logger): """ This function parses a metacyc uniprot-seq-ids.dat file to produce a data frame which includes (ec,uniprot_id) mappings. The uniprot-seq-ids.dat file directly gives the mapping between these in lisp S-exp format. Args: uniprot_seq_ids_file (string): path to the uniprot-seq-ids.dat file Returns: pd.DataFrame with columns: ec, uniprot_id """ data = sexpdata.load(open(uniprot_seq_ids_file)) ec_uniprot_list = [] for entry in data: ec = entry[1] # we sometimes have lists of size 1 of ECs. It is not clear why this # happens, so just parse it out if validation_utils.validate_is_sequence(ec, raise_on_invalid=False): # if the size is not 1, then this is unexpected if len(ec) > 1: msg = ( "Unexpected sequence when parsing S-exp EC from uniprot_" "seqids_file. {}".format(data)) if raise_on_error: raise ValueError(msg) else: logger.warning(msg) ec = ec[0] # the EC is sometimes as "Symbol"; this is okay if isinstance(ec, sexpdata.Symbol): ec = ec.value() for uniprot_id in entry[2:]: # we occasionally parse out lists of size 1 of symbols # it is unclear to me when this happens if validation_utils.validate_is_sequence(uniprot_id, raise_on_invalid=False): # if the size of the list is not 1, then this is unexpected if len(uniprot_id) > 1: msg = ("Unexpected sequence when parsing S-exp uniprot_" "seq_ids_file. {}".format(data)) if raise_on_error: raise ValueError(msg) else: logger.warning(msg) uniprot_id = uniprot_id[0] if isinstance(uniprot_id, sexpdata.Symbol): uniprot_id = uniprot_id.value() ec_uniprot = {"ec": ec, "uniprot_id": uniprot_id} ec_uniprot_list.append(ec_uniprot) ec_uniprot_df = pd.DataFrame(ec_uniprot_list) return ec_uniprot_df
def load_tree_from_rundir(substep_dir, bin_name, preprocessing, output_dir): logging.info("Loading tree from %s" % substep_dir) substep_tmp_dir = os.path.join(substep_dir, "tmp") if not os.path.exists(substep_tmp_dir): os.mkdir(substep_tmp_dir) try: with open(os.devnull, 'w') as FNULL: logging.info("Created tar process for %s" % substep_dir) subprocess.call([ "tar", "xzvf", os.path.join(substep_dir, "artifacts.tar"), "-C", substep_tmp_dir ], stdout=FNULL, stderr=FNULL) data_collector_file = os.path.join( substep_tmp_dir, bin_name + ".0.data_collector.v1.sexp") execution_stats_file = os.path.join(substep_dir, "execution_stats.sexp") if not os.path.exists(data_collector_file): logging.info("Dropping %s due to missing data collector file" % substep_dir) return None if not os.path.exists(execution_stats_file): logging.info("Dropping %s due to missing execution stats" % substep_dir) return None if preprocessing: assert isinstance(preprocessing, tuple) if preprocessing[0] == "path_patching": experiment_subdir = preprocessing[1] cleaner_script = os.path.join( os.path.dirname(os.path.realpath(__file__)), "scripts", "clean-with-path-patching") proc = subprocess.Popen([ cleaner_script, data_collector_file, bin_name, experiment_subdir ]) proc.wait() if proc.returncode != 0: raise RuntimeError( "scripts/clean-with-path-patching failed for arguments %s %s %s" % (data_collector_file, bin_name, experiment_subdir)) else: assert False tree_file = tempfile.NamedTemporaryFile(delete=True) try: proc = subprocess.Popen([ "../_build/default/tools/tree_tools.exe", "v1", "decisions-to-tree", data_collector_file, "-expand", "-output", tree_file.name ]) proc.wait() if proc.returncode != 0: raise RuntimeError( "decisions-to-tree failed for arguments %s -expand" % data_collector_file) tree = build_tree_from_str(tree_file.read()) shutil.copy(data_collector_file, os.path.join(output_dir, "decisions.sexp")) shutil.copy(tree_file.name, os.path.join(output_dir, "expanded-tree.sexp")) finally: tree_file.close() if tree is None: logging.info("Dropping %s because cannot parse sexp correctly" % substep_dir) return None with open(execution_stats_file) as f: execution_stats_sexp = sexpdata.load(f) m = sexp_to_map(execution_stats_sexp) execution_time = geometric_mean( [parse_time(unpack_atom(x)) for x in m["raw_execution_time"]]) shutil.copy(execution_stats_file, os.path.join(output_dir, "execution_stats.sexp")) logging.info("Done with %s" % substep_dir) finally: logging.info("Removed %s" % substep_tmp_dir) if os.path.exists(substep_tmp_dir): shutil.rmtree(substep_tmp_dir) return (tree, execution_time)
def list(self): for f in self.files: l = sexpdata.load(open(f, 'r')) print _convert_sexp_symbol_to_string(l[1])
def replace_lib(tarlib, deslib): rename_ext_lib(tarlib, deslib) change_net_lib(tarlib, deslib) ### Main from here ### # Input file infile = open("in.edif", "r") # Output file outfile = open("out.edif", "w") logfile = open("log.edif", "w") # Read a line from infile data = sexpdata.load(infile) infile.close() # List Data list_ext(0) logfile.write('All EXT Instance:\n') logfile.write(str(extinslist)) logfile.write('\nConverting begin\n') # Replace from map.edif file # map.edif: # <tarlib> <tarinst> <deslib> <desinste>\n # # map.edif exp: # hb180enh_digitalcell_S sizeB OD0003_sch_common sizeB # hb180enh nch5_iso_nbl 1830bd15ba nch_svt_iso_nbl_5p0v
def __init__(self, fileobj): self.sexpr = sexpdata.load(fileobj) self.version = None self.host = None self.host_version = None self.page = None self.general = {} self.setup = {} self.nets = {} self.layers = {} self.pcbplotparams = {} if self.sexpr[0].value() != 'kicad_pcb': raise ValueError("Not a kicad pcb file") def parsedict(dictout, node, subtrees = {}): for g in node[1:]: name = g[0].value() if name in subtrees: parsedict(subtrees[name], g) elif len(g) == 2: dictout[g[0].value()] = g[1] else: dictout[g[0].value()] = g[1:] for e in self.sexpr[1:]: sym = e[0].value() if sym == 'version': self.version = e[1] elif sym == 'host': self.host = e[1].value() self.host_version = e[2] elif sym == 'page': self.page = e[1].value() elif sym == 'general': parsedict(self.general, e) elif sym == 'setup': parsedict(self.setup, e, {'pcbplotparams' : self.pcbplotparams}) elif sym == 'net': self.nets[int(e[1])] = sym2str(e[2]) elif sym == 'module': x, y, angle = None, None, 0 for si in e[2:]: if type(si) is sexpdata.Symbol: continue sym = si[0].value() if sym == 'at': x, y = float(si[1]), float(si[2]) if len(si) > 3: angle = si[3] elif sym == 'pad': pad_type = sym2str(si[2]) pad_shape = sym2str(si[3]) padx, pady = None, None padw, padh = None, None padangle = angle layers = None net = 0 drillx = 0 drilly = 0 for pat in si[4:]: sym = pat[0].value() if sym == 'at': paddx, paddy = rotdeg((float(pat[1]), float(pat[2])), angle) padx, pady = float(x + paddx), float(y + paddy) if len(pat) > 3: padangle = pat[3] elif sym == 'size': padw, padh = float(pat[1]), float(pat[2]) elif sym == 'drill' and len(pat) > 1: if type(pat[1]) in [float, int]: drillx, drilly = float(pat[1]), float(pat[1]) elif sym2str(pat[1]) == 'oval': drillx = float(pat[2]) if len(pat) == 3: drilly = drillx else: drilly = float(pat[3]) elif sym == 'layers': layers = map(sym2str, pat[1:]) elif sym == 'net': net = pat[1] if padangle in [90, 270]: padw, padh = padh, padw drillx, drilly = drilly, drillx self.add_pad(PCBPad(padx, pady, padw, padh, pad_shape, pad_type, layers, net, drillx, drilly)) elif sym == 'zone': net = None layer = None for si in e[1:]: sym = si[0].value() if sym == 'net': net = si[1] elif sym == 'layer': layer = sym2str(si[1]) elif sym == 'filled_polygon': pts = [] for xy in si[1][1:]: if sym2str(xy[0]) != 'xy': raise ValueError, "Invalid item inside filled_polygon" pts.append((float(xy[1]), float(xy[2]))) lp = self.get_layer(layer).polygons if net not in lp: lp[net] = [pts] else: lp[net].append(pts) elif sym == 'segment': start = None end = None width = None net = None for si in e[1:]: sym = si[0].value() if sym == 'start': start = (si[1], si[2]) if sym == 'end': end = (si[1], si[2]) if sym == 'width': width = si[1] if sym == 'layer': layer = sym2str(si[1]) if sym == 'net': net = si[1] self.get_layer(layer).segments.append(Segment(start = start, end = end, width = width, layer = layer, net = net)) elif sym == 'gr_line': start = None end = None width = None for si in e[1:]: sym = si[0].value() if sym == 'start': start = (si[1], si[2]) if sym == 'end': end = (si[1], si[2]) if sym == 'width': width = si[1] if sym == 'layer': layer = sym2str(si[1]) self.get_layer(layer).gr_lines.append(GraphicLine(start = start, end = end, width = width, layer = layer))
def parse(p): try: _, x, y, deg = p return (translate([x, -y, 0.0])(rotate(deg, [0, 0, 1])(hole))) except Exception: _, x, y = p return (translate([x, -y, 0.0])(hole)) def parse_hole(p): _, x, y = p return (translate([x, -y, 0.0])(circle(1.1, segments=30))) f = load(open("./right.kicad_pcb")) y = list( filter( lambda x: x[0] == Symbol("module") if isinstance(x, list) else False, f)) z = list(filter(lambda x: x[1] == Symbol("base:ToprePad"), y)) sws = list( map( lambda y: list( filter( lambda x: x[0] == Symbol("at") if isinstance(x, list) else False, y))[0], z)) z = list( filter(lambda x: x[1] == Symbol("MountingHole:MountingHole_2.2mm_M2"), y)) holes = list( map(
return ret if __name__ == '__main__': parser = argparse.ArgumentParser(description='Compare KiCad netlists') parser.add_argument('first_netlist') parser.add_argument('second_netlist') parser.add_argument('--quiet', action='store_true') args = parser.parse_args() fn_a = args.first_netlist fn_b = args.second_netlist with open(fn_a, 'r') as f: a = sexpdata.load(f) with open(fn_b, 'r') as f: b = sexpdata.load(f) # Extract the nets portion a = extract_nets(a) b = extract_nets(b) if a is None: if not args.quiet: print("Could not read nets from {}".format(fn_a)) sys.exit(-1) if b is None: if not args.quiet:
# Extract the bookmark data from the DJVU document # (scratch) retval = 0 retval = retval | os.system("djvused %s -u -e 'print-outline' > %s/bmarks.out" % (args.src, tmp)) print "Bookmarks extracted." # Check for zero-length outline if os.stat("%s/bmarks.out" % tmp).st_size > 0: # Extract the metadata from the PDF document retval = retval | os.system("pdftk %s dump_data_utf8 > %s/pdfmetadata.out" % (args.dest, tmp)) print "Original PDF metadata extracted." # Parse the sexpr pdfbmarks = walk_bmarks(sexpdata.load(open(tmp + '/bmarks.out')), 0) # Integrate the parsed bookmarks into the PDF metadata p = re.compile('NumberOfPages: [0-9]+') metadata = open("%s/pdfmetadata.out" % tmp, 'r').read() for m in p.finditer(metadata): loc = int(m.end()) newoutput = metadata[:loc] + "\n" + pdfbmarks[:-1] + metadata[loc:] # Update the PDF metadata open("%s/pdfmetadata.in" % tmp, 'w').write(newoutput) retval = retval | os.system("pdftk %s update_info_utf8 %s output %s" % (args.dest, tmp + '/pdfmetadata.in', finaldest)) else:
argParser.add_argument('-i', '--input-file', dest='input_file', default="netlists/c17.edif", help="EDIF input file") argParser.add_argument('-o', '--output-file', dest='output_file', default="STDOUT", help="POETS graph XML file") args = argParser.parse_args() with open(args.input_file, 'r') as edif: # true=None, prevent t being intepreted as True e = sexpdata.load(edif, true=None) #s = sexpdata.car(e) #print(type(s)) #print(s.__dict__) #print(inspect.getmembers(s, predicate=inspect.ismethod)) AVAILABLE_CELLS = list(gateMappings.keys()) # dictionary for arrays in EDIF arrays = {} def get_op(lst): return lst[0].value()
def load(f, domain): data = utils.desymbolize(sexpdata.load(f)) return Problem.deserialize(data, domain)
#!/usr/bin/env python3 import sexpdata import sys def walk_bmarks(bmarks, level=0): output = '' wroteTitle = False for j in bmarks: if isinstance(j, list): output = output + walk_bmarks(j, level + 1) elif isinstance(j, str): if not wroteTitle: output = output + "BookmarkBegin\nBookmarkTitle: %s\nBookmarkLevel: %d\n" % ( j, level) wroteTitle = True else: output = output + "BookmarkPageNumber: %s\n" % j.split('#')[1] wroteTitle = False else: pass return output fn = sys.argv[1] data = sexpdata.load(open(fn)) pdfbmarks = walk_bmarks(data) print(pdfbmarks)
def load_lc(filename): """ Load a lambda calculus file into sexpdata """ with open(filename, 'r') as f: return load(f)
def load(f): data = utils.desymbolize(sexpdata.load(f)) return Domain.deserialize(data)
def load(s, **kwargs): return _dictify(sexpdata.load(s, **kwargs))
from cooltools import memcached from cooltools import with_multi_args from time import strftime, gmtime import smoked_rpc proxy_app = Sanic() import config # lisp magic # literally - all software is magic, because it causes change in reality in accordance with will data_file = open('data.lisp') data_model = sexpdata.load(data_file) data_file.close() # TODO - switch from rpc method to some more generic method for data source def gen_entity_multi_handler(entity_dict): defargs = [] has_count = False rpc_method_name = car(entity_dict['rpc_method']).value() for arg in car(cdr(entity_dict['rpc_method'])): if type(arg) is sexpdata.Symbol: if arg.value() == '!count': has_count = True else: defargs.append(arg.value())