def __init__(self,infile=None): """ initialize an object >>> files = Files() >>> files.get_value('CASEFILE_HEADERS',resolved=False) '$CIMEROOT/cime_config/config_headers.xml' """ if(infile is None): files = Files() infile = files.get_value('CASEFILE_HEADERS',resolved=True) EntryID.__init__(self,infile)
def load(self): self._map = {} self._tiles = {} self._attributes = {} file = Files.openFile(self._file) self._attributes = self.loadAttributes('attribs', file) self._enemies = self.loadAttributes('enemies', file) self.w = self.getAttr("w") * const.res self.h = self.getAttr("h") * const.res self._display = Display(Surface((self.w, self.h)), klass=self, transparent=True) file = re.search("map: {(.*?)}", file, flags=re.DOTALL).group(1) for tile in re.finditer(r"\((.*?):(.*?)\)", file): rect, right = tile.group(1), tile.group(2) rect = re.match(r"(\d+),(\d+),(\d+),(\d+),(\d+),(\d+)", rect) if not rect: raise Exception("Unrecognized pattern: {}".format(rect)) details = re.match(r"(\d+),(\d+)$", right) if not details: raise Exception("Unrecognized pattern: {}".format(right)) i, e = int(rect.group(1)), int(rect.group(2)) x, y, w, h = rect.group(3), rect.group(4), rect.group(5), rect.group(6) x, y, w, h = int(x), int(y), int(w), int(h) typ, tile = int(details.group(1)), int(details.group(2)) attrib = {} wall = Wall((x, y, w, h), typ, tile, attrib) wall.subscribe("map", self._updateMap) self._map[(i, e)] = wall self._tiles.setdefault(wall.getType(), []).append(wall)
def __init__(self, level, speed, tileset, **kwargs): super().__init__( dirRule=lambda: { -1: Direction.Left, 0: None, 1: Direction.Right }[self.move.getDir(x=True)], **kwargs) self.collision = Collision(self, level) self.move = Move(self, speed, collision=self.collision) self._gravity = GravityLine(self, 2, h=level.map.h // 2) self.jumping = Jumping(self.move, self._gravity, 2) self._input = Input(inputStream=self.getInputStream()) self.applyInputSettings() self._damageTimer = MinTimeEventStream(duration=2) self._damageTimer.subscribe("self", self._takeDmg, autoInit=False) def _isMoving(): return self.move.getSpeed(x=True) != 0 def _hDir(): return self.move.getDir(x=True) def _vDir(): return {False: -1, True: 1}[self._gravity.positiveDir()] image = Files.loadImage(tileset) self._display = Display(image, self, Animation(image, 11, _isMoving, _hDir, _vDir), True) self._weapon = Weapon(level, anchor=self, offsetFunc=lambda: ((5 * self.getIntDir()), 0), inputStream=self.getInputStream())
def __init__(self, rect, speed, tileset, level, maxHealth, **kwargs): super().__init__(rect=rect, dirRule=lambda: { -1: Direction.Left, 0: None, 1: Direction.Right, }[self.move.getDir(x=True)], idName="enemy", baseHealth=maxHealth, **kwargs) self.collision = Collision(self, level, "enemy") self.move = Move(self, speed, self.collision) self.gravity = GravityLine(self, 2, h=level.map.h // 2) self._ai = AI(self) def _isMoving(): return self.move.getSpeed(x=True) != 0 def _hDir(): return self.move.getDir(x=True) def _vDir(): return {False: -1, True: 1}[self.gravity.positiveDir()] image = Files.loadImage(tileset) self._display = Display(image, self, Animation(image, 11, _isMoving, _hDir, _vDir), True)
def create_paramsets(self, user, files, basemetadata, outliers): self.fileset = Files() self.fileset.load_files(files) self.baseparamset = ParameterSet() self.baseparamset.initialize(user, basemetadata) self.outlierparamsets = [] for record in outliers: pset = ParameterSet() pset.initialize(user, record['metadata']) self.outlierparamsets.append( (record['files'], pset) )
def __init__(self, infile=None, files=None, machine=None): """ initialize an object if a filename is provided it will be used, otherwise if a files object is provided it will be used otherwise create a files object from default values """ self.machine = None self.name = None if (infile is None): if (files is None): files = Files() infile = files.get_value("MACHINES_SPEC_FILE") GenericXML.__init__(self, infile) if (machine is None): machine = self.probe_machine_name() self.set_machine(machine)
def __init__(self): self.pause = False self.next = False self._stop = False self.pause_at_end = False self.reverse = False self.speed = 1 self._files = Files(DIRECTORY) self.queue = list(self._files) random.shuffle(self.queue) self._loaded_songs = [] self._nr_loaded = 0
def main(): global flv_root, stats, def_lang, filters, files flv_root = FLVDirectory("/") def_lang = "fi,en,la,it" filters = [] files = Files() FLVFile.files = files # XXX: Hack flv_parse_config_file("atrfs.conf") # Add files into root directory. for name in files.get_names(): # FLVFiles can be stored as (unique) names. flv_root.add_entry(name, name) stats = FLVStatistics() flv_root.add_entry("stat", stats) stats.lookup("language").set_contents(def_lang) server = ATRFS() server.parse() server.main()
def save(self): s = [] s.append("attribs: {\n") for a, val in self._attributes.items(): s.append(" {}: {},\n".format(a, val)) s.append("}\n") s.append("map: {\n") for i in range(self.getAttr("h")): for e in range(self.getAttr("w")): tile = self._map[(e, i)] s.append("({},{},{},{},{},{}:{},{}".format(e, i, tile.x, tile.y, tile.w, tile.h, tile.getType().value, tile.getTile())) spawn = tile.getAttr("spawnNum") if spawn: s.append(",[{}]".format(str(spawn))) s.append(")") s.append("\n") s.append("}") Files.saveFile(self._file, ''.join(s))
def __init__(self, x, y, parent): super().__init__(pos=(x, y)) assert isinstance(parent, Health) self._hearts = [] self._parent = parent hearts = Files.loadImage(const.heartsImg) self._heartFilled = (hearts.subsurface(Object(rect=(0, 0, 10, 16)).asRect()), hearts.subsurface(Object(rect=(10, 0, 10, 16)).asRect())) self._heartEmpty = (hearts.subsurface(Object(rect=(20, 0, 10, 16)).asRect()), hearts.subsurface(Object(rect=(30, 0, 10, 16)).asRect())) self.update() self._parent.subscribe("healthbar", self.recalculate)
def __init__(self, x, y, maxTime, numNums=3): image, width = const.numbers numbers = Files.loadImage(image) numbers.set_colorkey(numbers.get_at((0, 0))) super().__init__(rect=(x, y, width * numNums, numbers.get_height()), enabled=True) self._numbers = [] self._digits = [] self._maxTime = maxTime self._currentTime = maxTime self._blank = Display(Surface((width, self.h))) for i in range(width): self._numbers.append(Display(numbers.subsurface((i * width, 0, width, self.h)))) surf = Surface((self.w + 2 * numNums, self.h)) self._display = Display(surf, self, transparent=True, alpha=200) for i in range(numNums): self._digits.append(surf.subsurface((i * width + 2 * i, 0, width, self.h))) self._lastUpdate = -maxTime
def lpd_block(self): name = Files() lpd_blockwise = name.lpd_block return lpd_blockwise
def telemetry_last7days(self): name = Files() telemetry_last7days = name.telemetry_last7days return telemetry_last7days
def pat_clusterwise(self): name = Files() pat_clusterwise = name.pat_clusterwise return pat_clusterwise
class MusicPlayer(object): def __init__(self): self.pause = False self.next = False self._stop = False self.pause_at_end = False self.reverse = False self.speed = 1 self._files = Files(DIRECTORY) self.queue = list(self._files) random.shuffle(self.queue) self._loaded_songs = [] self._nr_loaded = 0 def toggle_pause(self): self.pause = not self.pause return self.pause def toggle_reverse(self): self.speed = -self.speed return self.speed < 0 def next_song(self): self.next = True self.pause = False def pause_at_end_of_song(self): self.pause_at_end = True def set_speed(self, play_speed): self.speed = play_speed def stop(self): self._stop = True def load_next(self): while not self.queue or self._nr_loaded >= MAX_LOADED: if self._stop is True: return time.sleep(SLEEP_TIME) metadata = self.queue.pop() song = AudioSegment.from_file(metadata["path"]) song.metadata = metadata self._loaded_songs.append(song) self._nr_loaded += 1 print("loaded", self.namestring(metadata)) def play_next_song(self): while not self._loaded_songs: if self._stop is True: return time.sleep(SLEEP_TIME) song = self._loaded_songs.pop(0) self._nr_loaded -= 1 if self.speed > 0: chunk_index = 0 speed = self.speed data = song.readframes(chunk_index) else: chunk_index = int(len(song._data)/1024/song.frame_width) speed = -self.speed data = song.readframesreverse(chunk_index) print(self.namestring(song.metadata)) p = pyaudio.PyAudio() stream = p.open(format=p.get_format_from_width(song.sample_width), channels=song.channels, rate=int(song.frame_rate*speed), output=True) while data != '': if self.next: stream.close() p.terminate() self.next = False return if not self.pause: stream.write(data) if self.speed > 0: data = song.readframes(chunk_index) chunk_index += 1 else: data = song.readframesreverse(chunk_index) chunk_index -= 1 else: time.sleep(SLEEP_TIME) stream.close() p.terminate() if self.pause_at_end: self.pause_at_end = False self.pause = True def search_music(self, searchterm): songs_found = 0 self.queue = [] for file in self._files: if searchterm.lower() in file["path"].lower(): print(self.namestring(file)) self.queue.append(file) songs_found += 1 print(songs_found, " songs found") def reorder(self): self._files.reorder() def namestring(self, metadata): title = metadata["title"] artist = metadata["artist"] length = metadata["length"] str_length = "" if length is not None: str_length = " (" + str("%.1f" % metadata["length"]) + " seconds)" if title is not None and artist is not None: return artist + " - " + title + str_length else: return "filename: " + os.path.splitext(os.path.basename(metadata["path"]))[0] + str_length
def __init__(self, file, tileset): super().__init__() self._file = file self._tileset = Files.loadImage(tileset) self._tileset.set_colorkey(self._tileset.get_at((0, 0)))
def exception_block(self): name = Files() exception_block = name.exception_block return exception_block
def exception_school(self): name = Files() exception_school = name.exception_school return exception_school
def pchart_districts(self): name = Files() pchart_districtwise = name.pchart_districtwise return pchart_districtwise
def pat_districtwise(self): name = Files() pat_districtwise = name.pat_districtwise return pat_districtwise
def sr_district(self): name = Files() sr_district = name.sr_district return sr_district
def location_textbook(self): name = Files() location_textbook = name.location_textbook return location_textbook
def location_course(self): name = Files() location_course = name.location_course return location_course
def completion_error(self): name = Files() completion_error = name.completion_error return completion_error
def pat_district(self): name = Files() pat_district = name.pat_district return pat_district
def lpd_cluster(self): name = Files() lpd_clusterwise = name.lpd_cluster return lpd_clusterwise
def pat_school(self): name = Files() pat_school = name.pat_school return pat_school
def lpd_school(self): name = Files() lpd_schoolwise = name.lpd_school return lpd_schoolwise
def pat_cluster(self): name = Files() pat_cluster = name.pat_cluster return pat_cluster
def exception_cluster(self): name = Files() exception_cluster = name.exception_cluster return exception_cluster
def pat_block(self): name = Files() pat_block = name.pat_block return pat_block
def sr_clusterwise(self): name = Files() sr_clusterwise = name.sr_clusterwise return sr_clusterwise
def school_invalid_data(self): name = Files() completion_error = name.completion_error return completion_error
def telemetry_lastmonth(self): name = Files() telemetry_lastmonth = name.telemetry_lastmonth return telemetry_lastmonth
def pchart_grades(self): name = Files() pchart_grades = name.pchart_grades return pchart_grades
def telemetry_lastday(self): name = Files() telemetry_lastday = name.telemetry_lastday return telemetry_lastday
def lpd_districts(self): name = Files() lpd_districtwise = name.lpd_district return lpd_districtwise
def pchart_blocks(self): name = Files() pchart_blocks = name.pchart_blocks return pchart_blocks
def pat_blockwise(self): name = Files() pat_blockwise = name.pat_blockwise return pat_blockwise
# Routes app.add_url_rule('/', view_func=Main.as_view('main'), methods=["GET"]) app.add_url_rule('/<page>/', view_func=Main.as_view('main'), methods=["GET"]) app.add_url_rule('/login/', view_func=Login.as_view('login'), methods=["GET", "POST"]) app.add_url_rule('/remote/', view_func=Remote.as_view('remote'), methods=['GET', 'POST']) app.add_url_rule('/music/', view_func=Music.as_view('music'), methods=['GET']) app.add_url_rule('/files/', view_func=Files.as_view('files'), methods=['GET']) app.add_url_rule('/viewer/', view_func=Viewer.as_view('viewer'), methods=['GET', 'POST']) @app.errorhandler(404) def page_not_found(error): return flask.render_template('404.html'), 404 app.debug = True app.run()
def pchart_clusters(self): name = Files() pchart_clusters = name.pchart_clusters return pchart_clusters
def incoming_form(self, req, obj_id_str): # FIXME another routine on the refactoring list! self.obj_id = ObjectId(obj_id_str) # validate session id with req. sessionid = req.session.get('draft_id', None) if not sessionid == self.obj_id: self.mark_error('home', 'You have no access to the requested ' 'resource. Perhaps your session has been time out?') formtgt = [x for x in req.POST if x.startswith('target_')][0] if formtgt == 'target_add_files': if not req.POST['pastefiles'] and \ 'selectfiles' not in req.POST: self.mark_error('return_to_form', 'You have not selected files') return else: files = Files() files.post_files(req.POST) if not files.check_file_formatting(): self.mark_error('return_to_form', 'Your files contain the' ' following forbidden characters: {0}'.format(' '.join( \ files.forbidden_found))) self.db.update_files( self.obj_id, { 'files': { k[0]: {'extension':\ k[1]} for k in files.filelist }}) # with obj_id, get tmp metadata['sessionid'] # paramset, validate, store. elif formtgt in ['target_write_metadata','target_define_outliers', 'target_more_outliers']: files, basemd, outliers = self.load_from_db(self.obj_id, sessionid) self.paramset = ParameterSet() self.paramset.incoming_metadata(req.POST) if not self.paramset.error: if formtgt == 'target_write_metadata': # FIXME why next line? arent files already read above? files = self.db.get_files(self.obj_id) files['files'], autodet_done = \ self.paramset.do_autodetection(files['files'], [fn for fn in files['files']] ) self.paramset.parameter_lookup() self.paramset.generate_metadata_for_db() self.db.update_draft_metadata(self.obj_id, self.paramset.metadata, replace=False) else: outlierfiles = req.POST.getlist('outlierfiles', None) # check outliers if not outlierfiles: self.mark_error('return_to_form', 'No outlier files' ' were specified.') return basemd.pop('_id') if self.paramset.metadata == basemd: self.mark_error('return_to_form', 'Outlier metadata ' 'identical to base metadata') return for outlier in outliers: if self.paramset.metadata == outlier['metadata']: self.mark_error('return_to_form', 'Outlier metadata identical ' 'to previous outlier metadata.') return elif set(outlierfiles).intersection(outlier['files']): self.mark_error('return_to_form', 'Specified outlier files ' 'already selected in previous outlier set.') return files['files'], autodet_done = \ self.paramset.do_autodetection(files['files'],outlierfiles) self.paramset.parameter_lookup() # Checks passed, save to db: self.paramset.generate_metadata_for_db() self.more_outliers = 'target_more_outliers'==formtgt meta_for_db = { 'draft_id': self.obj_id, 'metadata': self.paramset.metadata, 'files': outlierfiles } self.db.insert_outliers(meta_for_db) if autodet_done: # DB hit is expensive, check first self.db.update_files(self.obj_id, files) else: self.mark_error('return_to_form', 'Errors in entered metadata')
def pchart_schools(self): name = Files() pchart_schools = name.pchart_schools return pchart_schools
class MetadataSet(object): def __init__(self): self.is_new_dataset = False self.obj_id = False self.more_outliers = False self.error = False self.config = metadataconfig.MetadataConfig() self.paramconf = ParameterSet() def new_dataset(self, request): userparams = self.paramconf.get_user_params() userparams = [up.name for up in userparams] user = '******'.format(request.user.first_name.encode('utf-8'), request.user.last_name.encode('utf-8')) draft_oid = self.db.insert_draft_metadata({up:user for up in \ userparams}) self.initialize_new_dataset(request, draft_oid) return str(draft_oid) def copy_dataset(self, request, oid_str): draft_oid = self.draft_from_fullmetadata('copy', oid_str) self.initialize_new_dataset(request, draft_oid) return str(draft_oid) def edit_dataset(self, request, oid_str): draft_oid = self.draft_from_fullmetadata('edit', oid_str) request.session['draft_id'] = draft_oid request.session['metadatastatus'] = 'edit' return str(draft_oid) def show_dataset(self, request, oid_str): session_id = request.session.get('draft_id', None) files, basemd, outliers = self.load_from_db(ObjectId(oid_str), session_id) self.check_completed_stages(basemd, files, request.session) self.create_paramsets(request.user, files, basemd, outliers) self.paramset = self.baseparamset def show_errored_dataset(self, request, oid_str): session_id = request.session.get('draft_id', None) files, basemd, outliers = self.load_from_db(ObjectId(oid_str), session_id) self.check_completed_stages(basemd, files, request.session) self.create_paramsets(request.user, files, basemd, outliers) def store_dataset(self, request, oid_str): """ SHould be turned into class later for diff storage forms""" sessionid = request.session.get('draft_id', None) curdate = datetime.date.strftime(datetime.datetime.now(), '%Y%m%d') if not sessionid == oid_str: pass # TODO ERROR filesset, basemd, outliers = self.load_from_db(ObjectId(oid_str), sessionid) # remove draft_id, status=edit/copy, metadata_id, etc from data metadata_id = basemd.pop('metadata_id', None) for x in ['draft_id', 'status', '_id']: # TODO this should be solved elsewhere, what if we change a name somewhere!? filesset.pop(x, None) basemd.pop(x, None) for rec in outliers: rec.pop(x, None) # pops from the original dict data object, no # need to redefine and put in new list. # convert outliers to files in fullmeta files = filesset['files'] for out in outliers: for key,val in out['metadata'].items(): if key in basemd and val != basemd[key]: for fn in out['files']: files[fn][key] = val fullmeta = {'metadata': basemd, 'files': files} fullmeta['general_info'] = {'date': curdate, 'mail': request.user.email, 'status': 'storing', } if metadata_id: # only when editing, no general info update self.db.update_metadata(metadata_id, {'metadata':fullmeta['metadata']}) self.db.update_metadata(metadata_id, {'files':fullmeta['files']}) else: metadata_id = self.db.insert_metadata_record(fullmeta) # get id from SQL DB that registers mongoid/users # Base infofilename on that. Concurrency problem solved. d = self.save_to_sql_db(Dataset, user=request.user, mongoid=str(metadata_id),date=datetime.datetime.now(), project=basemd['Project'], experiment=basemd['Experiment']) # map get dataset owners from base parameters and save to django db # FIXME this whole routine should be refactored! self.create_paramsets(request.user, filesset, basemd, outliers) owners = {x: 0 for x in self.baseparamset.return_dataset_owners() } for u in User.objects.all(): name = '{0} {1}'.format(u.first_name.encode('utf-8'), u.last_name.encode('utf-8')) if name in owners: owners[name] = u if request.user not in owners.values(): owners['loggedin_user'] = request.user for o in owners.values(): self.save_to_sql_db(DatasetOwner, dataset=d, owner=o) # save the whole metadata to mongo fullmeta['general_info']['status'] = 'new' fullmeta['general_info']['nr'] = d.id self.db.update_metadata(metadata_id, fullmeta, replace=True) def incoming_form(self, req, obj_id_str): # FIXME another routine on the refactoring list! self.obj_id = ObjectId(obj_id_str) # validate session id with req. sessionid = req.session.get('draft_id', None) if not sessionid == self.obj_id: self.mark_error('home', 'You have no access to the requested ' 'resource. Perhaps your session has been time out?') formtgt = [x for x in req.POST if x.startswith('target_')][0] if formtgt == 'target_add_files': if not req.POST['pastefiles'] and \ 'selectfiles' not in req.POST: self.mark_error('return_to_form', 'You have not selected files') return else: files = Files() files.post_files(req.POST) if not files.check_file_formatting(): self.mark_error('return_to_form', 'Your files contain the' ' following forbidden characters: {0}'.format(' '.join( \ files.forbidden_found))) self.db.update_files( self.obj_id, { 'files': { k[0]: {'extension':\ k[1]} for k in files.filelist }}) # with obj_id, get tmp metadata['sessionid'] # paramset, validate, store. elif formtgt in ['target_write_metadata','target_define_outliers', 'target_more_outliers']: files, basemd, outliers = self.load_from_db(self.obj_id, sessionid) self.paramset = ParameterSet() self.paramset.incoming_metadata(req.POST) if not self.paramset.error: if formtgt == 'target_write_metadata': # FIXME why next line? arent files already read above? files = self.db.get_files(self.obj_id) files['files'], autodet_done = \ self.paramset.do_autodetection(files['files'], [fn for fn in files['files']] ) self.paramset.parameter_lookup() self.paramset.generate_metadata_for_db() self.db.update_draft_metadata(self.obj_id, self.paramset.metadata, replace=False) else: outlierfiles = req.POST.getlist('outlierfiles', None) # check outliers if not outlierfiles: self.mark_error('return_to_form', 'No outlier files' ' were specified.') return basemd.pop('_id') if self.paramset.metadata == basemd: self.mark_error('return_to_form', 'Outlier metadata ' 'identical to base metadata') return for outlier in outliers: if self.paramset.metadata == outlier['metadata']: self.mark_error('return_to_form', 'Outlier metadata identical ' 'to previous outlier metadata.') return elif set(outlierfiles).intersection(outlier['files']): self.mark_error('return_to_form', 'Specified outlier files ' 'already selected in previous outlier set.') return files['files'], autodet_done = \ self.paramset.do_autodetection(files['files'],outlierfiles) self.paramset.parameter_lookup() # Checks passed, save to db: self.paramset.generate_metadata_for_db() self.more_outliers = 'target_more_outliers'==formtgt meta_for_db = { 'draft_id': self.obj_id, 'metadata': self.paramset.metadata, 'files': outlierfiles } self.db.insert_outliers(meta_for_db) if autodet_done: # DB hit is expensive, check first self.db.update_files(self.obj_id, files) else: self.mark_error('return_to_form', 'Errors in entered metadata') def mark_error(self, redirect, message): self.error = { 'redirect': redirect, 'message': message } def initialize_new_dataset(self, request, draft_oid): self.save_to_sql_db(DraftDataset, user=request.user, mongoid=str(draft_oid), date=datetime.datetime.now()) request.session['draft_id'] = draft_oid request.session['metadatastatus'] = 'new' self.db.insert_files({'draft_id': draft_oid}) def draft_from_fullmetadata(self, task, obj_id_str): obj_id = ObjectId(obj_id_str) # load md from db files, basemd, outliers = self.load_from_db(obj_id) # create draftmeta dict, add status = 'editing/copy' basemd['status'] = task if task == 'edit': basemd['metadata_id'] = self.fullmeta['_id'] else: files, outliers = {}, [] draft_id = self.db.insert_draft_metadata(basemd) for record in outliers: record['draft_id'] = draft_id self.db.insert_outliers(record) return draft_id def load_from_db(self, obj_id, sessionid=None): self.fullmeta = self.db.get_metadata(obj_id) if not self.fullmeta: # data is either draft, or doesn't exist if sessionid != obj_id: pass # TODO error, NO ACCESS or redirect! else: basemetadata = self.db.get_metadata(obj_id, draft=True) if not basemetadata: pass # NO ACCESS!, redirect else: files = self.db.get_files(obj_id) outliers = [] for record in self.db.get_outliers(obj_id): outliers.append(record) else: # We're either editing or we're just showing. basemetadata = self.fullmeta['metadata'] files = {'files': self.fullmeta['files']} outliers = self.get_outliers_from_fullmetadata(self.fullmeta) # convert mongo's unicode to utf-8 # my first recursive function! What a mindwarp. def convert_dicts_unicode_to_utf8(d): if isinstance(d, dict): return { convert_dicts_unicode_to_utf8(k): \ convert_dicts_unicode_to_utf8(v) for k,v in d.items() } elif isinstance(d, list): return [convert_dicts_unicode_to_utf8(x) for x in d] elif isinstance(d, unicode): return d.encode('utf-8') else: return d basemetadata = convert_dicts_unicode_to_utf8(basemetadata) files = convert_dicts_unicode_to_utf8(files) newoutliers = [] for outlier in outliers: newoutliers.append(convert_dicts_unicode_to_utf8(outlier)) return files, basemetadata, newoutliers def get_outliers_from_fullmetadata(self, md): outliers = [] for fn in md['files']: if set(md['metadata']).intersection(md['files'][fn]): outlier = { x: md['metadata'][x] for x in md['metadata'] } for key in set(md['metadata']).intersection(md['files'][fn]): outlier[key] = md['files'][fn][key] outliers.append(outlier) else: continue return outliers def create_paramsets(self, user, files, basemetadata, outliers): self.fileset = Files() self.fileset.load_files(files) self.baseparamset = ParameterSet() self.baseparamset.initialize(user, basemetadata) self.outlierparamsets = [] for record in outliers: pset = ParameterSet() pset.initialize(user, record['metadata']) self.outlierparamsets.append( (record['files'], pset) ) def save_to_sql_db(self, model, **kwargs): record = model(**kwargs) record.save() return record def check_completed_stages(self, basemd, files, session): self.tocomplete = ['files', 'metadata', 'outliers', 'store'] self.completed = [] self.completetitles = {'files': 'Files', 'metadata': 'Base Metadata', 'outliers': 'Outliers', 'store': 'Store Metadata'} if 'files' in files and session['metadatastatus'] == 'new': self.completed.append('files') userparams = [x.name for x in self.paramconf.get_user_params() ] if set(basemd.keys()).difference(userparams) != set(['_id']): self.completed.append('metadata') self.completed.append('outliers') if not False in [x in self.completed for x in ['metadata', 'files']]: self.completed.append('store')
def pchart_views(self): name = Files() pchart_view = name.pchart_view return pchart_view
def pchart_subjects(self): name = Files() pchart_subjects = name.subject_wise return pchart_subjects
def __init__(self, size, dampSpeed, picture, transparency): super().__init__(size=size) self._dampSpeed = dampSpeed self._picture = Files.loadImage(picture) self._display = Display(self._picture, klass=self, transparent=transparency)