← Back to branch summary

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

« back to all changes in this revision

Viewing changes to ivle/worksheet.py

  • Committer: chadnickbok
  • Date: 2009-02-02 04:00:25 UTC
  • Revision ID: svn-v4:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:1189
Adding the changes from my genshi branch into trunk.

Most apps now use the Genshi templating engine, in preparation
for future changes to dispatch

Show diffs side-by-side

added added

removed removed

Lines of Context:
ivle/worksheet.py
23
23
This module provides functions for tutorial and worksheet computations.
24
24
"""
25
25
 
26
 
import os.path
27
 
 
28
 
from storm.locals import And, Asc, Desc, Store
29
 
import genshi
30
 
 
 
26
from storm.locals import And, Asc, Desc
31
27
import ivle.database
32
 
from ivle.database import ExerciseAttempt, ExerciseSave, Worksheet, \
33
 
                          WorksheetExercise, Exercise
34
 
import ivle.webapp.tutorial.test
35
28
 
36
 
__all__ = ['ExerciseNotFound', 'get_exercise_status',
37
 
           'get_exercise_stored_text', 'get_exercise_attempts',
38
 
           'get_exercise_attempt', 'test_exercise_submission',
 
29
__all__ = ['get_exercise_status', 'get_exercise_stored_text',
 
30
           'get_exercise_attempts', 'get_exercise_attempt',
39
31
          ]
40
32
 
41
 
class ExerciseNotFound(Exception):
42
 
    pass
43
 
 
44
 
def get_exercise_status(store, user, worksheet_exercise, as_of=None):
 
33
def get_exercise_status(store, user, exercise):
45
34
    """Given a storm.store, User and Exercise, returns information about
46
35
    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.
51
36
    Returns a tuple of:
52
37
        - A boolean, whether they have successfully passed this exercise.
53
38
        - An int, the number of attempts they have made up to and
54
39
          including the first successful attempt (or the total number of
55
40
          attempts, if not yet successful).
56
41
    """
 
42
    ExerciseAttempt = ivle.database.ExerciseAttempt
57
43
    # A Storm expression denoting all active attempts by this user for this
58
44
    # exercise.
59
45
    is_relevant = ((ExerciseAttempt.user_id == user.id) &
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
 
46
                   (ExerciseAttempt.exercise_id == exercise.id) &
 
47
                   (ExerciseAttempt.active == True))
64
48
 
65
49
    # Get the first successful active attempt, or None if no success yet.
66
50
    # (For this user, for this exercise).
82
66
 
83
67
    return first_success is not None, num_attempts
84
68
 
85
 
def get_exercise_stored_text(store, user, worksheet_exercise):
86
 
    """Given a storm.store, User and WorksheetExercise, returns an
 
69
def get_exercise_stored_text(store, user, exercise):
 
70
    """Given a storm.store, User and Exercise, returns an
87
71
    ivle.database.ExerciseSave object for the last saved/submitted attempt for
88
72
    this question (note that ExerciseAttempt is a subclass of ExerciseSave).
89
73
    Returns None if the user has not saved or made an attempt on this
91
75
    If the user has both saved and submitted, it returns whichever was
92
76
    made last.
93
77
    """
 
78
    ExerciseSave = ivle.database.ExerciseSave
 
79
    ExerciseAttempt = ivle.database.ExerciseAttempt
94
80
 
95
81
    # Get the saved text, or None
96
82
    saved = store.find(ExerciseSave,
97
83
                ExerciseSave.user_id == user.id,
98
 
                ExerciseSave.ws_ex_id == worksheet_exercise.id).one()
 
84
                ExerciseSave.exercise_id == exercise.id).one()
99
85
 
100
86
    # Get the most recent attempt, or None
101
87
    attempt = store.find(ExerciseAttempt,
102
88
            ExerciseAttempt.user_id == user.id,
 
89
            ExerciseAttempt.exercise_id == exercise.id,
103
90
            ExerciseAttempt.active == True,
104
 
            ExerciseAttempt.ws_ex_id == worksheet_exercise.id
105
91
        ).order_by(Asc(ExerciseAttempt.date)).last()
106
92
 
107
93
    # Pick the most recent of these two
116
102
        else:
117
103
            return None
118
104
 
119
 
def _get_exercise_attempts(store, user, worksheet_exercise, as_of=None,
 
105
def _get_exercise_attempts(store, user, exercise, as_of=None,
120
106
        allow_inactive=False):
121
107
    """Same as get_exercise_attempts, but doesn't convert Storm's iterator
122
108
    into a list."""
 
109
    ExerciseAttempt = ivle.database.ExerciseAttempt
123
110
 
124
111
    # Get the most recent attempt before as_of, or None
125
112
    return store.find(ExerciseAttempt,
126
113
            ExerciseAttempt.user_id == user.id,
127
 
            ExerciseAttempt.ws_ex_id == worksheet_exercise.id,
 
114
            ExerciseAttempt.exercise_id == exercise.id,
128
115
            True if allow_inactive else ExerciseAttempt.active == True,
129
116
            True if as_of is None else ExerciseAttempt.date <= as_of,
130
117
        ).order_by(Desc(ExerciseAttempt.date))
131
118
 
132
 
def get_exercise_attempts(store, user, worksheet_exercise, as_of=None,
 
119
def get_exercise_attempts(store, user, exercise, as_of=None,
133
120
        allow_inactive=False):
134
121
    """Given a storm.store, User and Exercise, returns a list of
135
122
    ivle.database.ExerciseAttempt objects, one for each attempt made for the
139
126
        attempts made before or at this time.
140
127
    allow_inactive: If True, will return disabled attempts.
141
128
    """
142
 
    return list(_get_exercise_attempts(store, user, worksheet_exercise, as_of,
 
129
    return list(_get_exercise_attempts(store, user, exercise, as_of,
143
130
        allow_inactive))
144
131
 
145
 
def get_exercise_attempt(store, user, worksheet_exercise, as_of=None,
 
132
def get_exercise_attempt(store, user, exercise, as_of=None,
146
133
        allow_inactive=False):
147
 
    """Given a storm.store, User and WorksheetExercise, returns an
 
134
    """Given a storm.store, User and Exercise, returns an
148
135
    ivle.database.ExerciseAttempt object for the last submitted attempt for
149
136
    this question.
150
137
    Returns None if the user has not made an attempt on this
154
141
        attempts made before or at this time.
155
142
    allow_inactive: If True, will return disabled attempts.
156
143
    """
157
 
    return _get_exercise_attempts(store, user, worksheet_exercise, as_of,
 
144
    return _get_exercise_attempts(store, user, exercise, as_of,
158
145
        allow_inactive).first()
159
146
 
160
 
def save_exercise(store, user, worksheet_exercise, text, date):
 
147
def save_exercise(store, user, exercise, text, date):
161
148
    """Save an exercise for a user.
162
149
 
163
 
    Given a store, User, WorksheetExercise, text and date, save the text to the
 
150
    Given a store, User, Exercise and text and date, save the text to the
164
151
    database. This will create the ExerciseSave if needed.
165
152
    """
166
153
    saved = store.find(ivle.database.ExerciseSave,
167
154
                ivle.database.ExerciseSave.user_id == user.id,
168
 
                ivle.database.ExerciseSave.ws_ex_id == worksheet_exercise.id
169
 
                ).one()
 
155
                ivle.database.ExerciseSave.exercise_id == exercise.id).one()
170
156
    if saved is None:
171
 
        saved = ivle.database.ExerciseSave(user=user, 
172
 
                                        worksheet_exercise=worksheet_exercise)
 
157
        saved = ivle.database.ExerciseSave(user=user, exercise=exercise)
173
158
        store.add(saved)
174
159
 
175
160
    saved.date = date
176
161
    saved.text = text
177
162
 
178
 
def calculate_score(store, user, worksheet, as_of=None):
 
163
def calculate_score(store, user, worksheet):
179
164
    """
180
165
    Given a storm.store, User, Exercise and Worksheet, calculates a score for
181
166
    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.
186
167
    Returns a 4-tuple of ints, consisting of:
187
168
    (No. mandatory exercises completed,
188
169
     Total no. mandatory exercises,
197
178
    # Get the student's pass/fail for each exercise in this worksheet
198
179
    for worksheet_exercise in worksheet.worksheet_exercises:
199
180
        exercise = worksheet_exercise.exercise
200
 
        worksheet = worksheet_exercise.worksheet
201
181
        optional = worksheet_exercise.optional
202
182
 
203
 
        done, _ = get_exercise_status(store, user, worksheet_exercise, as_of)
 
183
        done, _ = get_exercise_status(store, user, exercise)
204
184
        # done is a bool, whether this student has completed that problem
205
185
        if optional:
206
186
            opt_total += 1
210
190
            if done: mand_done += 1
211
191
 
212
192
    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