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)
