10230191976

Committed 03 Aug 2024 06:45PM UTC coverage: 51.274%. Remained the same

Build # 10230191976

Build Type

push

github

Committed by

web-flow

Commit Message

Add lots of docstrings (#52)

Models
- [X] `assignments/models.py`
- [x] `courses/models.py`
- [x] `venvs/models.py`
- [x] `submissions/models.py`
- [x] `users/models.py`

Views
- [x] `assignments/views.py`
- [x] `courses/views.py`
- [X] `submissions/views.py`
- [x] `venvs/views.py`
- [x] `errors/views.py`
- [x] `auth/views.py`
- [x] `docs/views.py`

Run Details

277 of 885 branches covered (31.3%)

Branch coverage included in aggregate %.

13 of 13 new or added lines in 4 files covered. (100.0%)

31 existing lines in 9 files now uncovered.

1494 of 2569 relevant lines covered (58.15%)

0.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

35.6

/tin/apps/submissions/views.py

from __future__ import annotations

import psutil
from django import http
from django.db.models import F, Q
from django.shortcuts import get_object_or_404, redirect, render
from django.utils import timezone
from django.utils.http import url_has_allowed_host_and_scheme

from ..auth.decorators import login_required, superuser_required, teacher_or_superuser_required
from .forms import CommentForm, FilterForm
from .models import Comment, Submission
from .utils import serialize_submission_info

# Create your views here.


@login_required
def show_view(request, submission_id):
    """Show a submission

    Args:
        request: The request
        submission_id: An instance of the :class:`.Submission` model
    """
    submission = get_object_or_404(
        Submission.objects.filter_visible(request.user), id=submission_id
    )

    submissions = Submission.objects.filter(
        student=submission.student, assignment=submission.assignment
    )

    before_submissions = submissions.filter(id__lt=submission.id)
    submission_number = before_submissions.count() + 1

    context = {
        "course": submission.assignment.course,
        "folder": submission.assignment.folder,
        "assignment": submission.assignment,
        "submission": submission,
        "submission_number": submission_number,
        "submission_text": submission.file_text,
        "submission_comments": submission.comments.all(),
        "submissions": submissions.order_by("-date_submitted"),
        "is_student": submission.assignment.course.is_student_in_course(request.user),
        "is_teacher": request.user in submission.assignment.course.teacher.all(),
    }

    if request.user.is_teacher or request.user.is_superuser:
        context["student"] = submission.student

    return render(request, "submissions/show.html", context)


@login_required
def show_json_view(request, submission_id):
    """Get a JSON response about the information of a submission

    Args:
        request: The request
        submission_id: An instance of the :class:`.Submission` model
    """
    try:
        submission = Submission.objects.filter_visible(request.user).get(id=submission_id)
    except Submission.DoesNotExist:
        return http.JsonResponse({"error": "Submission not found"})

    return http.JsonResponse(serialize_submission_info(submission, request.user))


@login_required
def download_view(request, submission_id):
    """Download a submission

    Args:
        request: The request
        submission_id: An instance of the :class:`.Submission` model
    """
    submission = get_object_or_404(
        Submission.objects.filter_visible(request.user), id=submission_id
    )

    file_with_header = submission.file_text_with_header
    language = "P" if submission.assignment.filename.endswith(".py") else "J"
    extension = "java" if language == "J" else "py"
    username = submission.student.username

    response = http.HttpResponse(file_with_header, content_type="text/plain")
    response["Content-Disposition"] = f'attachment; filename="{username}.{extension}"'
    return response


@login_required
def kill_view(request, submission_id):
    """Kill a submission

    Args:
        request: The request
        submission_id: An instance of the :class:`.Submission` model
    """
    submissions_editable = Submission.objects.filter(
        Q(assignment__course__teacher=request.user) | Q(student=request.user)
    )
    submission = get_object_or_404(submissions_editable, id=submission_id)

    if request.method == "POST":
        submission.kill_requested = True
        submission.save()
        next_url = request.GET.get("next")
        if next_url and url_has_allowed_host_and_scheme(next_url, allowed_hosts=None):
            return redirect(next_url)
        else:
            return redirect("submissions:show", submission.id)
    else:
        raise http.Http404


@teacher_or_superuser_required
def rerun_view(request, submission_id):
    """Rerun a submission

    Args:
        request: The request
        submission_id: An instance of the :class:`.Submission` model
    """
    submission = get_object_or_404(
        Submission.objects.filter_visible(request.user), id=submission_id
    )

    submission.rerun().apply_async()
    return redirect("submissions:show", submission.id)


@teacher_or_superuser_required
def comment_view(request, submission_id):
    """Comment on a submission

    Args:
        request: The request
        submission_id: An instance of the :class:`.Submission` model
    """
    if request.method != "POST":
        raise http.Http404

    submission = get_object_or_404(
        Submission.objects.filter_editable(request.user), id=submission_id
    )

    if not submission.complete or not submission.has_been_graded:
        raise http.Http404

    comment = request.POST.get("comment", "")
    point_override = request.POST.get("point_override", "")
    comment = Comment(
        submission=submission,
        author=request.user,
        start_char=0,
        end_char=len(submission.file_text),
        text=comment,
        point_override=point_override,
    )
    comment.save()

    submission.publish()

    return redirect("submissions:show", submission.id)


@teacher_or_superuser_required
def edit_comment_view(request, submission_id, comment_id):
    """Edit a comment on a submission

    Args:
        request: The request
        submission_id: An instance of the :class:`.Submission` model
        comment_id: An instance of the :class:`.Comment` model
    """
    submission = get_object_or_404(
        Submission.objects.filter_editable(request.user), id=submission_id
    )
    comment = get_object_or_404(submission.comments.all(), id=comment_id)
    assignment = submission.assignment

    if request.method == "POST":
        form = CommentForm(request.POST, instance=comment)
        if form.is_valid():
            form.save()
            return redirect("submissions:show", submission.id)

    before_submissions = Submission.objects.filter(
        student=submission.student, assignment=submission.assignment, id__lt=submission.id
    )
    submission_number = before_submissions.count() + 1

    form = CommentForm(instance=comment)
    context = {
        "form": form,
        "nav_item": "Edit comment",
        "course": assignment.course,
        "folder": assignment.folder,
        "assignment": assignment,
        "submission": submission,
        "comment": comment,
        "submission_number": submission_number,
    }

    return render(request, "submissions/edit_comment.html", context=context)


@teacher_or_superuser_required
def delete_comment_view(request, submission_id, comment_id):
    """Delete a comment

    Args:
        request: The request
        submission_id: An instance of the :class:`.Submission` model
        comment_id: An instance of the :class:`.Comment` model
    """
    submission = get_object_or_404(
        Submission.objects.filter_editable(request.user), id=submission_id
    )
    comment = get_object_or_404(submission.comments.all(), id=comment_id)
    course = submission.assignment.course

    if not course.teacher.filter(id=request.user.id).exists() and not request.user.is_superuser:
        raise http.Http404

    comment.delete()
    return redirect("submissions:show", submission.id)


@teacher_or_superuser_required
def publish_view(request, submission_id):
    """Publish a submission

    Args:
        request: The request
        submission_id: An instance of the :class:`.Submission` model
    """
    submission = get_object_or_404(
        Submission.objects.filter_editable(request.user), id=submission_id
    )

    submission.publish()
    return redirect("submissions:show", submission.id)


@teacher_or_superuser_required
def unpublish_view(request, submission_id):
    """Unpublish a submission

    Args:
        request: The request
        submission_id: An instance of the :class:`.Submission` model
    """
    submission = get_object_or_404(
        Submission.objects.filter_editable(request.user), id=submission_id
    )

    submission.unpublish()
    return redirect("submissions:show", submission.id)


@teacher_or_superuser_required
def filter_view(request):
    """Search through submissions based on a filter.

    Args:
        request: The request
    """
    if request.method == "POST":
        filter_form = FilterForm(request.POST)
        if filter_form.is_valid():
            queryset = filter_form.get_results()

            if "list_submissions" in request.POST:
                return render(
                    request,
                    "submissions/filter.html",
                    {
                        "form": filter_form,
                        "submissions": queryset,
                        "action": "show",
                        "nav_item": "Filter submissions",
                    },
                )
            elif "view_code" in request.POST:
                submission_texts = []
                for submission in queryset:
                    submission_texts.append(submission.file_text)

                return render(
                    request,
                    "submissions/filter.html",
                    {
                        "form": filter_form,
                        "submissions": list(zip(queryset, submission_texts)),
                        "action": "show_code",
                        "nav_item": "Filter submissions",
                    },
                )

    filter_form = FilterForm()

    return render(
        request,
        "submissions/filter.html",
        {
            "form": filter_form,
            "submissions": Submission.objects.none(),
            "action": "filter",
            "nav_item": "Filter submissions",
        },
    )


@superuser_required
def set_aborted_complete_view(request):
    """Check if a submission is running.

    This also marks all non-running incomplete submissions
    as completed.

    Args:
        request: The request
    """
    if request.method == "POST":
        submissions = Submission.objects.filter(complete=False, grader_pid__isnull=False)

        for submission in submissions:
            try:
                psutil.Process(submission.grader_pid)
            except psutil.NoSuchProcess:
                submission.complete = True
                submission.save(update_fields=["complete"])

    return redirect("auth:index")


@superuser_required
def set_past_timeout_complete_view(request):
    """Update submissions based off the time limit

    If it has exceeded its time limit, marks it as complete

    Args:
        request: The request
    """
    if request.method == "POST":
        Submission.objects.filter(
            complete=False,
            grader_start_time__isnull=False,
            assignment__enable_grader_timeout=True,
            grader_start_time__lte=timezone.localtime().timestamp()
            - F("assignment__grader_timeout"),
        ).update(complete=True)

    return redirect("auth:index")

1	from __future__ import annotations	1✔
2
3	import psutil	1✔
4	from django import http	1✔
5	from django.db.models import F, Q	1✔
6	from django.shortcuts import get_object_or_404, redirect, render	1✔
7	from django.utils import timezone	1✔
8	from django.utils.http import url_has_allowed_host_and_scheme	1✔
9
10	from ..auth.decorators import login_required, superuser_required, teacher_or_superuser_required	1✔
11	from .forms import CommentForm, FilterForm	1✔
12	from .models import Comment, Submission	1✔
13	from .utils import serialize_submission_info	1✔
14
15	# Create your views here.
16
17
18	@login_required	1✔
19	def show_view(request, submission_id):	1!
20	"""Show a submission
21
22	Args:
23	request: The request
24	submission_id: An instance of the :class:`.Submission` model
25	"""
26	submission = get_object_or_404(	1✔
27	Submission.objects.filter_visible(request.user), id=submission_id
28	)
29
30	submissions = Submission.objects.filter(	1✔
31	student=submission.student, assignment=submission.assignment
32	)
33
34	before_submissions = submissions.filter(id__lt=submission.id)	1✔
35	submission_number = before_submissions.count() + 1	1✔
36
37	context = {	1✔
38	"course": submission.assignment.course,
39	"folder": submission.assignment.folder,
40	"assignment": submission.assignment,
41	"submission": submission,
42	"submission_number": submission_number,
43	"submission_text": submission.file_text,
44	"submission_comments": submission.comments.all(),
45	"submissions": submissions.order_by("-date_submitted"),
46	"is_student": submission.assignment.course.is_student_in_course(request.user),
47	"is_teacher": request.user in submission.assignment.course.teacher.all(),
48	}
49
50	if request.user.is_teacher or request.user.is_superuser:	1!
51	context["student"] = submission.student	×
52
53	return render(request, "submissions/show.html", context)	1✔
54
55
56	@login_required	1✔
57	def show_json_view(request, submission_id):	1!
58	"""Get a JSON response about the information of a submission
59
60	Args:
61	request: The request
62	submission_id: An instance of the :class:`.Submission` model
63	"""
64	try:	×
65	submission = Submission.objects.filter_visible(request.user).get(id=submission_id)	×
66	except Submission.DoesNotExist:	×
67	return http.JsonResponse({"error": "Submission not found"})	×
68
69	return http.JsonResponse(serialize_submission_info(submission, request.user))	×
70
71
72	@login_required	1✔
73	def download_view(request, submission_id):	1!
74	"""Download a submission
75
76	Args:
77	request: The request
78	submission_id: An instance of the :class:`.Submission` model
79	"""
UNCOV 80	submission = get_object_or_404(	×
81	Submission.objects.filter_visible(request.user), id=submission_id
82	)
83
84	file_with_header = submission.file_text_with_header	×
85	language = "P" if submission.assignment.filename.endswith(".py") else "J"	×
86	extension = "java" if language == "J" else "py"	×
87	username = submission.student.username	×
88
89	response = http.HttpResponse(file_with_header, content_type="text/plain")	×
90	response["Content-Disposition"] = f'attachment; filename="{username}.{extension}"'	×
91	return response	×
92
93
94	@login_required	1✔
95	def kill_view(request, submission_id):	1!
96	"""Kill a submission
97
98	Args:
99	request: The request
100	submission_id: An instance of the :class:`.Submission` model
101	"""
102	submissions_editable = Submission.objects.filter(	1✔
103	Q(assignment__course__teacher=request.user) \| Q(student=request.user)
104	)
105	submission = get_object_or_404(submissions_editable, id=submission_id)	1✔
106
107	if request.method == "POST":	1!
108	submission.kill_requested = True	1✔
109	submission.save()	1✔
110	next_url = request.GET.get("next")	1✔
111	if next_url and url_has_allowed_host_and_scheme(next_url, allowed_hosts=None):	1!
112	return redirect(next_url)	×
113	else:
114	return redirect("submissions:show", submission.id)	1✔
115	else:
116	raise http.Http404	×
117
118
119	@teacher_or_superuser_required	1✔
120	def rerun_view(request, submission_id):	1!
121	"""Rerun a submission
122
123	Args:
124	request: The request
125	submission_id: An instance of the :class:`.Submission` model
126	"""
UNCOV 127	submission = get_object_or_404(	×
128	Submission.objects.filter_visible(request.user), id=submission_id
129	)
130
131	submission.rerun().apply_async()	×
132	return redirect("submissions:show", submission.id)	×
133
134
135	@teacher_or_superuser_required	1✔
136	def comment_view(request, submission_id):	1!
137	"""Comment on a submission
138
139	Args:
140	request: The request
141	submission_id: An instance of the :class:`.Submission` model
142	"""
143	if request.method != "POST":	×
144	raise http.Http404	×
145
146	submission = get_object_or_404(	×
147	Submission.objects.filter_editable(request.user), id=submission_id
148	)
149
150	if not submission.complete or not submission.has_been_graded:	×
151	raise http.Http404	×
152
153	comment = request.POST.get("comment", "")	×
154	point_override = request.POST.get("point_override", "")	×
155	comment = Comment(	×
156	submission=submission,
157	author=request.user,
158	start_char=0,
159	end_char=len(submission.file_text),
160	text=comment,
161	point_override=point_override,
162	)
163	comment.save()	×
164
165	submission.publish()	×
166
167	return redirect("submissions:show", submission.id)	×
168
169
170	@teacher_or_superuser_required	1✔
171	def edit_comment_view(request, submission_id, comment_id):	1!
172	"""Edit a comment on a submission
173
174	Args:
175	request: The request
176	submission_id: An instance of the :class:`.Submission` model
177	comment_id: An instance of the :class:`.Comment` model
178	"""
UNCOV 179	submission = get_object_or_404(	×
180	Submission.objects.filter_editable(request.user), id=submission_id
181	)
182	comment = get_object_or_404(submission.comments.all(), id=comment_id)	×
183	assignment = submission.assignment	×
184
185	if request.method == "POST":	×
186	form = CommentForm(request.POST, instance=comment)	×
187	if form.is_valid():	×
188	form.save()	×
189	return redirect("submissions:show", submission.id)	×
190
191	before_submissions = Submission.objects.filter(	×
192	student=submission.student, assignment=submission.assignment, id__lt=submission.id
193	)
194	submission_number = before_submissions.count() + 1	×
195
196	form = CommentForm(instance=comment)	×
197	context = {	×
198	"form": form,
199	"nav_item": "Edit comment",
200	"course": assignment.course,
201	"folder": assignment.folder,
202	"assignment": assignment,
203	"submission": submission,
204	"comment": comment,
205	"submission_number": submission_number,
206	}
207
208	return render(request, "submissions/edit_comment.html", context=context)	×
209
210
211	@teacher_or_superuser_required	1✔
212	def delete_comment_view(request, submission_id, comment_id):	1!
213	"""Delete a comment
214
215	Args:
216	request: The request
217	submission_id: An instance of the :class:`.Submission` model
218	comment_id: An instance of the :class:`.Comment` model
219	"""
UNCOV 220	submission = get_object_or_404(	×
221	Submission.objects.filter_editable(request.user), id=submission_id
222	)
223	comment = get_object_or_404(submission.comments.all(), id=comment_id)	×
224	course = submission.assignment.course	×
225
226	if not course.teacher.filter(id=request.user.id).exists() and not request.user.is_superuser:	×
227	raise http.Http404	×
228
229	comment.delete()	×
230	return redirect("submissions:show", submission.id)	×
231
232
233	@teacher_or_superuser_required	1✔
234	def publish_view(request, submission_id):	1!
235	"""Publish a submission
236
237	Args:
238	request: The request
239	submission_id: An instance of the :class:`.Submission` model
240	"""
UNCOV 241	submission = get_object_or_404(	×
242	Submission.objects.filter_editable(request.user), id=submission_id
243	)
244
245	submission.publish()	×
246	return redirect("submissions:show", submission.id)	×
247
248
249	@teacher_or_superuser_required	1✔
250	def unpublish_view(request, submission_id):	1!
251	"""Unpublish a submission
252
253	Args:
254	request: The request
255	submission_id: An instance of the :class:`.Submission` model
256	"""
UNCOV 257	submission = get_object_or_404(	×
258	Submission.objects.filter_editable(request.user), id=submission_id
259	)
260
261	submission.unpublish()	×
262	return redirect("submissions:show", submission.id)	×
263
264
265	@teacher_or_superuser_required	1✔
266	def filter_view(request):	1!
267	"""Search through submissions based on a filter.
268
269	Args:
270	request: The request
271	"""
272	if request.method == "POST":	×
273	filter_form = FilterForm(request.POST)	×
274	if filter_form.is_valid():	×
275	queryset = filter_form.get_results()	×
276
277	if "list_submissions" in request.POST:	×
278	return render(	×
279	request,
280	"submissions/filter.html",
281	{
282	"form": filter_form,
283	"submissions": queryset,
284	"action": "show",
285	"nav_item": "Filter submissions",
286	},
287	)
288	elif "view_code" in request.POST:	×
289	submission_texts = []	×
290	for submission in queryset:	×
291	submission_texts.append(submission.file_text)	×
292
293	return render(	×
294	request,
295	"submissions/filter.html",
296	{
297	"form": filter_form,
298	"submissions": list(zip(queryset, submission_texts)),
299	"action": "show_code",
300	"nav_item": "Filter submissions",
301	},
302	)
303
304	filter_form = FilterForm()	×
305
306	return render(	×
307	request,
308	"submissions/filter.html",
309	{
310	"form": filter_form,
311	"submissions": Submission.objects.none(),
312	"action": "filter",
313	"nav_item": "Filter submissions",
314	},
315	)
316
317
318	@superuser_required	1✔
319	def set_aborted_complete_view(request):	1!
320	"""Check if a submission is running.
321
322	This also marks all non-running incomplete submissions
323	as completed.
324
325	Args:
326	request: The request
327	"""
328	if request.method == "POST":	×
329	submissions = Submission.objects.filter(complete=False, grader_pid__isnull=False)	×
330
331	for submission in submissions:	×
332	try:	×
333	psutil.Process(submission.grader_pid)	×
334	except psutil.NoSuchProcess:	×
335	submission.complete = True	×
336	submission.save(update_fields=["complete"])	×
337
338	return redirect("auth:index")	×
339
340
341	@superuser_required	1✔
342	def set_past_timeout_complete_view(request):	1!
343	"""Update submissions based off the time limit
344
345	If it has exceeded its time limit, marks it as complete
346
347	Args:
348	request: The request
349	"""
350	if request.method == "POST":	×
351	Submission.objects.filter(	×
352	complete=False,
353	grader_start_time__isnull=False,
354	assignment__enable_grader_timeout=True,
355	grader_start_time__lte=timezone.localtime().timestamp()
356	- F("assignment__grader_timeout"),
357	).update(complete=True)
358
359	return redirect("auth:index")	×

tjcsl / tin / 10230191976

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous