ff-ltitoolkit 0.1.0__py3-none-any.whl

ltitoolkit/core/grade.py

@@ -0,0 +1,143 @@
+import json
+import typing as t
+from .exception import LtiException
+
+
+TExtaClaims = t.Mapping[str, t.Any]
+
+
+class Grade:
+    _score_given: t.Optional[float] = None
+    _score_maximum: t.Optional[float] = None
+    _activity_progress: t.Optional[str] = None
+    _grading_progress: t.Optional[str] = None
+    _timestamp: t.Optional[str] = None
+    _user_id: t.Optional[str] = None
+    _comment: t.Optional[str] = None
+    _extra_claims: t.Optional[TExtaClaims] = None
+
+    def _validate_score(self, score_value) -> t.Optional[str]:
+        if not isinstance(score_value, (int, float)):
+            return "score must be integer or float"
+        if score_value < 0:
+            return "score must be positive number (including 0)"
+        return None
+
+    def get_score_given(self) -> t.Optional[float]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#scoregiven-and-scoremaximum
+        """
+        return self._score_given
+
+    def set_score_given(self, value: float) -> "Grade":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#scoregiven-and-scoremaximum
+        """
+        err_msg = self._validate_score(value)
+        if err_msg is not None:
+            raise LtiException("Invalid scoreGiven value: " + err_msg)
+        self._score_given = value
+        return self
+
+    def get_score_maximum(self) -> t.Optional[float]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#scoregiven-and-scoremaximum
+        """
+        return self._score_maximum
+
+    def set_score_maximum(self, value: float) -> "Grade":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#scoregiven-and-scoremaximum
+        """
+        err_msg = self._validate_score(value)
+        if err_msg is not None:
+            raise LtiException("Invalid scoreMaximum value: " + err_msg)
+        self._score_maximum = value
+        return self
+
+    def get_activity_progress(self) -> t.Optional[str]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#activityprogress
+        """
+        return self._activity_progress
+
+    def set_activity_progress(self, value: str) -> "Grade":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#activityprogress
+        """
+        self._activity_progress = value
+        return self
+
+    def get_grading_progress(self) -> t.Optional[str]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#gradingprogress
+        """
+        return self._grading_progress
+
+    def set_grading_progress(self, value: str) -> "Grade":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#gradingprogress
+        """
+        self._grading_progress = value
+        return self
+
+    def get_timestamp(self) -> t.Optional[str]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#timestamp
+        """
+        return self._timestamp
+
+    def set_timestamp(self, value: str) -> "Grade":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#timestamp
+        """
+        self._timestamp = value
+        return self
+
+    def get_user_id(self) -> t.Optional[str]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#userid-0
+        """
+        return self._user_id
+
+    def set_user_id(self, value: str) -> "Grade":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#userid-0
+        """
+        self._user_id = value
+        return self
+
+    def get_comment(self) -> t.Optional[str]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#comment-0
+        """
+        return self._comment
+
+    def set_comment(self, value: str) -> "Grade":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#comment-0
+        """
+        self._comment = value
+        return self
+
+    def set_extra_claims(self, value: TExtaClaims) -> "Grade":
+        self._extra_claims = value
+        return self
+
+    def get_extra_claims(self) -> t.Optional[TExtaClaims]:
+        return self._extra_claims
+
+    def get_value(self) -> str:
+        data = {
+            "scoreGiven": self._score_given,
+            "scoreMaximum": self._score_maximum,
+            "activityProgress": self._activity_progress,
+            "gradingProgress": self._grading_progress,
+            "timestamp": self._timestamp,
+            "userId": self._user_id,
+            "comment": self._comment,
+        }
+        if self._extra_claims is not None:
+            data.update(self._extra_claims)
+
+        return json.dumps({k: v for k, v in data.items() if v is not None})

ltitoolkit/core/launch_data_storage/base.py

@@ -0,0 +1,75 @@
+import typing as t
+from abc import ABCMeta, abstractmethod
+from ..request import Request
+
+T = t.TypeVar("T")
+
+
+class LaunchDataStorage(t.Generic[T]):
+    __metaclass__ = ABCMeta
+    _request: t.Optional[Request] = None
+    _session_id: t.Optional[str] = None
+    _session_cookie_name: str = "session-id"
+    _prefix: str = "lti1p3-"
+
+    def __init__(self, *args, **kwargs) -> None:
+        pass
+
+    def set_request(self, request: Request) -> None:
+        self._request = request
+
+    def get_session_cookie_name(self) -> t.Optional[str]:
+        return self._session_cookie_name
+
+    def get_session_id(self) -> t.Optional[str]:
+        return self._session_id
+
+    def set_session_id(self, session_id: str) -> None:
+        self._session_id = session_id
+
+    def remove_session_id(self) -> None:
+        self._session_id = None
+
+    def _prepare_key(self, key: str) -> str:
+        if self._session_id:
+            if key.startswith(self._prefix):
+                key = key[len(self._prefix) :]
+            return self._prefix + self._session_id + "-" + key
+        if not key.startswith(self._prefix):
+            key = self._prefix + key
+        return key
+
+    @abstractmethod
+    def can_set_keys_expiration(self) -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_value(self, key: str) -> T:
+        raise NotImplementedError
+
+    @abstractmethod
+    def set_value(self, key: str, value: T, exp: t.Optional[int] = None) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def check_value(self, key: str) -> bool:
+        raise NotImplementedError
+
+
+class DisableSessionId:
+    _session_id: t.Optional[str] = None
+    _launch_data_storage: t.Optional[LaunchDataStorage] = None
+
+    def __init__(self, launch_data_storage: t.Optional[LaunchDataStorage]) -> None:
+        self._launch_data_storage = launch_data_storage
+        if launch_data_storage:
+            self._session_id = launch_data_storage.get_session_id()
+
+    def __enter__(self) -> "DisableSessionId":
+        if self._launch_data_storage:
+            self._launch_data_storage.remove_session_id()
+        return self
+
+    def __exit__(self, *args) -> None:
+        if self._launch_data_storage and self._session_id:
+            self._launch_data_storage.set_session_id(self._session_id)

ltitoolkit/core/launch_data_storage/cache.py

@@ -0,0 +1,43 @@
+import typing as t
+
+from .base import LaunchDataStorage
+
+T = t.TypeVar("T")
+
+
+class CacheDataStorage(LaunchDataStorage[T], t.Generic[T]):
+    _cache = None
+
+    def get_session_cookie_name(self) -> t.Optional[str]:
+        """
+        Workaround for the local non-HTTP usage.
+        There is odd situation that all cookies become unavailable from some time
+        on the launch step (even if they were set in the new window).
+        Looks like it is bug in Chrome >= 80 related to SameSite changes.
+        So because of this we have to set all cache values without session prefix.
+        It is less secure because if you know unique launch_id you may get access to launch data,
+        but unfortunately there is no other way. So please use HTTPS on production :-)
+        """
+        assert self._request is not None, "Request should be set at this point"
+        if not self._request.is_secure():
+            return None
+        return super().get_session_cookie_name()
+
+    def _get_cache(self):
+        assert self._cache is not None, "Cache is not set"
+        return self._cache
+
+    def get_value(self, key) -> T:
+        key = self._prepare_key(key)
+        return self._get_cache().get(key)
+
+    def set_value(self, key: str, value: T, exp: t.Optional[int] = None) -> None:
+        key = self._prepare_key(key)
+        self._get_cache().set(key, value, exp)
+
+    def check_value(self, key: str) -> bool:
+        key = self._prepare_key(key)
+        return self._get_cache().get(key) is not None
+
+    def can_set_keys_expiration(self) -> bool:
+        return True

ltitoolkit/core/launch_data_storage/session.py

@@ -0,0 +1,29 @@
+import typing as t
+
+from .base import LaunchDataStorage
+
+T = t.TypeVar("T")
+
+
+class SessionDataStorage(LaunchDataStorage[T], t.Generic[T]):
+    def get_session_cookie_name(self) -> None:
+        return None
+
+    def set_session_id(self, session_id: str) -> None:
+        pass
+
+    def get_value(self, key: str) -> T:
+        assert self._request is not None, "Request should be set at this point"
+        return self._request.session.get(key, None)
+
+    def set_value(self, key: str, value: T, exp: t.Optional[int] = None) -> None:
+        # pylint: disable=unused-argument
+        assert self._request is not None, "Request should be set at this point"
+        self._request.session[key] = value
+
+    def check_value(self, key: str) -> bool:
+        assert self._request is not None, "Request should be set at this point"
+        return key in self._request.session
+
+    def can_set_keys_expiration(self) -> bool:
+        return False

ltitoolkit/core/lineitem.py

@@ -0,0 +1,205 @@
+import json
+import typing as t
+import typing_extensions as te
+from .exception import LtiException
+
+
+TSubmissionReview = te.TypedDict(
+    "TSubmissionReview",
+    {
+        # Required data
+        "reviewableStatus": list,
+        # Optional data
+        "label": str,
+        "url": str,
+        "custom": t.Dict[str, str],
+    },
+    total=False,
+)
+
+TLineItem = te.TypedDict(
+    "TLineItem",
+    {
+        "id": str,
+        "scoreMaximum": int,
+        "label": str,
+        "resourceId": str,
+        "tag": str,
+        "resourceLinkId": str,
+        "startDateTime": str,
+        "endDateTime": str,
+        "submissionReview": TSubmissionReview,
+    },
+    total=False,
+)
+
+
+class LineItem:
+    _id: t.Optional[str] = None
+    _score_maximum: t.Optional[float] = None
+    _label: t.Optional[str] = None
+    _resource_id: t.Optional[str] = None
+    _resource_link_id: t.Optional[str] = None
+    _tag: t.Optional[str] = None
+    _start_date_time: t.Optional[str] = None
+    _end_date_time: t.Optional[str] = None
+    _submission_review: t.Optional[TSubmissionReview] = None
+
+    def __init__(self, lineitem: t.Optional[TLineItem] = None):
+        if not lineitem:
+            lineitem = {}
+        self._id = lineitem.get("id")
+        self._score_maximum = lineitem.get("scoreMaximum")
+        self._label = lineitem.get("label")
+        self._resource_id = lineitem.get("resourceId")
+        self._resource_link_id = lineitem.get("resourceLinkId")
+        self._tag = lineitem.get("tag")
+        self._start_date_time = lineitem.get("startDateTime")
+        self._end_date_time = lineitem.get("endDateTime")
+        self._submission_review = lineitem.get("submissionReview")
+
+    def get_id(self) -> t.Optional[str]:
+        return self._id
+
+    def set_id(self, value: str) -> "LineItem":
+        self._id = value
+        return self
+
+    def get_label(self) -> t.Optional[str]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#label
+        """
+        return self._label
+
+    def set_label(self, value: str) -> "LineItem":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#label
+        """
+        self._label = value
+        return self
+
+    def get_score_maximum(self) -> t.Optional[float]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#scoremaximum
+        """
+        return self._score_maximum
+
+    def set_score_maximum(self, value: float) -> "LineItem":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#scoremaximum
+        """
+        if not isinstance(value, (int, float)):
+            raise LtiException(
+                "Invalid scoreMaximum value: score must be integer or float"
+            )
+        if value <= 0:
+            raise LtiException(
+                "Invalid scoreMaximum value: score must be non null value, strictly greater than 0"
+            )
+
+        self._score_maximum = value
+        return self
+
+    def get_resource_id(self) -> t.Optional[str]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#tool-resource-identifier-resourceid
+        """
+        return self._resource_id
+
+    def set_resource_id(self, value: str) -> "LineItem":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#tool-resource-identifier-resourceid
+        """
+        self._resource_id = value
+        return self
+
+    def get_resource_link_id(self) -> t.Optional[str]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0#resourcelinkid-and-binding-a-line-item-to-a-resource-link
+        """
+        return self._resource_link_id
+
+    def set_resource_link_id(self, value: str) -> "LineItem":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0#resourcelinkid-and-binding-a-line-item-to-a-resource-link
+        """
+        self._resource_link_id = value
+        return self
+
+    def get_tag(self) -> t.Optional[str]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#tag
+        """
+        return self._tag
+
+    def set_tag(self, value: str) -> "LineItem":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#tag
+        """
+        self._tag = value
+        return self
+
+    def get_start_date_time(self) -> t.Optional[str]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#startdatetime
+        """
+        return self._start_date_time
+
+    def set_start_date_time(self, value: str) -> "LineItem":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#startdatetime
+        """
+        self._start_date_time = value
+        return self
+
+    def get_end_date_time(self) -> t.Optional[str]:
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#enddatetime
+        """
+        return self._end_date_time
+
+    def set_end_date_time(self, value: str) -> "LineItem":
+        """
+        https://www.imsglobal.org/spec/lti-ags/v2p0/#enddatetime
+        """
+        self._end_date_time = value
+        return self
+
+    def get_submission_review(self) -> t.Optional[TSubmissionReview]:
+        return self._submission_review
+
+    def set_submission_review(
+        self,
+        reviewable_status: t.List,
+        label: t.Optional[str] = None,
+        url: t.Optional[str] = None,
+        custom: t.Optional[t.Dict[str, str]] = None,
+    ) -> "LineItem":
+        if not isinstance(reviewable_status, list):
+            raise Exception('Invalid "reviewable_status" argument')
+
+        self._submission_review: TSubmissionReview = {
+            "reviewableStatus": reviewable_status
+        }
+        if label:
+            self._submission_review["label"] = label
+        if url:
+            self._submission_review["url"] = url
+        if custom:
+            self._submission_review["custom"] = custom
+
+        return self
+
+    def get_value(self) -> str:
+        data = {
+            "id": self._id if self._id else None,
+            "scoreMaximum": self._score_maximum,
+            "label": self._label,
+            "resourceId": self._resource_id,
+            "resourceLinkId": self._resource_link_id,
+            "tag": self._tag,
+            "startDateTime": self._start_date_time,
+            "endDateTime": self._end_date_time,
+            "submissionReview": self._submission_review,
+        }
+        return json.dumps({k: v for k, v in data.items() if v})