← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to ivle/worksheet/utils.py

  • Committer: William Grant
  • Date: 2010-02-15 08:49:58 UTC
  • Revision ID: grantw@unimelb.edu.au-20100215084958-8x5dzd9k4pbcddlz
Split subject/semester management out onto a separate page, and link to SemesterEdit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/worksheet/utils.py
23
23
This module provides functions for tutorial and worksheet computations.
24
24
"""
25
25
 
26
 
from storm.locals import And, Asc, Desc
 
26
import os.path
 
27
 
 
28
from storm.locals import And, Asc, Desc, Store
 
29
import genshi
 
30
 
27
31
import ivle.database
 
32
from ivle.database import ExerciseAttempt, ExerciseSave, Worksheet, \
 
33
                          WorksheetExercise, Exercise
 
34
import ivle.webapp.tutorial.test
28
35
 
29
 
__all__ = ['get_exercise_status', 'get_exercise_stored_text',
30
 
           'get_exercise_attempts', 'get_exercise_attempt',
 
36
__all__ = ['ExerciseNotFound', 'get_exercise_status',
 
37
           'get_exercise_stored_text', 'get_exercise_attempts',
 
38
           'get_exercise_attempt', 'test_exercise_submission',
31
39
          ]
32
40
 
33
 
def get_exercise_status(store, user, exercise):
 
41
class ExerciseNotFound(Exception):
 
42
    pass
 
43
 
 
44
def get_exercise_status(store, user, worksheet_exercise, as_of=None):
34
45
    """Given a storm.store, User and Exercise, returns information about
35
46
    the user's performance on that problem.
 
47
    @param store: A storm.store
 
48
    @param user: A User.
 
49
    @param worksheet_exercise: An Exercise.
 
50
    @param as_of: Optional datetime. If supplied, gets the status as of as_of.
36
51
    Returns a tuple of:
37
52
        - A boolean, whether they have successfully passed this exercise.
38
53
        - An int, the number of attempts they have made up to and
39
54
          including the first successful attempt (or the total number of
40
55
          attempts, if not yet successful).
41
56
    """
42
 
    ExerciseAttempt = ivle.database.ExerciseAttempt
43
57
    # A Storm expression denoting all active attempts by this user for this
44
58
    # exercise.
45
59
    is_relevant = ((ExerciseAttempt.user_id == user.id) &
46
 
                   (ExerciseAttempt.exercise_id == exercise.id) &
47
 
                   (ExerciseAttempt.active == True))
 
60
            (ExerciseAttempt.ws_ex_id == worksheet_exercise.id) &
 
61
            (ExerciseAttempt.active == True))
 
62
    if as_of is not None:
 
63
        is_relevant &= ExerciseAttempt.date <= as_of
48
64
 
49
65
    # Get the first successful active attempt, or None if no success yet.
50
66
    # (For this user, for this exercise).
66
82
 
67
83
    return first_success is not None, num_attempts
68
84
 
69
 
def get_exercise_stored_text(store, user, exercise):
70
 
    """Given a storm.store, User and Exercise, returns an
 
85
def get_exercise_stored_text(store, user, worksheet_exercise):
 
86
    """Given a storm.store, User and WorksheetExercise, returns an
71
87
    ivle.database.ExerciseSave object for the last saved/submitted attempt for
72
88
    this question (note that ExerciseAttempt is a subclass of ExerciseSave).
73
89
    Returns None if the user has not saved or made an attempt on this
75
91
    If the user has both saved and submitted, it returns whichever was
76
92
    made last.
77
93
    """
78
 
    ExerciseSave = ivle.database.ExerciseSave
79
 
    ExerciseAttempt = ivle.database.ExerciseAttempt
80
94
 
81
95
    # Get the saved text, or None
82
96
    saved = store.find(ExerciseSave,
83
97
                ExerciseSave.user_id == user.id,
84
 
                ExerciseSave.exercise_id == exercise.id).one()
 
98
                ExerciseSave.ws_ex_id == worksheet_exercise.id).one()
85
99
 
86
100
    # Get the most recent attempt, or None
87
101
    attempt = store.find(ExerciseAttempt,
88
102
            ExerciseAttempt.user_id == user.id,
89
 
            ExerciseAttempt.exercise_id == exercise.id,
90
103
            ExerciseAttempt.active == True,
 
104
            ExerciseAttempt.ws_ex_id == worksheet_exercise.id
91
105
        ).order_by(Asc(ExerciseAttempt.date)).last()
92
106
 
93
107
    # Pick the most recent of these two
102
116
        else:
103
117
            return None
104
118
 
105
 
def _get_exercise_attempts(store, user, exercise, as_of=None,
 
119
def _get_exercise_attempts(store, user, worksheet_exercise, as_of=None,
106
120
        allow_inactive=False):
107
121
    """Same as get_exercise_attempts, but doesn't convert Storm's iterator
108
122
    into a list."""
109
 
    ExerciseAttempt = ivle.database.ExerciseAttempt
110
123
 
111
124
    # Get the most recent attempt before as_of, or None
112
125
    return store.find(ExerciseAttempt,
113
126
            ExerciseAttempt.user_id == user.id,
114
 
            ExerciseAttempt.exercise_id == exercise.id,
 
127
            ExerciseAttempt.ws_ex_id == worksheet_exercise.id,
115
128
            True if allow_inactive else ExerciseAttempt.active == True,
116
129
            True if as_of is None else ExerciseAttempt.date <= as_of,
117
130
        ).order_by(Desc(ExerciseAttempt.date))
118
131
 
119
 
def get_exercise_attempts(store, user, exercise, as_of=None,
 
132
def get_exercise_attempts(store, user, worksheet_exercise, as_of=None,
120
133
        allow_inactive=False):
121
134
    """Given a storm.store, User and Exercise, returns a list of
122
135
    ivle.database.ExerciseAttempt objects, one for each attempt made for the
126
139
        attempts made before or at this time.
127
140
    allow_inactive: If True, will return disabled attempts.
128
141
    """
129
 
    return list(_get_exercise_attempts(store, user, exercise, as_of,
 
142
    return list(_get_exercise_attempts(store, user, worksheet_exercise, as_of,
130
143
        allow_inactive))
131
144
 
132
 
def get_exercise_attempt(store, user, exercise, as_of=None,
 
145
def get_exercise_attempt(store, user, worksheet_exercise, as_of=None,
133
146
        allow_inactive=False):
134
 
    """Given a storm.store, User and Exercise, returns an
 
147
    """Given a storm.store, User and WorksheetExercise, returns an
135
148
    ivle.database.ExerciseAttempt object for the last submitted attempt for
136
149
    this question.
137
150
    Returns None if the user has not made an attempt on this
141
154
        attempts made before or at this time.
142
155
    allow_inactive: If True, will return disabled attempts.
143
156
    """
144
 
    return _get_exercise_attempts(store, user, exercise, as_of,
 
157
    return _get_exercise_attempts(store, user, worksheet_exercise, as_of,
145
158
        allow_inactive).first()
146
159
 
147
 
def save_exercise(store, user, exercise, text, date):
 
160
def save_exercise(store, user, worksheet_exercise, text, date):
148
161
    """Save an exercise for a user.
149
162
 
150
 
    Given a store, User, Exercise and text and date, save the text to the
 
163
    Given a store, User, WorksheetExercise, text and date, save the text to the
151
164
    database. This will create the ExerciseSave if needed.
152
165
    """
153
166
    saved = store.find(ivle.database.ExerciseSave,
154
167
                ivle.database.ExerciseSave.user_id == user.id,
155
 
                ivle.database.ExerciseSave.exercise_id == exercise.id).one()
 
168
                ivle.database.ExerciseSave.ws_ex_id == worksheet_exercise.id
 
169
                ).one()
156
170
    if saved is None:
157
 
        saved = ivle.database.ExerciseSave(user=user, exercise=exercise)
 
171
        saved = ivle.database.ExerciseSave(user=user, 
 
172
                                        worksheet_exercise=worksheet_exercise)
158
173
        store.add(saved)
159
174
 
160
175
    saved.date = date
161
176
    saved.text = text
162
177
 
163
 
def calculate_score(store, user, worksheet):
 
178
def calculate_score(store, user, worksheet, as_of=None):
164
179
    """
165
180
    Given a storm.store, User, Exercise and Worksheet, calculates a score for
166
181
    the user on the given worksheet.
 
182
    @param store: A storm.store
 
183
    @param user: A User.
 
184
    @param worksheet: A Worksheet.
 
185
    @param as_of: Optional datetime. If supplied, gets the score as of as_of.
167
186
    Returns a 4-tuple of ints, consisting of:
168
187
    (No. mandatory exercises completed,
169
188
     Total no. mandatory exercises,
178
197
    # Get the student's pass/fail for each exercise in this worksheet
179
198
    for worksheet_exercise in worksheet.worksheet_exercises:
180
199
        exercise = worksheet_exercise.exercise
 
200
        worksheet = worksheet_exercise.worksheet
181
201
        optional = worksheet_exercise.optional
182
202
 
183
 
        done, _ = get_exercise_status(store, user, exercise)
 
203
        done, _ = get_exercise_status(store, user, worksheet_exercise, as_of)
184
204
        # done is a bool, whether this student has completed that problem
185
205
        if optional:
186
206
            opt_total += 1
190
210
            if done: mand_done += 1
191
211
 
192
212
    return mand_done, mand_total, opt_done, opt_total
 
213
 
 
214
def calculate_mark(mand_done, mand_total):
 
215
    """Calculate a subject mark, given the result of all worksheets.
 
216
    @param mand_done: The total number of mandatory exercises completed by
 
217
        some student, across all worksheets.
 
218
    @param mand_total: The total number of mandatory exercises across all
 
219
        worksheets in the offering.
 
220
    @return: (percent, mark, mark_total)
 
221
        percent: The percentage of exercises the student has completed, as an
 
222
            integer between 0 and 100 inclusive.
 
223
        mark: The mark the student has received, based on the percentage.
 
224
        mark_total: The total number of marks available (currently hard-coded
 
225
            as 5).
 
226
    """
 
227
    # We want to display a students mark out of 5. However, they are
 
228
    # allowed to skip 1 in 5 questions and still get 'full marks'.
 
229
    # Hence we divide by 16, essentially making 16 percent worth
 
230
    # 1 star, and 80 or above worth 5.
 
231
    if mand_total > 0:
 
232
        percent_int = (100 * mand_done) // mand_total
 
233
    else:
 
234
        # Avoid Div0, just give everyone 0 marks if there are none available
 
235
        percent_int = 0
 
236
    # percent / 16, rounded down, with a maximum mark of 5
 
237
    max_mark = 5
 
238
    mark = min(percent_int // 16, max_mark)
 
239
    return (percent_int, mark, max_mark)
 
240
 
 
241
def update_exerciselist(worksheet):
 
242
    """Runs through the worksheetstream, generating the appropriate
 
243
    WorksheetExercises, and de-activating the old ones."""
 
244
    exercises = []
 
245
    # Turns the worksheet into an xml stream, and then finds all the 
 
246
    # exercise nodes in the stream.
 
247
    worksheetdata = genshi.XML(worksheet.get_xml())
 
248
    for kind, data, pos in worksheetdata:
 
249
        if kind is genshi.core.START:
 
250
            # Data is a tuple of tag name and a list of name->value tuples
 
251
            if data[0] == 'exercise':
 
252
                src = ""
 
253
                optional = False
 
254
                for attr in data[1]:
 
255
                    if attr[0] == 'src':
 
256
                        src = attr[1]
 
257
                    if attr[0] == 'optional':
 
258
                        optional = attr[1] == 'true'
 
259
                if src != "":
 
260
                    exercises.append((src, optional))
 
261
    ex_num = 0
 
262
    # Set all current worksheet_exercises to be inactive
 
263
    db_worksheet_exercises = Store.of(worksheet).find(WorksheetExercise,
 
264
        WorksheetExercise.worksheet_id == worksheet.id)
 
265
    for worksheet_exercise in db_worksheet_exercises:
 
266
        worksheet_exercise.active = False
 
267
    
 
268
    for exerciseid, optional in exercises:
 
269
        worksheet_exercise = Store.of(worksheet).find(WorksheetExercise,
 
270
            WorksheetExercise.worksheet_id == worksheet.id,
 
271
            Exercise.id == WorksheetExercise.exercise_id,
 
272
            Exercise.id == exerciseid).one()
 
273
        if worksheet_exercise is None:
 
274
            exercise = Store.of(worksheet).find(Exercise,
 
275
                Exercise.id == exerciseid
 
276
            ).one()
 
277
            if exercise is None:
 
278
                raise ExerciseNotFound(exerciseid)
 
279
            worksheet_exercise = WorksheetExercise()
 
280
            worksheet_exercise.worksheet_id = worksheet.id
 
281
            worksheet_exercise.exercise_id = exercise.id
 
282
            Store.of(worksheet).add(worksheet_exercise)
 
283
        worksheet_exercise.active = True
 
284
        worksheet_exercise.seq_no = ex_num
 
285
        worksheet_exercise.optional = optional
 
286
 
 
287
 
 
288
def test_exercise_submission(config, user, exercise, code):
 
289
    """Test the given code against an exercise.
 
290
 
 
291
    The code is run in a console process as the provided user.
 
292
    """
 
293
    # Start a console to run the tests on
 
294
    jail_path = os.path.join(config['paths']['jails']['mounts'],
 
295
                             user.login)
 
296
    working_dir = os.path.join("/home", user.login)
 
297
    cons = ivle.console.Console(config, user.unixid, jail_path,
 
298
                                working_dir)
 
299
 
 
300
    # Parse the file into a exercise object using the test suite
 
301
    exercise_obj = ivle.webapp.tutorial.test.parse_exercise_file(
 
302
        exercise, cons)
 
303
 
 
304
    # Run the test cases. Get the result back as a JSONable object.
 
305
    # Return it.
 
306
    test_results = exercise_obj.run_tests(code)
 
307
 
 
308
    # Close the console
 
309
    cons.close()
 
310
 
 
311
    return test_results
 
312
 
 
313
 
 
314
class FakeWorksheetForMarks:
 
315
    """This class represents a worksheet and a particular students progress
 
316
    through it.
 
317
    
 
318
    Do not confuse this with a worksheet in the database. This worksheet
 
319
    has extra information for use in the output, such as marks."""
 
320
    def __init__(self, id, name, assessable):
 
321
        self.id = id
 
322
        self.name = name
 
323
        self.assessable = assessable
 
324
        self.complete_class = ''
 
325
        self.optional_message = ''
 
326
        self.total = 0
 
327
        self.mand_done = 0
 
328
    def __repr__(self):
 
329
        return ("Worksheet(id=%s, name=%s, assessable=%s)"
 
330
                % (repr(self.id), repr(self.name), repr(self.assessable)))
 
331
 
 
332
 
 
333
# XXX: This really shouldn't be needed.
 
334
def create_list_of_fake_worksheets_and_stats(store, user, offering):
 
335
    """Take an offering's real worksheets, converting them into stats.
 
336
 
 
337
    The worksheet listing views expect special fake worksheet objects
 
338
    that contain counts of exercises, whether they've been completed,
 
339
    that sort of thing. A fake worksheet object is used to contain
 
340
    these values, because nobody has managed to refactor the need out
 
341
    yet.
 
342
    """
 
343
    new_worksheets = []
 
344
    problems_done = 0
 
345
    problems_total = 0
 
346
 
 
347
    # Offering.worksheets is ordered by the worksheets seq_no
 
348
    for worksheet in offering.worksheets:
 
349
        new_worksheet = FakeWorksheetForMarks(
 
350
            worksheet.identifier, worksheet.name, worksheet.assessable)
 
351
        if new_worksheet.assessable:
 
352
            # Calculate the user's score for this worksheet
 
353
            mand_done, mand_total, opt_done, opt_total = (
 
354
                ivle.worksheet.utils.calculate_score(store, user, worksheet))
 
355
            if opt_total > 0:
 
356
                optional_message = " (excluding optional exercises)"
 
357
            else:
 
358
                optional_message = ""
 
359
            if mand_done >= mand_total:
 
360
                new_worksheet.complete_class = "complete"
 
361
            elif mand_done > 0:
 
362
                new_worksheet.complete_class = "semicomplete"
 
363
            else:
 
364
                new_worksheet.complete_class = "incomplete"
 
365
            problems_done += mand_done
 
366
            problems_total += mand_total
 
367
            new_worksheet.mand_done = mand_done
 
368
            new_worksheet.total = mand_total
 
369
            new_worksheet.optional_message = optional_message
 
370
        new_worksheets.append(new_worksheet)
 
371
 
 
372
    return new_worksheets, problems_total, problems_done