def load(self): self.config = {} for fname in [os.path.abspath(self.configfilename), os.path.join('/etc/myownci', self.configfilename)]: if os.path.isfile(fname): self.config = simpleyaml.load(open(fname).read()) break self.config['var'] = {} try: self.config['var'].update(simpleyaml.load(open(os.path.join('/var/tmp', self.configfilename), 'r'))) except IOError: pass
def test_unicode_input(unicode_filename, verbose=False): data = open(unicode_filename, 'rb').read().decode('utf-8') value = ' '.join(data.split()) output = yaml.load(_unicode_open(StringIO.StringIO(data.encode('utf-8')), 'utf-8')) assert output == value, (output, value) for input in [data, data.encode('utf-8'), codecs.BOM_UTF8+data.encode('utf-8'), codecs.BOM_UTF16_BE+data.encode('utf-16-be'), codecs.BOM_UTF16_LE+data.encode('utf-16-le')]: if verbose: print "INPUT:", repr(input[:10]), "..." output = yaml.load(input) assert output == value, (output, value) output = yaml.load(StringIO.StringIO(input)) assert output == value, (output, value)
def main(yamlfilename, csvfilename): vectors = yaml.load(open(yamlfilename)) symbol_class = [[c for c in r] for r in csv.reader(open(csvfilename))] rows = len(vectors) cols = len(vectors[0]) # sort the data by class by_class = dict() for i in range(rows): for j in range(cols): vec = vectors[i][j] sym = symbol_class[i][j] if sym in by_class: by_class[sym].append(vec) else: by_class[sym] = [vec] # plot the data as an average over the class for sym, vecs in by_class.items(): for key in vecs[0].keys(): pad = 2 key_matrix = np.array([v[key][pad:-pad] for v in vecs]) y = key_matrix.mean(0) x = range(pad, len(key_matrix[0]) + pad) err = key_matrix.std(0) plt.errorbar(x, y, yerr=err) name = "output-%s-%s--%d.png" % (sym, key, len(vecs)) plt.title(name) plt.savefig(name) plt.close()
def test_representer_types(code_filename, verbose=False): test_constructor._make_objects() for allow_unicode in [False, True]: for encoding in ['utf-8', 'utf-16-be', 'utf-16-le']: native1 = test_constructor._load_code(open(code_filename, 'rb').read()) native2 = None try: output = yaml.dump(native1, Dumper=test_constructor.MyDumper, allow_unicode=allow_unicode, encoding=encoding) native2 = yaml.load(output, Loader=test_constructor.MyLoader) try: if native1 == native2: continue except TypeError: pass value1 = test_constructor._serialize_value(native1) value2 = test_constructor._serialize_value(native2) if verbose: print "SERIALIZED NATIVE1:" print value1 print "SERIALIZED NATIVE2:" print value2 assert value1 == value2, (native1, native2) finally: if verbose: print "NATIVE1:" pprint.pprint(native1) print "NATIVE2:" pprint.pprint(native2) print "OUTPUT:" print output
def get_config(): """ Load the config file, either from the user data directory, or if that is not available, the installed copy. :returns: config :rtype: dict """ # First check whether the user has a custom home directory. script_dir = os.path.dirname(os.path.realpath(__file__)) home_dir_locfile = os.path.join(script_dir, "user_home.txt") config_path = None if os.path.exists(home_dir_locfile): with open(home_dir_locfile, "rb") as f: home_dir_path = f.read() config_path = os.path.join(home_dir_path, "config.yml") # If it doesn't exist, use the installed copy if config_path is None or not os.path.exists(config_path): config_path = os.path.join( os.path.split(os.path.abspath(__file__))[0], "config.yml" ) # Load & return config with open(config_path) as cfile: return yaml.load(cfile)
def get_config(): """ Load the config file, either from the user data directory, or if that is not available, the installed copy. :returns: config :rtype: dict """ # First check whether the user has a custom home directory. script_dir = os.path.dirname(os.path.realpath(__file__)) home_dir_locfile = os.path.join(script_dir, "user_home.txt") config_path = None if os.path.exists(home_dir_locfile): with open(home_dir_locfile, "rb") as f: home_dir_path = f.read() config_path = os.path.join(home_dir_path, "config.yml") # If it doesn't exist, use the installed copy if config_path is None or not os.path.exists(config_path): config_path = os.path.join( os.path.split(os.path.abspath(__file__))[0], "config.yml") # Load & return config with open(config_path) as cfile: return yaml.load(cfile)
def test_emitter_error(error_filename, verbose=False): events = list(yaml.load(open(error_filename, "rb"), Loader=test_emitter.EventsLoader)) try: yaml.emit(events) except yaml.YAMLError, exc: if verbose: print "%s:" % exc.__class__.__name__, exc
def test_emitter_events(events_filename, verbose=False): events = list(yaml.load(open(events_filename, 'rb'), Loader=EventsLoader)) output = yaml.emit(events) if verbose: print "OUTPUT:" print output new_events = list(yaml.parse(output)) _compare_events(events, new_events)
def test_unicode_input_errors(unicode_filename, verbose=False): data = open(unicode_filename, 'rb').read().decode('utf-8') for input in [data.encode('latin1', 'ignore'), data.encode('utf-16-be'), data.encode('utf-16-le'), codecs.BOM_UTF8+data.encode('utf-16-be'), codecs.BOM_UTF16_BE+data.encode('utf-16-le'), codecs.BOM_UTF16_LE+data.encode('utf-8')+'!']: try: yaml.load(input) except yaml.YAMLError, exc: if verbose: print exc else: raise AssertionError("expected an exception") try: yaml.load(StringIO.StringIO(input)) except yaml.YAMLError, exc: if verbose: print exc
def __init__(self): super(sjcam, self).__init__() self.commands = [] print "parsing yaml" with open('sjcam.yaml', 'r') as yamlFile: commands = yaml.load(yamlFile) print commands for id, values in commands['commands'].items(): self.commands.append( sjcamCommand(id=id, description=values.get('description'), parameters=values.get('parameter', []), readOnly=values.get('readOnly', False), format=values.get('format', '')))
def test_recursive(recursive_filename, verbose=False): exec open(recursive_filename, "rb").read() value1 = value output1 = None value2 = None output2 = None try: output1 = yaml.dump(value1) value2 = yaml.load(output1) output2 = yaml.dump(value2) assert output1 == output2, (output1, output2) finally: if verbose: # print "VALUE1:", value1 # print "VALUE2:", value2 print "OUTPUT1:" print output1 print "OUTPUT2:" print output2
def main(file): stream = open(file, "r") docs = yaml.load(stream) dirname = os.path.dirname(sys.argv[0]) for doc in docs: id = doc['id'] newfile = open(dirname + "/../_papers/" + id + ".html", "w") #for item in doc. doc['layout'] = 'singlepaper' doc['picture'] = 'paco2' string = yaml.dump(doc, explicit_start=True, default_flow_style=False, allow_unicode=True) newfile.write(string) newfile.write("---\n\n") newfile.write("{% include singlepaper.html paper=page %}") newfile.close()
def get_config(): """ Load the config file, either from the user data directory, or if that is not available, the installed copy. :returns: config :rtype: dict """ # First try to load the config file in the # user data directory config_path = os.path.join( appdirs.user_data_dir("superplot", ""), "config.yml" ) # If it doesn't exist, use the installed copy if not os.path.exists(config_path): config_path = os.path.join( os.path.split(os.path.abspath(__file__))[0], "config.yml" ) # Load & return config with open(config_path) as cfile: return yaml.load(cfile)
def canonical_load(stream): return yaml.load(stream, Loader=CanonicalLoader)
import Image, ImageDraw import simpleyaml as yaml import argparse from black_and_white import as_black_and_white def bb(x, y, w, h): return (x, y, x + w, y + h) if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument('mean_file_yml') parser.add_argument('output') parser.add_argument('-split', type=int) args = parser.parse_args() meta_data = yaml.load(open(args.mean_file_yml)) rows = 0 max_w = 0 max_h = 0 for name, data in meta_data.items(): rows += 1 data['image'] = Image.open(data['path']) data['template'] = Image.open(data['template_path']) if args.split: data['image'] = as_black_and_white(data['image'], args.split, contrast=True) data['template'] = as_black_and_white(data['template'], args.split, contrast=True) max_w = max(max_w, data['template'].size[0]) max_h = max(max_h, data['template'].size[1]) max_w = max(max_w, data['image'].size[0]) max_h = max(max_h, data['image'].size[1])
#!/usr/bin/env python2 import sys sys.path.append("/vagrant/includes.zip") import graphit, shlex, urlparse, simpleyaml # MAIN iid = "0838e286-fab7-465f-9405-b308dc2561ba" with open("/opt/autopilot/conf/aae.yaml") as aae_yaml: try: config = simpleyaml.load([ entry['Value'] for entry in simpleyaml.load(aae_yaml)['SystemGlobalVariables'] if entry['Name'] == "KI_Deployment" ][0]) except IndexError: print >> sys.stderr, "Config not found in aae.yaml" sys.exit(5) with graphit.Tunnel( config['SourceEnvironment']['EngineHost'], usr=config['SourceEnvironment']['SSHUser'], opts=shlex.split(config['SourceEnvironment']['SSHOptions']), fwd={ 'graphit': urlparse.urlparse( config['SourceEnvironment']['GraphitURL']).netloc, 'wso2': urlparse.urlparse(config['SourceEnvironment']['WSO2ISURL']).netloc }) as tun: try: source_graph = graphit.GraphAPI(
proximity_counts = get_proximity_counts(map_list, edge_class, directions, proximity_stats=save_prox) proximity_prob = calculate_probabilities(proximity_counts, min_n_size, edge_class) if class_prob_csv: classprobs = classify_byprob(map_list, proximity_prob, directions, edge_class) with open(class_prob_csv, 'w') as f: w = csv.writer(f) w.writerow(["i", "j"] + proximity_prob.keys() + ["intended"]) for r in classprobs: w.writerow(r) prob_headers = csv_probs(proximity_prob, map_classifcation_type) header_names = ["i", "j", map_classifcation_type] + get_header_from_prox_prob(prob_headers) writer.writerow(header_names) for i in range(0, len(map_list)): for j in range(0,len(map_list[i])): cell_class = get_class(j, i, map_list) writer.writerow([i, j, cell_class]+prob_headers[cell_class].values()) if __name__ == "__main__": args = parse_args() if args.output: out_fd = open(args.output, "w") else: out_fd = sys.stdout prox=dict() if args.load: prox=yaml.load(open(args.load)) main(args.map_csv, out_fd, args.edge_class, args.min_n_size, args.map_classification_type, save_prox=prox, class_prob_csv=args.probs) if args.save: open(args.save, 'w').write(yaml.dump(prox))
def configure(): # Read configuration file = open("config/parameters.yml", "r") config = yaml.load(file) file.close() return config
raise ValueError('Not images given to blend') if count == 1: return imgs[0].convert('L') else: return Image.blend(blend_images(imgs[:count/2]), blend_images(imgs[count/2:]), .5) def bounding_box(x, y, w, h, inset=7): return (x + inset, y + inset, x + w - 2 * inset, y + h - 2 * inset) if __name__ == "__main__": args = parse_args() if args.gold: meta_data = yaml.load(open(args.gold)) for name, data in meta_data.items(): meta_data[name]['image'] = Image.open(data['path']) meta_data[name]['template'] = Image.open(data['template_path']) else: meta_data = dict() grid = Image.open(args.map) classes = [r for r in csv.reader(open(args.intended))] rows = len(classes) cols = len(classes[0]) width, height = dims.celldims(grid.size, rows, cols) # collect all cells by class name img_by_class = dict() for j in range(rows):
def gold_classify(gold_images, cell_image, align=True): return [(compare_images(gold, cell_image, align=False), className) for className, gold in gold_images.items()] def bounding_box(x, y, w, h, inset=7): return (x + inset, y + inset, x + w - 2 * inset, y + h - 2 * inset) if __name__ == "__main__": args = parse_args() grid = Image.open(args.image) cell_w, cell_h = dims.celldims(grid.size, args.rows, args.cols) answer = [] gold = yaml.load(open(args.gold)) for name, mean_img in gold.items(): if 'path' in mean_img: gold[name] = Image.open(mean_img['path']) else: gold[name] = Image.open(mean_img) if args.split: gold[name] = as_black_and_white(gold[name], args.split, contrast=True) class_errs = [[gold_classify(gold, grid.crop(bounding_box( j * cell_w, i * cell_h, cell_w, cell_h))) for j in range(args.cols)] for i in range(args.rows)] output = [[min(class_errs[i][j])[1] for j in range(args.cols)] for i in range(args.rows)]
def parse_args(): parser = argparse.ArgumentParser() parser.add_argument('tileset', help="directory with images and yaml file") parser.add_argument('csv_map', help="csv file to tileize") parser.add_argument('output', help="where to output image") return parser.parse_args() def boundingbox(x, y, w, h): return (x, y, x + w, y + h) if __name__ == "__main__": args = parse_args() tile_set = yaml.load(open(os.path.join(args.tileset, 'tiles.yml'))) for name, data in tile_set.items(): if name != 'tiles': tile_set[name]['image'] = Image.open( os.path.join(args.tileset, data['image'])) classes = [r for r in csv.reader(open(args.csv_map))] width = tile_set['tiles']['width'] height = tile_set['tiles']['height'] output_size = (width * len(classes[0]), height * len(classes)) output = Image.new('RGB', output_size, "white") old = [list(x) for x in classes] for j, row in enumerate(classes): for i, cell in enumerate(row): if cell and cell in tile_set:
import simpleyaml as yaml data = yaml.load(file("data.yaml","r")) customers = data['customers'] vipIds = [c['id'] for c in customers if c['vip'] == True]
def test_loader_error_single(error_filename, verbose=False): try: yaml.load(open(error_filename, "rb").read()) except yaml.YAMLError, exc: if verbose: print "%s:" % exc.__class__.__name__, exc
import os import re import shutil from fabric.api import local try: # Py2 import simpleyaml as yaml prj_name = '{name}.jms'.format(name=str(raw_input('Enter masher name: '))) except: # Py3 import yaml prj_name = '{name}.jms'.format(name=str(input('Enter masher name: '))) d_opt = yaml.load(open('options.yaml')) cur_dir = os.getcwd() src_dir = d_opt['gen']['src_dir'] if d_opt['gen']['src_dir'].find( ':' ) > -1 else os.getcwd() + '\\' + d_opt['gen']['src_dir'].rstrip('\\') + '\\' jcl_dir = d_opt['gen']['jcl_dir'] if d_opt['gen']['jcl_dir'].find( ':' ) > -1 else os.getcwd() + '\\' + d_opt['gen']['jcl_dir'].rstrip('\\') + '\\' out_dir = d_opt['gen']['out_dir'] if d_opt['gen']['out_dir'].find( ':' ) > -1 else os.getcwd() + '\\' + d_opt['gen']['out_dir'].rstrip('\\') + '\\' ############ decorators ############### def exe_jcl(f):
#!/usr/bin/env python # -*- coding: utf-8 -*- VERSION = (1, 4, 0) import sys from twisted.internet import reactor from twisted.python import log import simpleyaml as yaml import botfactory log.startLogging(sys.stderr) if len(sys.argv) > 1: config = yaml.load(open(sys.argv[1])) else: log.msg('no config file specified') config['version'] = VERSION f = botfactory.BotFactory(config) # connect factory to this host and port reactor.connectTCP(config['server'], config['port'], f) # run bot reactor.run()