def get_handlers(): handlers = {} for handler_path in glob(path.abspath(path.join(path.dirname(path.realpath(__file__)), '../', 'handlers', '*.yml'))): loader_path = re.sub(r'[^\/]+$', '', handler_path) matches = re.findall(r'[^\/]+$', handler_path) if len(matches) <= 0: exit('Houston, we have a problem') filename = matches[0] variables = {} dump = 'volback-unique-' + encode_service.str_encode(str(time.time())) with open(handler_path, 'r') as f: data = yaml.load(f) for key in _.keys(data): variables[key] = data[key]['variables'] if 'variables' in data[key] else {} variables[key]['dump_path'] = path.join(data[key]['data'], dump) variables['env'] = os.environ env = Environment(loader=FileSystemLoader(loader_path), trim_blocks=True) template = env.get_template(filename) data = yaml.load(template.render(**variables)) for key in _.keys(data): handlers[key] = { 'data': data[key]['data'], 'backup': data[key]['backup'], 'restore': data[key]['restore'], 'dump': dump } return handlers
def register_or_get_nailpack(app, api, nailpack_name): if api: if hasattr(api, '_registered_nailpacks'): if _.includes(_.keys(api._registered_nailpacks), nailpack_name): return api._registered_nailpacks[nailpack_name] nailpack = importlib.import_module(nailpack_name).Nailpack() api._registered_nailpacks[nailpack_name] = nailpack else: nailpack = importlib.import_module(nailpack_name).Nailpack() registered_nailpacks = {} registered_nailpacks[nailpack_name] = nailpack setattr(api, '_registered_nailpacks', registered_nailpacks) setattr(nailpack, 'api', api) else: nailpack = importlib.import_module(nailpack_name).Nailpack() if hasattr(app, '_registered_nailpacks'): if _.includes(_.keys(app._registered_nailpacks), nailpack_name): return app._registered_nailpacks[nailpack_name] app._registered_nailpacks.append(nailpack.name) else: registered_nailpacks = {} registered_nailpacks[nailpack_name] = nailpack setattr(app, '_registered_nailpacks', registered_nailpacks) for key in helpers.pubkeys(nailpack): if app: regsiter_event(app, key, getattr(nailpack, key)) if api: regsiter_event(api, key, getattr(nailpack, key)) if app: setattr(nailpack, 'app', app) setattr(nailpack, 'name', nailpack_name) setattr(nailpack, 'level', get_level(nailpack)) return nailpack
def populate(self, **kwargs): """Extended ndb.Model populate method, so it can ignore properties, which are not defined in model class without throwing error """ kwargs = _.omit(kwargs, Base.PUBLIC_PROPERTIES + ['key', 'id']) # We don't want to populate those properties kwargs = _.pick(kwargs, _.keys(self._properties)) # We want to populate only real model properties super(Base, self).populate(**kwargs)
def main(): #WTForms validators def set_checker(form, field): if len(request.values) > 2: return True raise ValidationError('Please select at least one set.') def blacklist_checker(form, field): if re.match(".*[,;]$", request.values['blacklist']): raise ValidationError( 'Please don\'t have trailing punctuation in the blacklist box.' ) class RandomizerForm(Form): base = BooleanField('Base') intrigue = BooleanField('Intrigue') seaside = BooleanField('Seaside') alchemy = BooleanField('Alchemy') prosperity = BooleanField('Prosperity') cornucopia = BooleanField('Cornucopia') hinterlands = BooleanField('Hinterlands') darkages = BooleanField('Dark Ages') guilds = BooleanField('Guilds') adventures = BooleanField('Adventures') blacklist = TextAreaField('Blacklisted cards', [blacklist_checker]) randomize_button = SubmitField('Get cards!', [set_checker]) form = RandomizerForm(request.values) if ('randomize_button' in request.values) and form.validate(): conn = db.DB() sets = [] for set in _.keys(request.values): if set == 'darkages': sets.append("\'Dark Ages\'") elif set != 'randomize_button' and set != 'blacklist': sets.append("\'" + set + "\'") where_string = ', '.join(sets) query = """CREATE OR REPLACE VIEW picked_cards as SELECT * FROM cards WHERE CardSet IN ({}) AND ({}) ORDER BY RAND() LIMIT 10""".format( where_string, not_statement.blacklist(request.values['blacklist'])) conn.execute(query) query = "SELECT * FROM picked_cards ORDER BY CardSet, Cost" content = conn.execute(query).fetchall() img_links = utils.cardImgLinker(content) return render_template('main.html', form=form, links=img_links) return render_template('main.html', form=form)
def create_or_update(cls,key=None, urlsafe=False, parent=None, **kwargs): """ Updates an entity or creates a new one. If key is None it creates a new entity, if key is set it gets it. Returns key """ def omit(data, omit_list): values = {} for k, v in data.iteritems(): if isinstance(v, dict): # iterable, not string values[k] = omit(v,omit_list) elif k not in omit_list: values[k] = v return values print "CREATE OR UPDATE" print cls if key and (key != "new" or key !="add"): print "GOT key" print key if urlsafe: print "User urlsave" key = ndb.Key(urlsafe=key) print key db = key.get() print kwargs kwargs = omit(kwargs, Base.PUBLIC_PROPERTIES + ['key', 'id']) # We don't want to populate those properties print "kwargs after omiting" print "=============================" print kwargs db.populate(**kwargs) else: print "Save new one" print "properties are:" print _.keys(cls._properties) # We don't want to populate those properties kwargs = omit(kwargs, Base.PUBLIC_PROPERTIES + ['key', 'id']) # We want to populate only real model properties kwargs = _.pick(kwargs, _.keys(cls._properties)) # TODO should be deep! print "____________________________________" print "kwargs" print kwargs db = cls(parent=parent,**kwargs) key = db.put() return key
def main(): #WTForms validators def set_checker(form, field): if len(request.values) > 2: return True raise ValidationError('Please select at least one set.') def blacklist_checker(form, field): if re.match(".*[,;]$", request.values['blacklist']): raise ValidationError('Please don\'t have trailing punctuation in the blacklist box.') class RandomizerForm(Form): base = BooleanField('Base') intrigue = BooleanField('Intrigue') seaside = BooleanField('Seaside') alchemy = BooleanField('Alchemy') prosperity = BooleanField('Prosperity') cornucopia = BooleanField('Cornucopia') hinterlands = BooleanField('Hinterlands') darkages = BooleanField('Dark Ages') guilds = BooleanField('Guilds') adventures = BooleanField('Adventures') blacklist = TextAreaField('Blacklisted cards', [blacklist_checker]) randomize_button = SubmitField('Get cards!', [set_checker]) form = RandomizerForm(request.values) if ('randomize_button' in request.values) and form.validate(): conn = db.DB() sets = [] for set in _.keys(request.values): if set == 'darkages': sets.append("\'Dark Ages\'") elif set != 'randomize_button' and set != 'blacklist': sets.append("\'" + set + "\'") where_string = ', '.join(sets) query = """CREATE OR REPLACE VIEW picked_cards as SELECT * FROM cards WHERE CardSet IN ({}) AND ({}) ORDER BY RAND() LIMIT 10""".format(where_string, not_statement.blacklist(request.values['blacklist'])) conn.execute(query) query = "SELECT * FROM picked_cards ORDER BY CardSet, Cost" content = conn.execute(query).fetchall() img_links = utils.cardImgLinker(content) return render_template('main.html', form=form, links=img_links) return render_template('main.html', form=form)
def dict_to_list(input_dict): """Creates list from dictionary with true booloean values This function is primarily useful for converting passed data from Angular checkboxes, since angular ng-model can't return list of checked group of checkboxes, instead it returns something like {'a': True, 'b': True} for each checkbox Example: >>> dict_to_list({'a': True, 'b': True, 'c': False}) ['a', 'b'] Args: input_dict (dict): Dict with boolean values Returns: list: list of truthful values """ return _.keys(_.pick(input_dict, _.identity))
def run_required(self): global steps_ran steps = self.app.steps cached = True if not hasattr(self, 'requires'): return False if len(self.requires) <= 0: cached = False for required in self.requires: maybe_cached = True if _.includes(_.keys(steps_ran), required): maybe_cached = steps_ran[required] else: maybe_cached = getattr(steps, required).start() if not maybe_cached: cached = maybe_cached return cached
def to_dict(self, include=None): """Return a dict containing the entity's property values, so it can be passed to client Args: include (list, optional): Set of property names to include, default all properties. For nested elements the list can use a dict: eg. ['name','description,{'tags':['name','count']}] """ repr_dict = {} if include is None: include = _.keys(self._properties) #return super(Base, self).to_dict(include=include) def to_value(attr,name_str, name=None): if isinstance(attr, datetime.date): return attr.isoformat() elif isinstance(attr, ndb.Key): if name_str == 'key': return self.key.urlsafe() else: return attr.urlsafe() elif isinstance(attr, ndb.GeoPt): return {'lat':attr.lat, 'lng': attr.lon, 'lon': attr.lon} elif hasattr(attr, '__iter__'): # iterable, not string return [to_value(a,name_str,name) for a in attr] elif hasattr(attr, 'to_dict'): # hooray for duck typing! incl = None if not isinstance(name,dict) else name[name_str] return attr.to_dict(include=incl) else: return attr for name in include: name_str = name if not isinstance(name,dict) else name.keys()[0] attr = getattr(self, name_str) repr_dict[name_str] = to_value(attr,name_str,name) if name_str == 'key': repr_dict['id'] = self.key.id() return repr_dict
def load_conf(conf): if _.includes(sys.argv, '-h') or _.includes(sys.argv, '--help'): return conf cwd_path = os.getcwd() flag = None if _.includes(sys.argv, '--source'): flag = '--source' elif _.includes(sys.argv, '--src'): flag = '--src' elif _.includes(sys.argv, '-s'): flag = '-s' if flag: flag_index = _.index_of(sys.argv, flag) if len(sys.argv) > flag_index + 1: cwd_path = path.abspath(sys.argv[flag_index + 1]) config_path = path.join(cwd_path, 'config.yml') if not path.exists(config_path): Halo(text='config not found: ' + config_path).fail() exit(1) with open(config_path, 'r') as f: try: conf = munchify(_.merge({}, conf, yaml.load(f))) except yaml.YAMLError as err: print(err) exit(1) conf.paths.cwd = cwd_path if 'version' in conf: conf.version = str(conf.version) conf.paths.install = path.join(conf.paths.mount, 'casper') if not path.exists(path.join(conf.paths.install, 'filesystem.squashfs')): conf.paths.install = path.join(conf.paths.mount, 'install') output_path = conf.paths.output conf = munchify( _.merge({}, conf, { 'paths': _.zip_object( _.keys(conf.paths), _.map(conf.paths, lambda x: path.abspath(path.join(conf.paths.cwd, x)))) })) conf.paths.output = path.abspath(output_path) return conf
def serialize_nested(self, dest, current, attribute, opts): embeds = [] attributes = [] if opts and opts.get('attributes'): embeds = filter(lambda x: opts.get(x), opts['attributes']) attributes = filter(lambda x: opts.get(x) is None, opts['attributes']) else: attributes = _.keys(dest) ret = {} if attributes: ret['attributes'] = self.pick(dest, attributes) for embed in embeds: if self._is_complex_type(dest[embed]): self.serialize(ret, dest, embed, opts[embed]) return ret['attributes']
print("") for cat in results: print("{}) {}".format(index, json.dumps(cat))) index += 1 if index > 20: return # load up the taxonomy categories = [] with open("taxonomy.csv", "r") as csvfile: cats = csv.DictReader(csvfile) for cat in cats: categories.append(cat) directories = _.keys(categories[0]) print("Supported directories: {}".format(json.dumps(directories))) find = _.find(categories, {'gcid': "gcid:{}".format(args.gcid)}) if find is None: find = {'gcid': 'gcid:{}'.format(args.gcid)} print("") print("Current config: {}".format(json.dumps(find))) for directory in directories: # handle gcid condition if directory == 'google': find['google'] = args.name continue
def get_all_properties(cls): """Gets all model's ndb properties""" return ['key', 'id'] + _.keys(cls._properties)
def get_data_type(self, container): data_type = container['Config']['Image'][:container['Config']['Image']. index(':')] if not _.includes(_.keys(self.handlers), data_type): data_type = 'raw' return data_type