edx-proctoring 5.2.0__tar.gz → 6.1.2__tar.gz

edx-proctoring-5.2.0/edx_proctoring.egg-info/PKG-INFO → edx_proctoring-6.1.2/CHANGELOG.rst

@@ -1,133 +1,3 @@
-Metadata-Version: 2.1
-Name: edx-proctoring
-Version: 5.2.0
-Summary: Proctoring subsystem for Open edX
-Home-page: https://github.com/openedx/edx-proctoring
-Author: edX
-Author-email: oscm@edx.org
-License: AGPL 3.0
-Keywords: Django edx
-Classifier: Development Status :: 4 - Beta
-Classifier: Framework :: Django
-Classifier: Framework :: Django :: 4.2
-Classifier: Framework :: Django :: 5.2
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
-Classifier: Natural Language :: English
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-License-File: LICENSE.txt
-
-edx-proctoring
-==============
-
-.. image:: https://img.shields.io/pypi/v/edx-proctoring.svg
-    :target: https://pypi.python.org/pypi/edx-proctoring/
-    :alt: PyPI
-
-.. image:: https://github.com/openedx/edx-proctoring/workflows/Python%20CI/badge.svg
-    :target: https://github.com/openedx/edx-proctoring/actions?query=workflow%3A%22Python+CI%22
-    :alt: Python CI
-
-.. image:: https://codecov.io/gh/edx/edx-proctoring/branch/master/graph/badge.svg
-    :target: https://codecov.io/gh/edx/edx-proctoring
-    :alt: Codecov
-
-.. image:: https://img.shields.io/pypi/pyversions/edx-proctoring.svg
-    :target: https://pypi.python.org/pypi/edx-proctoring/
-    :alt: Supported Python versions
-
-.. image:: https://img.shields.io/github/license/edx/django-component-views.svg
-    :target: https://github.com/openedx/edx-proctoring/blob/master/LICENSE.txt
-    :alt: License
-
-This is the exam proctoring subsystem for the Open edX platform.
-
-Overview
---------
-
-Proctored exams are exams with time limits that learners complete while online
-proctoring software monitors their computers and behavior for activity that
-might be evidence of cheating. This Python library provides the proctoring
-implementation used by Open edX.
-
-Documentation
--------------
-
-For authoring documentation, see `Including Proctored Exams In Your Course`_.
-
-Installation
-------------
-
-To install edx-proctoring:
-
-    mkvirtualenv edx-proctoring
-
-    make install
-
-If you want to run tests, first setup requirements. Note that JS tests
-require Node 10, nvm install v10 if you are on a different version so
-that gulp is installed for v10:
-
-    nvm install v10
-
-    make requirements-test
-
-Run tests:
-
-    make test
-
-Run just python tests:
-
-    make test-python
-
-Run just JS tests:
-
-    make test-js
-
-For a full list of Make targets:
-
-    make help
-
-Developing
--------------
-
-See the `developer guide`_ for configuration, devstack and sandbox setup, and other developer concerns.
-
-.. _developer guide: ./docs/developing.rst
-
-License
--------
-
-The code in this repository is licensed under the AGPL 3.0 unless
-otherwise noted.
-
-Please see ``LICENSE.txt`` for details.
-
-How To Contribute
------------------
-
-Contributions are very welcome.
-
-Please read `How To Contribute <https://github.com/openedx/.github/blob/master/CONTRIBUTING.md>`_ for details.
-
-
-Reporting Security Issues
--------------------------
-
-Please do not report security issues in public. Please email security@openedx.org.
-
-Getting Help
-------------
-
-Have a question about this repository, or about Open edX in general?  Please
-refer to this `list of resources`_ if you need any assistance.
-
-.. _list of resources: https://open.edx.org/getting-help
-.. _Including Proctored Exams In Your Course: https://docs.openedx.org/en/latest/educators/concepts/proctored_exams/proctored_exams_overview.html
-
-
 Change Log
 ----------
 
@@ -143,6 +13,70 @@ Change Log
 
 Unreleased
 ~~~~~~~~~~
+
+[6.1.2] - 2026-10-16
+~~~~~~~~~~~~~~~~~~~~
+
+* A passing review from the proctoring provider no longer marks an attempt ``verified``
+  when the learner never submitted it, for example because the proctoring session ended
+  while the attempt was still ``ready_to_start``. Such attempts are put into ``error``
+  instead, so the learner is told to retry and staff can see the exam was not completed.
+* A review that arrives for an attempt that has since been reset (``onboarding_reset``)
+  no longer changes that attempt's status.
+* A timeout treated as a submission (``ALLOW_TIMED_OUT_STATE`` off) now always records
+  ``completed_at``, falling back to the current time when no timeout timestamp is passed,
+  as ``mark_exam_attempt_timeout`` does. As with any other submission, this also marks
+  the exam complete in the completion service.
+* **Existing data:** attempts that are already ``verified`` but have no ``completed_at``
+  (they were verified without being submitted) move to ``error`` the next time their
+  review is processed, whether by a re-delivered passing review or by the
+  ``update_attempt_status_from_review`` management command, and their credit
+  requirement changes to ``failed``. Run that command over a review date range to apply
+  this to existing attempts on purpose.
+
+[6.1.1] - 2026-10-14
+~~~~~~~~~~~~~~~~~~~~
+
+* Fix PyPI publish workflow: use ``python -m build`` instead of ``setup.py sdist
+  bdist_wheel``, which broke on Python 3.12 because ``setuptools`` is no longer
+  bundled and was not installed by the workflow.
+
+[6.1.0] - 2026-09-01
+~~~~~~~~~~~~~~~~~~~~
+
+* **Behaviour change for API consumers:** the instructor reset endpoint now responds with
+  **502** when the proctoring provider cannot remove the attempt, where it previously
+  returned a 500 or appeared to succeed. Anything driving the instructor dashboard reset
+  should handle that status.
+* Make resetting a proctored exam attempt fail gracefully when the proctoring provider
+  is unavailable, instead of an unhandled 500 or a stuck reset:
+
+  * Add an explicit request timeout to the REST proctoring backend (default 30s,
+    overridable per backend via a ``timeout`` key in ``PROCTORING_BACKENDS``), applied to
+    every outbound provider request, so a slow provider cannot hang the request
+    indefinitely.
+  * Call the provider from ``remove_exam_attempt`` **before** the local delete (rather
+    than from the ``pre_delete`` signal). If the provider is unreachable/errors, a typed
+    ``BackendProviderCannotRemoveAttempt`` (HTTP 502) is raised before anything is
+    deleted, so the caller can show the instructor a descriptive message and the local
+    attempt is preserved. Because the failure no longer originates inside ``delete()``'s
+    ``pre_delete`` signal, it does not leave the DB connection in a needs-rollback state,
+    so a partially-failed multi-attempt reset can be retried in the same request.
+  * On removal, a provider ``404`` (the attempt is already gone upstream) is treated as
+    success so a retried, partially-failed reset converges; any other HTTP error is raised
+    so the local attempt is kept for a later retry instead of being silently dropped.
+  * Route the ``reset_attempts`` management command through the same provider-removal
+    path, since provider cleanup no longer happens in the ``pre_delete`` signal.
+  * Learner-initiated practice/onboarding resets stay best-effort, so a provider problem
+    does not block a learner from retrying their own onboarding exam.
+  * Deleting a ``ProctoredExam`` no longer notifies the proctoring provider about the
+    attempts that are cascade-deleted with it. Provider removal now happens at the three
+    call sites that reset attempts rather than in a ``pre_delete`` signal, so attempts
+    removed this way (a staff delete from Django admin) are left on the provider.
+
+[5.2.1] - 2025-12-05
+* Remove all references to Proctortrack
+
 [5.2.0] - 2025-04-22
 * adds support for django 5.2
 

{edx-proctoring-5.2.0 → edx_proctoring-6.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: edx-proctoring
-Version: 5.2.0
+Version: 6.1.2
 Summary: Proctoring subsystem for Open edX
 Home-page: https://github.com/openedx/edx-proctoring
 Author: edX
@@ -14,10 +14,37 @@ Classifier: Framework :: Django :: 5.2
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
 Classifier: Natural Language :: English
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 License-File: LICENSE.txt
+Requires-Dist: event-tracking>=0.2.5
+Requires-Dist: jsonfield
+Requires-Dist: edx-opaque-keys>=0.4
+Requires-Dist: edx-when>=0.1.3
+Requires-Dist: Django>=2.2
+Requires-Dist: django-webpack-loader>=0.6.0
+Requires-Dist: rules
+Requires-Dist: django-ipware>=1.1.0
+Requires-Dist: djangorestframework
+Requires-Dist: django-simple-history
+Requires-Dist: pycryptodomex>=3.4.7
+Requires-Dist: pyjwt[crypto]>=2.1.0
+Requires-Dist: edx-drf-extensions
+Requires-Dist: django-crum
+Requires-Dist: python-dateutil>=2.1
+Requires-Dist: pytz>=2018
+Requires-Dist: django-model-utils
+Requires-Dist: django-waffle
+Requires-Dist: edx-rest-api-client>=1.9.2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
 
 edx-proctoring
 ==============
@@ -143,6 +170,70 @@ Change Log
 
 Unreleased
 ~~~~~~~~~~
+
+[6.1.2] - 2026-10-16
+~~~~~~~~~~~~~~~~~~~~
+
+* A passing review from the proctoring provider no longer marks an attempt ``verified``
+  when the learner never submitted it, for example because the proctoring session ended
+  while the attempt was still ``ready_to_start``. Such attempts are put into ``error``
+  instead, so the learner is told to retry and staff can see the exam was not completed.
+* A review that arrives for an attempt that has since been reset (``onboarding_reset``)
+  no longer changes that attempt's status.
+* A timeout treated as a submission (``ALLOW_TIMED_OUT_STATE`` off) now always records
+  ``completed_at``, falling back to the current time when no timeout timestamp is passed,
+  as ``mark_exam_attempt_timeout`` does. As with any other submission, this also marks
+  the exam complete in the completion service.
+* **Existing data:** attempts that are already ``verified`` but have no ``completed_at``
+  (they were verified without being submitted) move to ``error`` the next time their
+  review is processed, whether by a re-delivered passing review or by the
+  ``update_attempt_status_from_review`` management command, and their credit
+  requirement changes to ``failed``. Run that command over a review date range to apply
+  this to existing attempts on purpose.
+
+[6.1.1] - 2026-10-14
+~~~~~~~~~~~~~~~~~~~~
+
+* Fix PyPI publish workflow: use ``python -m build`` instead of ``setup.py sdist
+  bdist_wheel``, which broke on Python 3.12 because ``setuptools`` is no longer
+  bundled and was not installed by the workflow.
+
+[6.1.0] - 2026-09-01
+~~~~~~~~~~~~~~~~~~~~
+
+* **Behaviour change for API consumers:** the instructor reset endpoint now responds with
+  **502** when the proctoring provider cannot remove the attempt, where it previously
+  returned a 500 or appeared to succeed. Anything driving the instructor dashboard reset
+  should handle that status.
+* Make resetting a proctored exam attempt fail gracefully when the proctoring provider
+  is unavailable, instead of an unhandled 500 or a stuck reset:
+
+  * Add an explicit request timeout to the REST proctoring backend (default 30s,
+    overridable per backend via a ``timeout`` key in ``PROCTORING_BACKENDS``), applied to
+    every outbound provider request, so a slow provider cannot hang the request
+    indefinitely.
+  * Call the provider from ``remove_exam_attempt`` **before** the local delete (rather
+    than from the ``pre_delete`` signal). If the provider is unreachable/errors, a typed
+    ``BackendProviderCannotRemoveAttempt`` (HTTP 502) is raised before anything is
+    deleted, so the caller can show the instructor a descriptive message and the local
+    attempt is preserved. Because the failure no longer originates inside ``delete()``'s
+    ``pre_delete`` signal, it does not leave the DB connection in a needs-rollback state,
+    so a partially-failed multi-attempt reset can be retried in the same request.
+  * On removal, a provider ``404`` (the attempt is already gone upstream) is treated as
+    success so a retried, partially-failed reset converges; any other HTTP error is raised
+    so the local attempt is kept for a later retry instead of being silently dropped.
+  * Route the ``reset_attempts`` management command through the same provider-removal
+    path, since provider cleanup no longer happens in the ``pre_delete`` signal.
+  * Learner-initiated practice/onboarding resets stay best-effort, so a provider problem
+    does not block a learner from retrying their own onboarding exam.
+  * Deleting a ``ProctoredExam`` no longer notifies the proctoring provider about the
+    attempts that are cascade-deleted with it. Provider removal now happens at the three
+    call sites that reset attempts rather than in a ``pre_delete`` signal, so attempts
+    removed this way (a staff delete from Django admin) are left on the provider.
+
+[5.2.1] - 2025-12-05
+* Remove all references to Proctortrack
+
 [5.2.0] - 2025-04-22
 * adds support for django 5.2
 

{edx-proctoring-5.2.0 → edx_proctoring-6.1.2}/edx_proctoring/__init__.py

@@ -3,4 +3,4 @@ The exam proctoring subsystem for the Open edX platform.
 """
 
 # Be sure to update the version number in edx_proctoring/package.json
-__version__ = '5.2.0'
+__version__ = '6.1.2'

{edx-proctoring-5.2.0 → edx_proctoring-6.1.2}/edx_proctoring/admin.py

@@ -316,11 +316,11 @@ class ProctoredExamSoftwareSecureReviewAdmin(admin.ModelAdmin):
         obj.reviewed_by = request.user
         obj.save()
 
-    def lookup_allowed(self, lookup, value):
+    def lookup_allowed(self, lookup, value, request=None):
         """ Checks if lookup allowed or not """
         if lookup == 'exam__course_id':
             return True
-        return super().lookup_allowed(lookup, value)
+        return super().lookup_allowed(lookup, value, request)
 
 
 @admin.register(ProctoredExamSoftwareSecureReviewHistory)

{edx-proctoring-5.2.0 → edx_proctoring-6.1.2}/edx_proctoring/api.py

@@ -26,8 +26,10 @@ from edx_proctoring.backends import get_backend_provider
 from edx_proctoring.exceptions import (
     AllowanceValueNotAllowedException,
     BackendProviderCannotRegisterAttempt,
+    BackendProviderCannotRemoveAttempt,
     BackendProviderNotConfigured,
     BackendProviderOnboardingException,
+    BackendProviderRemovalNotConfirmed,
     BackendProviderSentNoAttemptID,
     ProctoredBaseException,
     ProctoredExamAlreadyExists,
@@ -1472,7 +1474,7 @@ def update_attempt_status(attempt_id, to_status,
         exam_attempt_obj.allowed_time_limit_mins = _calculate_allowed_mins(exam, exam_attempt_obj.user_id)
 
     elif treat_timeout_as_submitted:
-        exam_attempt_obj.completed_at = timeout_timestamp
+        exam_attempt_obj.completed_at = timeout_timestamp or datetime.now(pytz.UTC)
     elif to_status == ProctoredExamStudentAttemptStatus.submitted:
         # likewise, when we transition to submitted mark
         # when the exam has been completed
@@ -1771,7 +1773,7 @@ def create_proctoring_attempt_status_email(exam_attempt_obj, course_name, course
     default_contact_url = f'{scheme}://{constants.SITE_NAME}/support/contact_us'
 
     # If the course has a proctoring escalation email set, use that rather than edX Support.
-    # Currently only courses using Proctortrack will have this set.
+    # This will be set if 'requires_escalation_email' is 'True' in proctoring backend.
     proctoring_escalation_email = _get_proctoring_escalation_email(course_id)
     if proctoring_escalation_email:
         contact_url = f'mailto:{proctoring_escalation_email}'
@@ -1880,7 +1882,9 @@ def reset_practice_exam(exam_id, user_id, requesting_user):
 
     # resetting a submitted attempt that has not been reviewed will entirely remove that submission.
     if exam_attempt_obj.status == ProctoredExamStudentAttemptStatus.submitted:
-        remove_exam_attempt(exam_attempt_obj.id, requesting_user)
+        # This is the learner retrying their own onboarding exam, so a provider problem
+        # must not block them: remove what we can upstream and reset locally regardless.
+        remove_exam_attempt(exam_attempt_obj.id, requesting_user, require_backend_removal=False)
     else:
         exam_attempt_obj.status = ProctoredExamStudentAttemptStatus.onboarding_reset
         exam_attempt_obj.save()
@@ -1890,9 +1894,115 @@ def reset_practice_exam(exam_id, user_id, requesting_user):
     return create_exam_attempt(exam_id, user_id, taking_as_proctored=exam_attempt_obj.taking_as_proctored)
 
 
-def remove_exam_attempt(attempt_id, requesting_user):
+def _remove_exam_attempt_from_backend(attempt):
+    """
+    Ask the proctoring backend to remove ``attempt`` on the provider's side, raising
+    ``BackendProviderCannotRemoveAttempt`` (HTTP 502) if it cannot.
+
+    This is called BEFORE the local delete (see ``remove_exam_attempt``). Doing the
+    provider call outside the ``pre_delete`` signal means a provider outage can raise a
+    descriptive error without the local delete being half-applied: raising from inside
+    ``delete()``'s ``pre_delete`` marks the DB connection needs-rollback, which then makes
+    the surrounding request (and any retry) fail with ``TransactionManagementError``.
+
+    An attempt already gone upstream (provider 404) counts as success, so the local delete
+    proceeds and a retry converges. Bulk, best-effort callers (onboarding cleanup, the
+    reset_attempts command) should use ``_remove_exam_attempts_from_backend`` instead, which
+    swallows these errors and skips a failing backend for the rest of the pass.
+    """
+    exam = attempt.proctored_exam
+    if not exam.is_proctored:
+        return
+    if not attempt.external_id:
+        # The attempt was never registered with the provider; nothing to remove upstream.
+        return
+    # Single instructor-facing message for any provider-side removal failure. The specific
+    # cause is logged (below), never surfaced to the user.
+    # Translators: shown to an instructor when an exam attempt could not be reset because
+    # the external proctoring provider is temporarily unavailable.
+    unavailable_message = _(
+        'The proctoring provider is temporarily unavailable, so this attempt could not '
+        'be fully reset. Please try again in a few minutes.'
+    )
+    try:
+        # Resolving the backend can itself raise (e.g. NotImplementedError for a
+        # stale/unconfigured backend), so keep it inside the error-handling block.
+        backend = get_backend_provider(name=exam.backend)
+        if not backend:
+            return
+        result = backend.remove_exam_attempt(exam.external_id, attempt.external_id)
+    except Exception as exc:
+        log.exception(
+            'Failed to remove attempt_id=%(attempt_id)s (external_id=%(external_id)s) for '
+            'exam_id=%(exam_id)s user_id=%(user_id)s from backend=%(backend)s due to a provider error.',
+            {
+                'attempt_id': attempt.id,
+                'external_id': attempt.external_id,
+                'exam_id': exam.id,
+                'user_id': attempt.user_id,
+                'backend': exam.backend,
+            }
+        )
+        raise BackendProviderCannotRemoveAttempt(unavailable_message) from exc
+    if not result:
+        # The provider responded but did not confirm removal, so keep the local attempt: a
+        # retry can converge once the provider is healthy instead of silently dropping it.
+        # This is attempt-specific -- the provider answered -- so it is raised as the more
+        # specific subclass, letting bulk callers keep using the same backend.
+        log.warning('Backend %s did not confirm removal of attempt_id=%s.', exam.backend, attempt.id)
+        raise BackendProviderRemovalNotConfirmed(unavailable_message)
+
+
+def _remove_exam_attempts_from_backend(attempts, failed_backends=frozenset()):
+    """
+    Best-effort provider-side removal for a collection of attempts.
+
+    Provider failures are swallowed (the caller is expected to delete the attempts locally
+    regardless). Once a backend proves *unreachable* we stop calling it for the rest of this
+    pass -- while still trying other, independently configured backends -- so a provider
+    outage does not cost a full request timeout for every attempt. A reachable provider that
+    merely fails to confirm one removal is not skipped, since the remaining attempts on it
+    are still worth attempting.
+
+    Returns the set of backends that failed, so a caller working through batches can thread
+    it back in and keep skipping them across calls.
+
+    Pass a queryset with ``select_related('proctored_exam')`` to avoid a query per attempt.
+    """
+    # Fresh mutable set per call; the shared default is only ever copied from, never mutated.
+    failed = set(failed_backends)
+    for attempt in attempts:
+        backend = attempt.proctored_exam.backend
+        if backend in failed:
+            continue
+        try:
+            _remove_exam_attempt_from_backend(attempt)
+        except BackendProviderRemovalNotConfirmed:
+            # The provider answered, it just did not confirm this one. It is still healthy,
+            # so keep going -- skipping the rest would orphan them upstream for nothing.
+            log.warning(
+                'Backend %r did not confirm removal of attempt_id=%s; removing locally only.',
+                backend, attempt.id,
+            )
+        except BackendProviderCannotRemoveAttempt:
+            # The provider could not be reached at all, so stop paying its timeout for
+            # every remaining attempt on that backend.
+            log.warning(
+                'Provider removal failed for backend %r; skipping further provider calls '
+                'for it during this cleanup and removing locally only.', backend
+            )
+            failed.add(backend)
+    return failed
+
+
+def remove_exam_attempt(attempt_id, requesting_user, require_backend_removal=True):
     """
     Removes an exam attempt given the attempt id. requesting_user is passed through to the instructor_service.
+
+    The attempt is removed on the proctoring provider first. By default a provider failure
+    raises ``BackendProviderCannotRemoveAttempt`` and the local attempt is left untouched so
+    it can be retried. Pass ``require_backend_removal=False`` for learner-initiated resets,
+    where the provider removal is best-effort and must not block the learner.
     """
 
     log.info(
@@ -1916,6 +2026,15 @@ def remove_exam_attempt(attempt_id, requesting_user):
     content_id = existing_attempt.proctored_exam.content_id
     to_status = existing_attempt.status
 
+    # Remove the attempt on the proctoring provider BEFORE deleting it locally, so a
+    # provider outage surfaces a descriptive error instead of a rolled-back, half-applied
+    # delete. See _remove_exam_attempt_from_backend for why this must not happen in the
+    # pre_delete signal.
+    if require_backend_removal:
+        _remove_exam_attempt_from_backend(existing_attempt)
+    else:
+        _remove_exam_attempts_from_backend([existing_attempt])
+
     existing_attempt.delete_exam_attempt()
     instructor_service = get_runtime_service('instructor')
     grades_service = get_runtime_service('grades')

{edx-proctoring-5.2.0 → edx_proctoring-6.1.2}/edx_proctoring/apps.py

@@ -37,6 +37,7 @@ BACKEND_CONFIGURATION_ALLOW_LIST = [
     'supports_onboarding',
     'tech_support_email',
     'tech_support_phone',
+    'timeout',
     'token_expiration_time',
     'verbose_name',
     'video_review_aes_key',

{edx-proctoring-5.2.0 → edx_proctoring-6.1.2}/edx_proctoring/backends/backend.py

@@ -61,6 +61,12 @@ class ProctoringBackendProvider(metaclass=abc.ABCMeta):
     def remove_exam_attempt(self, exam, attempt):
         """
         Method that removes the exam attempt from the backend's system
+
+        Return ``True`` when the provider confirms the attempt was removed, or that it is
+        already gone upstream. Return ``False`` when the provider responded without
+        confirming the removal; the caller then keeps the local attempt so the removal can
+        be retried instead of being silently dropped. Raise to signal that the provider
+        could not be reached at all.
         """
         raise NotImplementedError()
 

{edx-proctoring-5.2.0 → edx_proctoring-6.1.2}/edx_proctoring/backends/rest.py

@@ -41,6 +41,14 @@ class BaseRestProctoringProvider(ProctoringBackendProvider):
     has_dashboard = True
     supports_onboarding = True
     passing_statuses = (SoftwareSecureReviewStatus.clean,)
+    # Timeout (in seconds) for every outbound request to the provider, so a slow or
+    # unavailable provider cannot hang the request indefinitely. ``requests`` applies this
+    # as two separate inactivity limits -- how long to wait to connect, and how long to wait
+    # for more data -- not as a cap on total request time, so a response that keeps
+    # trickling can outlast it. A ``(connect, read)`` tuple sets those two phases
+    # independently. Overridable per backend via a ``timeout`` key in
+    # ``PROCTORING_BACKENDS``.
+    timeout = 30
 
     @property
     def exam_attempt_url(self):
@@ -148,7 +156,7 @@ class BaseRestProctoringProvider(ProctoringBackendProvider):
         """
         url = self.config_url
         log.debug('Requesting config from %r', url)
-        response = self.session.get(url, headers=self._get_language_headers()).json()
+        response = self.session.get(url, headers=self._get_language_headers(), timeout=self.timeout).json()
         return response
 
     def get_exam(self, exam):
@@ -157,7 +165,7 @@ class BaseRestProctoringProvider(ProctoringBackendProvider):
         """
         url = self.exam_url.format(exam_id=exam['id'])
         log.debug('Requesting exam from %r', url)
-        response = self.session.get(url).json()
+        response = self.session.get(url, timeout=self.timeout).json()
         return response
 
     def get_attempt(self, attempt):
@@ -187,7 +195,7 @@ class BaseRestProctoringProvider(ProctoringBackendProvider):
             'Creating exam attempt for exam_id=%(exam_id)i (external_id=%(external_id)s) at %(url)s',
             {'exam_id': exam['id'], 'external_id': exam['external_id'], 'url': url}
         )
-        response = self.session.post(url, json=payload)
+        response = self.session.post(url, json=payload, timeout=self.timeout)
         if response.status_code != 200:
             raise BackendProviderCannotRegisterAttempt(response.content, response.status_code)
         status_code = response.status_code
@@ -227,13 +235,29 @@ class BaseRestProctoringProvider(ProctoringBackendProvider):
 
     def remove_exam_attempt(self, exam, attempt):
         """
-        Removes the exam attempt on the backend provider's server
+        Removes the exam attempt on the backend provider's server.
+
+        Returns ``True`` when the provider confirms removal with the documented
+        ``{"status": "deleted"}`` payload, or on a ``404`` (the attempt is already gone
+        upstream, so a retried reset converges). Returns ``False`` when the provider responds
+        but does not confirm deletion (undecodable body or an unexpected status); the API
+        layer decides whether that is fatal. Any other HTTP error is raised so a transient
+        failure keeps the local attempt available for a later retry.
         """
-        response = self._make_attempt_request(
-            exam,
-            attempt,
-            method='DELETE')
-        return response.get('status', None) == 'deleted'
+        if not attempt:
+            return False
+        url = self.exam_attempt_url.format(exam_id=exam, attempt_id=attempt)
+        log.debug('Removing attempt at %r', url)
+        response = self.session.request('DELETE', url, timeout=self.timeout)
+        if response.status_code == 404:
+            return True
+        response.raise_for_status()
+        try:
+            data = response.json()
+        except ValueError:
+            log.exception('Decoding attempt removal %r -> %r', attempt, response.content)
+            return False
+        return data.get('status', None) == 'deleted'
 
     def mark_erroneous_exam_attempt(self, exam, attempt):
         """
@@ -272,7 +296,7 @@ class BaseRestProctoringProvider(ProctoringBackendProvider):
         )
         response = None
         try:
-            response = self.session.post(url, json=exam)
+            response = self.session.post(url, json=exam, timeout=self.timeout)
             data = response.json()
         except Exception as exc:  # pylint: disable=broad-exception-caught
             if response:
@@ -327,16 +351,21 @@ class BaseRestProctoringProvider(ProctoringBackendProvider):
 
     def retire_user(self, user_id):
         url = self.user_info_url.format(user_id=user_id)
+        response = None
         try:
-            response = self.session.delete(url)
+            response = self.session.delete(url, timeout=self.timeout)
             data = response.json()
             assert data in (True, False)
         except Exception as exc:
             # pylint: disable=no-member
             if hasattr(exc, 'response') and exc.response is not None:
                 content = exc.response.content
-            else:
+            elif response is not None:
                 content = response.content
+            else:
+                # The request failed before a response was received (e.g. a timeout), so
+                # there is no body to include.
+                content = None
             raise BackendProviderCannotRetireUser(content) from exc
         return data
 
@@ -346,7 +375,7 @@ class BaseRestProctoringProvider(ProctoringBackendProvider):
             query_string = urlencode(kwargs)
             url += '?' + query_string
 
-        response = self.session.get(url)
+        response = self.session.get(url, timeout=self.timeout)
 
         if response.status_code != 200:
             raise BackendProviderOnboardingProfilesException(response.content, response.status_code)
@@ -384,7 +413,7 @@ class BaseRestProctoringProvider(ProctoringBackendProvider):
         if method == 'GET':
             headers.update(self._get_language_headers())
         log.debug('Making %r attempt request at %r', method, url)
-        response = self.session.request(method, url, json=payload, headers=headers)
+        response = self.session.request(method, url, json=payload, headers=headers, timeout=self.timeout)
         try:
             data = response.json()
         except ValueError: