Draft: Refactor models/logic code

app/models/__init__.py

@@ -0,0 +1,8 @@
+from .assignment import Assignment
+from .question import Question
+from .batch_response import BatchResponse
+from .batch import Batch
+from .response import Response
+from .datatype import Datatype
+from .student import Student
+from .submission import Submission

app/models/assignment.py

@@ -0,0 +1,28 @@
+from app import db
+
+class Assignment(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(80), unique=True, nullable=False)
+    folder_name = db.Column(db.String(80), unique=True, nullable=False)
+
+    questions = db.relationship('Question', backref='assignment', lazy=True, cascade='all,delete')
+    responses = db.relationship('Response', backref='assignment', lazy=True, cascade='all,delete')
+    submissions = db.relationship('Submission', backref='assignment', lazy=True, cascade='all,delete')
+
+    def total_points(self):
+        points = [question.max_grade for question in self.questions]
+        return sum(points)
+
+    def total_submissions(self):
+        return len(self.submissions)
+
+    def total_questions(self):
+        return len(self.questions)
+
+    def to_dict(self):
+        return {'id': self.id,
+                'name': self.name,
+                'folder_name': self.folder_name,
+                'total_points': self.total_points(),
+                'total_questions': self.total_questions(),
+                'total_submissions': self.total_submissions()}

app/models/batch.py

@@ -0,0 +1,54 @@
+from app import db
+
+class Batch(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    grade = db.Column(db.Integer)
+    comments = db.Column(db.String(280))
+    next_id = db.Column(db.Integer)
+    previous_id = db.Column(db.Integer)
+
+    question_id = db.Column(db.Integer, db.ForeignKey('question.id'), nullable=False)
+    datatype_id = db.Column(db.Integer, db.ForeignKey('datatype.id'), nullable=False)
+    batch_responses = db.relationship('BatchResponse', backref='batch', lazy=True, cascade='all,delete')
+
+    def total_responses(self):
+        return len(self.batch_responses)
+
+    def get_fullfile(self):
+        return self.batch_responses[0].response.get_fullfile()
+
+    def get_data(self):
+        return self.batch_responses[0].response.get_data()
+
+    def to_dict(self):
+        from ..selectors.datatype import get_datatype_name
+
+        datatype = get_datatype_name(self.datatype_id)
+        if self.question.preprocessing:
+            fun = self.question.get_preprocessing()
+            try:
+                data = fun(self.batch_responses[0].response.student_id,self.get_data())
+            except:
+                data = self.get_data()
+        else:
+            data = self.get_data()
+        if datatype == 'figure':
+            dataJSON = []
+            for line in data:
+                if line.size == 2:
+                    dataJSON.append(line.tolist())
+                else:
+                    dataJSON.append({'x': line[:,0].tolist(),'y': line[:,1].tolist()})
+        else:
+            dataJSON = str(data)
+        return {'id': self.id,
+                'grade': self.grade,
+                'comments': self.comments,
+                'question_id': self.question_id,
+                'assignment_id': self.question.assignment.id,
+                'datatype': datatype,
+                'total_batch_responses': self.total_responses(),
+                'total_question_responses': self.question.total_responses(),
+                'next_id': self.next_id,
+                'previous_id': self.previous_id,
+                'data': dataJSON}

app/models/batch_response.py

@@ -0,0 +1,9 @@
+from app import db
+
+
+class BatchResponse(db.Model):
+    response_id = db.Column(db.Integer, db.ForeignKey('response.id'), primary_key=True)
+    batch_id = db.Column(db.Integer, db.ForeignKey('batch.id'), primary_key=True)
+    status = db.Column(db.String(140))
+
+    response = db.relationship('Response', backref='batch_responses', lazy=True)

app/models/datatype.py

@@ -0,0 +1,10 @@
+from app import db
+
+
+class Datatype(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(80), nullable=False)
+    extension = db.Column(db.String(10), nullable=False)
+
+    batches = db.relationship('Batch', backref='datatype', lazy=True)
+    responses = db.relationship('Response', backref='datatype', lazy=True)

app/models/question.py

@@ -0,0 +1,41 @@
+from app import db
+import importlib
+
+
+class Question(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(80), nullable=False)
+    var_name = db.Column(db.String(80), nullable=False)
+    alt_var_name = db.Column(db.String(80), nullable=False)
+    max_grade = db.Column(db.Integer, default=0)
+    tolerance = db.Column(db.Float, default=0.001)
+    preprocessing = db.Column(db.String(280))
+
+    assignment_id = db.Column(db.Integer, db.ForeignKey('assignment.id'), nullable=False)
+    batches = db.relationship('Batch', backref='question', lazy=True, cascade='all,delete')
+
+    def get_preprocessing(self):
+        f = open('preprocessing_module.py','w')
+        f.write(self.preprocessing)
+        f.close()
+        import preprocessing_module
+        importlib.reload(preprocessing_module)
+        os.remove('preprocessing_module.py')
+        return preprocessing_module.fun
+
+    def total_batches(self):
+        return len(self.batches)
+
+    def total_responses(self):
+        return sum([len(batch.batch_responses) for batch in self.batches])
+
+    def to_dict(self):
+        return {'id': self.id,
+                'name': self.name,
+                'var_name': self.var_name,
+                'alt_var_name': self.alt_var_name,
+                'max_grade': self.max_grade,
+                'tolerance': self.tolerance,
+                'assignment_id': self.assignment_id,
+                'total_batches': self.total_batches(),
+                'total_responses': self.total_responses()}

app/models/response.py

@@ -0,0 +1,52 @@
+from pathlib import Path
+import numpy as np
+from app import db
+
+
+class Response(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    var_name = db.Column(db.String(80), nullable=False)
+
+    student_id = db.Column(db.Integer, db.ForeignKey('student.id'), nullable=False)
+    datatype_id = db.Column(db.Integer, db.ForeignKey('datatype.id'), nullable=False)
+    assignment_id = db.Column(db.Integer, db.ForeignKey('assignment.id'), nullable=False)
+
+    def get_fullfile(self):
+        submission_folder = Path("submissions/")
+        assignment_folder = Assignment.query.get(self.assignment_id).folder_name
+        student_folder = str(self.student_id)
+        response_file = f"{self.var_name}.{self.datatype.extension}"
+        return submission_folder / assignment_folder / student_folder / response_file
+
+    def get_data(self):
+        dtype = self.datatype.name
+        filename = self.get_fullfile()
+        if dtype in ['numeric','logical']:
+            f = open(filename,'r')
+            data = f.read()
+            f.close()
+            if 'i' in data:
+                data = data.replace('i','j')
+                dtype = complex
+            else:
+                dtype = float
+            tmp = Path("app") / "tmp.txt"
+            file = open(tmp,'w')
+            file.write(data)
+            file.close()
+            data = np.loadtxt(tmp,delimiter=',',ndmin=2,dtype=dtype)
+            if data.size == 1:
+                data = data.flat[0]
+            os.remove(tmp)
+        elif dtype == 'figure':
+            f = open(filename,'r')
+            data = f.read()
+            f.close()
+            data = json.loads(data)
+            Lines = data['Lines']
+            data = [np.array(Lines[n],dtype=float) for n in range(0,len(Lines))]
+        else:
+            f = open(filename)
+            data = f.read()
+            f.close()
+        return data

app/models/student.py

@@ -0,0 +1,6 @@
+from app import db
+
+
+class Student(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    responses = db.relationship('Response', backref='student', lazy=True)

app/models/submission.py

@@ -0,0 +1,9 @@
+from app import db
+
+class Submission(db.Model):
+    grade = db.Column(db.Integer)
+    feedback = db.Column(db.String(280))
+
+    assignment_id = db.Column(db.Integer, db.ForeignKey('assignment.id'), primary_key=True)
+    student_id = db.Column(db.Integer, db.ForeignKey('student.id'), primary_key=True)
+    student = db.relationship('Student', backref='submissions', lazy=True)