def get(self, owner_id, assignment_name):
headers = {'Content-Type': 'text/html'}
args = parser.parse_args()
owner = User.objects(id=owner_id).first()
user_id = session['user_id']
user = User.objects(id=user_id).first()
assignment = Assignment.objects(name=assignment_name) \
.filter(owner=owner).first()
# Allow re-submission
#if assignment.statuses[str(user_id)]:
# return redirect("/annotator")
assignment.owner_name = assignment.owner.name
assignment.ds_name = assignment.dataset.name
assignment.ds_owner_id = str(assignment.dataset.owner.id)
queries = Query.objects(assignment=assignment,
creator=user,
submitted=False)
return make_response(
render_template("assignment.html",
user=user,
assignment=assignment,
queries=queries), 200, headers)
def post(self):
headers = {'Content-Type': 'application/json'}
args = parser.parse_args()
name = args['name']
ranker = args['ranker']
params = args['params']
dataset = args['dataset']
deadline = args['deadline']
doc_scores = args['doc_scores']
num_results = args['num_results']
assignment = Assignment()
assignment.name = name
assignment.owner = User.objects(id=session['user_id']).first()
assignment.ranker = ranker
assignment.params = params
assignment.dataset = Dataset.objects(id=dataset).first()
assignment.annotators = User.objects()
assignment.statuses = {
str(anno.id): False
for anno in assignment.annotators
}
assignment.deadline = deadline
assignment.num_results = num_results
assignment.save()
return str(assignment.id)
def get(self):
user = User.objects(id=session['user_id']).first()
my_datasets = Dataset.objects(owner=user)
public_datasets = Dataset.objects(privacy='public', owner__ne=user)
authorized_datasets = Dataset.objects(privacy='private', collaborators__in=[user])
classes = [class_.name for class_ in Class.objects(owner=user)]
assignments = list(map(self._collect_assignment_data, Assignment.objects(owner=user)))
return make_response(render_template(
"instructor.html",
data={
"user" : json.dumps(user.to_json()),
"my_datasets" : my_datasets,
"public_datasets" : public_datasets,
"authorized_datasets" : authorized_datasets,
"classes" : classes,
"assignments" : assignments
},
logged_in=('user_id' in session)
),
200,
{'Content-Type': 'text/html'}
)
def get(self):
headers = {'Content-Type': 'text/html'}
user_id = session['user_id'];
user = User.objects(id=user_id).first()
assignments = Assignment.objects()
for assignment in assignments:
assignment['owner_name'] = assignment.owner.name
assignment['owner_id'] = str(assignment.owner.id)
assignment['ds_name'] = assignment.dataset.name
assignment['complete'] = assignment.statuses.get(str(user_id), False)
return make_response(
render_template(
"annotator.html",
data={
"assignments" : assignments,
"user" : user
},
logged_in=('user_id' in session)
),
200,
headers
)
def _get_or_init_owner_path(self):
owner = User.objects(id=session["user_id"]).first()
owner_path = cfg["anno_dataset_base_path"] + str(owner.gitlab_id)
if not os.path.exists(owner_path):
os.mkdir(owner_path)
return owner_path
def post(self):
args = parser.parse_args()
class_ = Class()
class_.owner = User.objects(id=session['user_id']).first()
class_.name = args['name']
#class_.password = args['password']
class_.save()
return make_response(jsonify({"message": "Success"}), 200)
def authorized():
token = gitlab.authorize_access_token()
session['gitlab_token'] = token
resp = requests.get('https://lab.textdata.org/api/v4/user?access_token=' +
token['access_token'])
resp = resp.json()
if 'id' in resp:
user = User.objects(gitlab_id=resp['id']).first()
if not user:
user = User(gitlab_id=resp['id'],
name=resp['name'],
email=resp['email'])
user.save()
session['user_id'] = str(user.id)
return redirect('/')
else:
return redirect('/logout')
def query_nsa_filter(assignment):
queries_need_to_show_new = []
for q in assignment.queries_need_to_show:
all_annotations_of_the_query = Annotation.objects(query=q)
annotations = []
for annotation in all_annotations_of_the_query:
if annotation.assignment.name == assignment.name and annotation.assignment.instructor == assignment.instructor:
annotations.append(annotation)
students = {}
student_list = []
documents = {}
for annotation in annotations:
if annotation.annotator.id not in students.keys():
students[annotation.annotator.id] = len(students)
student_list.append(annotation.annotator.id)
if annotation.doc.id not in documents.keys():
documents[annotation.doc.id] = len(documents)
students_annotations_res = np.zeros(
(len(documents), len(students)), dtype=int)
credibility_scores = np.zeros(len(students))
for annotation in annotations:
score = 1 if annotation.judgement else -1
students_annotations_res[documents[annotation.doc.id]][
students[annotation.annotator.id]] = score
for studentID, pos in students.items():
credibility_scores[pos] = User.objects(
id=studentID).first().credibility_score
res = OutputDecision.Decision(students_annotations_res,
credibility_scores)
if res.completed:
for i in range(len(student_list)):
userobj = User.objects(id=student_list[i]).first()
old_credibility_score = userobj.credibility_score
new_credibility_score = old_credibility_score + (
res.new_credibility_scores[i] -
old_credibility_score) / 3
userobj.update(credibility_score=new_credibility_score)
else:
queries_need_to_show_new.append(q)
assignment.update(queries_need_to_show=queries_need_to_show_new)
def post(self, owner_id, ds_name): args = parser.parse_args() query = args['query'] ranker = args['ranker'] num_results = args['num_results'] params = args['params'] owner = User.objects(id=owner_id).first() path = cfg["anno_dataset_base_path"] + str(owner.gitlab_id) searcher = Searcher(ds_name, path) documents = jsonify(searcher.search(query, ranker, params, num_results)) return make_response(documents)
def get(self):
check_role('instructor')
datasets = [(d.name, d.author.name) for d in DataSet.objects()]
instructor = User.objects(email=current_user.email).first()
assignments = {}
for assignment in Assignment.objects(instructor=instructor):
assignments[(assignment.name, assignment.instructor.name)] = (
self.get_judgement_score(assignment))
return make_response(
render_template('instructor.html',
datasets=datasets,
assignments=assignments))
def post(self):
headers = {'Content-Type': 'application/json'}
args = parser.parse_args()
content = args['content']
dataset = args['dataset']
creator = args['creator']
dataset = Dataset.objects(id=dataset)
creator = User.objects(id=creator)
query = Query()
query.content = content
query.data_set = dataset[0]
query.creator = creator[0]
query.submitted = False
query.save()
return make_response(jsonify("succeed"), 200, headers)
def store_annotations(annotations, assignment_id):
assignment = Assignment.objects(id=assignment_id).first()
for query_id in annotations:
query = Query.objects(id=query_id).first()
for doc_id in annotations[query_id]:
result = annotations[query_id][doc_id]
judgement = False
if result == 'T':
judgement = True
doc = Document.objects(id=doc_id).first()
user = User.objects(email=current_user.email).first()
try:
Annotation(user, query, doc, judgement, assignment).save()
except (NotUniqueError, ValidationError):
return False
AnnotatorAPI.query_nsa_filter(assignment)
return True
def search(assignment, dataset_name, queries, ranker, params, num_results):
author = User.objects(email=current_user.email).first()
path = os.path.join(current_app.root_path, 'data', author.name)
searcher = Searcher(dataset_name, path)
for query in queries:
results = searcher.search(query, ranker, params,
num_results)['results']
for result in results:
doc_path = str(
os.path.join(path, result['path'].encode('utf8')[2:]))
doc_score = result['score']
document = Document.objects(path=doc_path).first()
q = Query.objects(content=query).first()
Score(result=doc_score,
assignment=assignment,
query=q,
document=document).save()
def get(self, instructor_name, assignment_name):
# TODO: annotation view
check_role('annotator')
instructor = User.objects(name=instructor_name).first()
assignment = Assignment.objects(name=assignment_name,
instructor=instructor).first()
if not assignment:
flash('No Such Assignment!')
return redirect(url_for('annotatorapi'))
queries = {}
assignment_score = Score.objects(assignment=assignment)
for q in assignment.queries_need_to_show:
scores = assignment_score.filter(query=q)
queries[q] = [score.document for score in scores]
return make_response(
render_template('assignment.html',
assignment=assignment,
queries=queries))
def post(self):
headers = {'Content-Type': 'application/json'}
args = parser.parse_args()
assignment_id = args['assignment_id']
assignment = Assignment.objects(id=assignment_id).first()
annotations = args['annotations']
user_id = session['user_id']
# Allow re-submission
#if assignment.statuses[str(user_id)]:
# return make_response(jsonify("Failed: Already submitted assignment"), 200)
annotator = User.objects(id=user_id).first()
for query_content in annotations:
query = Query.objects(assignment=assignment,
content=query_content).first()
apq = annotations[query_content]
for file_name in apq:
label = apq[file_name]
dataset = assignment.dataset
document = Document.objects(dataset=dataset) \
.filter(name=file_name).first()
a = Annotation()
a.annotator = annotator
a.document = document
a.judgement = label
a.query = query
a.save()
Query.objects(id=query.id).update(submitted=True)
# student has completed the assignment
cstatus = assignment.statuses
cstatus[str(user_id)] = True
Assignment.objects(id=assignment_id).update(statuses=cstatus)
return make_response(jsonify("succeed"), 200, headers)
def post(self):
args = parser.parse_args()
query_content = args['query']
assignment_id = args['assignment_id']
user_id = args['user_id']
doc_scores = args['doc_scores']
assignment = Assignment.objects(id=assignment_id).first()
creator = User.objects(id=user_id).first()
query = Query()
query.content = query_content
query.assignment = assignment
query.doc_scores = doc_scores
query.creator = creator
query.submitted = False
query.save()
return "OK"
def post(self):
check_role('instructor')
args = parser.parse_args()
queries = [q for q in args['query[]'] if q != '']
if not queries:
flash('Empty Query!')
return redirect(url_for('instructorapi'))
ranker = args['ranker']
assignment_name = args['assignment_name']
dataset_name = args['ds_name']
params = self.generate_params_dict(ranker, args['param[]'])
num_results = args['num_results']
instructor = User.objects(email=current_user.email).first()
dataset = DataSet.objects(name=dataset_name).first()
assignment = Assignment(name=assignment_name,
instructor=instructor,
data_set=dataset,
ranker=ranker,
params=params,
num_results=num_results)
try:
assignment.save()
except (NotUniqueError, ValidationError):
flash('Invalid Input!')
return redirect(url_for('instructorapi'))
q = self.generate_queries(queries)
assignment.update(queries=q)
assignment.update(queries_need_to_show=q)
try:
self.search(assignment, dataset_name, queries, ranker, params,
num_results)
except Exception as e:
print(e)
flash('Assignment Created!')
return redirect(url_for('instructorapi'))
def post(self):
args = parser.parse_args()
ds_name = args['ds_name']
ds_privacy = args['ds_privacy']
uploaded_files = request.files.getlist("file")
is_zipfile = \
len(uploaded_files) == 1 and \
uploaded_files[0].filename[-4:] == ".zip"
if is_zipfile:
zipfile = uploaded_files[0]
if not is_zipfile:
err = self._validate_files(uploaded_files)
if err:
return make_response(jsonify(err), 200)
owner = User.objects(id=session["user_id"]).first()
owner_path = self._get_or_init_owner_path()
err, ds_path = self._get_or_init_ds_path(owner_path, ds_name)
if err:
return make_response(jsonify(err), 200)
self._save_dataset_files(uploaded_files, ds_path, is_zipfile)
self._save_dataset_configs(ds_path)
dataset = self._save_dataset_entry(ds_name, owner, ds_privacy)
for fname in os.listdir(ds_path):
document = Document()
document.name = fname
document.dataset = dataset
document.save()
return make_response(
jsonify({"message": "Files have been successfully uploaded"}), 200)
def get(self):
return make_response(
render_template(
'upload_file.html',
author=User.objects(id=session["user_id"]).first()), 200,
{'Content-Type': 'text/html'})
def post(self):
check_role('instructor')
args = parser.parse_args()
ds_name = args['ds_name']
author = User.objects(email=current_user.email).first()
author_dir = os.path.join(current_app.root_path, 'data', author.name)
ds_dir = os.path.join(author_dir, ds_name)
if args['_method'] == 'DELETE':
dataset = DataSet.objects(author=author, name=ds_name).first()
shutil.rmtree(ds_dir)
for doc in Document.objects(data_set=dataset):
doc.delete()
dataset.delete()
if not DataSet.objects(author=author).first():
shutil.rmtree(author_dir)
flash('Dataset deleted.')
return redirect(url_for('instructorapi'))
else:
# check file format
files = request.files.getlist('file')
for f in files:
if not f or not allowed_file(f.filename):
flash('Wrong file format.')
return redirect(url_for('uploadapi'))
# create dataset object
dataset = DataSet(author, ds_name)
try:
dataset.save()
except NotUniqueError:
flash('Dataset name is occupied.')
return redirect(url_for('uploadapi'))
# save documents
if not os.path.exists(author_dir):
os.mkdir(author_dir)
os.mkdir(ds_dir)
for f in files:
filename = secure_filename(f.filename)
f_path = os.path.join(ds_dir, filename)
f.save(f_path)
doc = Document(f.filename, dataset, f_path)
doc.save()
# create config files - copied from guoqiao's gift
if len(os.listdir(ds_dir)) != 0:
file_corpus = open(ds_dir + "/dataset-full-corpus.txt", "w")
file_toml = open(ds_dir + "/file.toml", "w")
file_metadata = open(ds_dir + "/metadata.data", "w")
for file in os.listdir(ds_dir):
if file[-3:] == "txt" and file != "dataset-full-corpus.txt":
file_corpus.write("[None] " + file + "\n")
file_metadata.write(file + " " + file[:-4] + "\n")
file_toml.write("type = \"file-corpus\"" + "\n")
file_toml.write("list = \"dataset\"")
file_corpus.close()
file_toml.close()
file_metadata.close()
flash('Dataset uploaded.')
return redirect(url_for('instructorapi'))
