scratchattach 2.1.15b0__py3-none-any.whl → 3.0.0b0__py3-none-any.whl

scratchattach/site/activity.py

@@ -1,382 +0,0 @@
-"""Activity and CloudActivity class"""
-from __future__ import annotations
-
-from bs4 import PageElement
-
-from . import user, project, studio
-from ._base import BaseSiteComponent
-from scratchattach.utils import exceptions
-
-
-class Activity(BaseSiteComponent):
-    """
-    Represents a Scratch activity (message or other user page activity)
-    """
-
-    def __repr__(self):
-        return f"Activity({repr(self.raw)})"
-
-    def __str__(self):
-        return str(self.raw)
-
-    def __init__(self, **entries):
-        # Set attributes every Activity object needs to have:
-        self._session = None
-        self.raw = None
-
-        # Possible attributes
-        self.project_id = None
-        self.gallery_id = None
-
-        self.username = None
-        self.followed_username = None
-        self.recipient_username = None
-
-        self.comment_type = None
-        self.comment_obj_id = None
-        self.comment_obj_title = None
-        self.comment_id = None
-
-        self.datetime_created = None
-        self.time = None
-        self.type = None
-
-        # Update attributes from entries dict:
-        self.__dict__.update(entries)
-
-    def update(self):
-        print("Warning: Activity objects can't be updated")
-        return False  # Objects of this type cannot be updated
-
-    def _update_from_dict(self, data):
-        self.raw = data
-        self.__dict__.update(data)
-        return True
-
-    def _update_from_json(self, data: dict):
-        """
-        Update using JSON, used in the classroom API.
-        """
-        activity_type = data["type"]
-
-        _time = data["datetime_created"] if "datetime_created" in data else None
-
-        if "actor" in data:
-            username = data["actor"]["username"]
-        elif "actor_username" in data:
-            username = data["actor_username"]
-        else:
-            username = None
-
-        if data.get("recipient") is not None:
-            recipient_username = data["recipient"]["username"]
-
-        elif data.get("recipient_username") is not None:
-            recipient_username = data["recipient_username"]
-
-        elif data.get("project_creator") is not None:
-            recipient_username = data["project_creator"]["username"]
-        else:
-            recipient_username = None
-
-        default_case = False
-        # Even if `activity_type` is an invalid value; it will default to 'user performed an action'
-
-        if activity_type == 0:
-            # follow
-            followed_username = data["followed_username"]
-
-            self.raw = f"{username} followed user {followed_username}"
-
-            self.datetime_created = _time
-            self.type = "followuser"
-            self.username = username
-            self.followed_username = followed_username
-
-        elif activity_type == 1:
-            # follow studio
-            studio_id = data["gallery"]
-
-            raw = f"{username} followed studio https://scratch.mit.edu/studios/{studio_id}"
-
-            self.raw = raw
-            self.datetime_created = _time
-            self.type = "followstudio"
-
-            self.username = username
-            self.gallery_id = studio_id
-
-        elif activity_type == 2:
-            # love project
-            project_id = data["project"]
-
-            raw = f"{username} loved project https://scratch.mit.edu/projects/{project_id}"
-
-            self.raw = raw
-            self.datetime_created = _time,
-            self.type = "loveproject"
-
-            self.username = username
-            self.project_id = project_id
-            self.recipient_username = recipient_username
-
-        elif activity_type == 3:
-            # Favorite project
-            project_id = data["project"]
-
-            raw = f"{username} favorited project https://scratch.mit.edu/projects/{project_id}"
-
-            self.raw = raw
-            self.datetime_created = _time
-            self.type = "favoriteproject"
-
-            self.username = username
-            self.project_id = project_id
-            self.recipient_username = recipient_username
-
-        elif activity_type == 7:
-            # Add project to studio
-
-            project_id = data["project"]
-            studio_id = data["gallery"]
-
-            raw = f"{username} added the project https://scratch.mit.edu/projects/{project_id} to studio https://scratch.mit.edu/studios/{studio_id}"
-
-            self.raw = raw
-            self.datetime_created = _time
-            self.type = "addprojecttostudio"
-
-            self.username = username
-            self.project_id = project_id
-            self.recipient_username = recipient_username
-
-        elif activity_type in (8, 9, 10):
-            # Share/Reshare project
-            project_id = data["project"]
-            is_reshare = data["is_reshare"]
-
-            raw_reshare = "reshared" if is_reshare else "shared"
-
-            raw = f"{username} {raw_reshare} the project https://scratch.mit.edu/projects/{project_id}"
-
-            self.raw = raw
-            self.datetime_created = _time
-            self.type = "shareproject"
-
-            self.username = username
-            self.project_id = project_id
-            self.recipient_username = recipient_username
-
-        elif activity_type == 11:
-            # Remix
-            parent_id = data["parent"]
-
-            raw = f"{username} remixed the project https://scratch.mit.edu/projects/{parent_id}"
-
-            self.raw = raw
-            self.datetime_created = _time
-            self.type = "remixproject"
-
-            self.username = username
-            self.project_id = parent_id
-            self.recipient_username = recipient_username
-
-        # type 12 does not exist in the HTML. That's why it was removed, not merged with type 13.
-        
-        elif activity_type == 13:
-            # Create ('add') studio
-            studio_id = data["gallery"]
-
-            raw = f"{username} created the studio https://scratch.mit.edu/studios/{studio_id}"
-
-            self.raw = raw
-            self.datetime_created = _time
-            self.type = "createstudio"
-
-            self.username = username
-            self.gallery_id = studio_id
-
-        elif activity_type == 15:
-            # Update studio
-            studio_id = data["gallery"]
-
-            raw = f"{username} updated the studio https://scratch.mit.edu/studios/{studio_id}"
-
-            self.raw = raw
-            self.datetime_created = _time
-            self.type = "updatestudio"
-
-            self.username = username
-            self.gallery_id = studio_id
-
-        elif activity_type in (16, 17, 18, 19):
-            # Remove project from studio
-
-            project_id = data["project"]
-            studio_id = data["gallery"]
-
-            raw = f"{username} removed the project https://scratch.mit.edu/projects/{project_id} from studio https://scratch.mit.edu/studios/{studio_id}"
-
-            self.raw = raw
-            self.datetime_created = _time
-            self.type = "removeprojectfromstudio"
-
-            self.username = username
-            self.project_id = project_id
-
-        elif activity_type in (20, 21, 22):
-            # Was promoted to manager for studio
-            studio_id = data["gallery"]
-
-            raw = f"{recipient_username} was promoted to manager by {username} for studio https://scratch.mit.edu/studios/{studio_id}"
-
-            self.raw = raw
-            self.datetime_created = _time
-            self.type = "promotetomanager"
-
-            self.username = username
-            self.recipient_username = recipient_username
-            self.gallery_id = studio_id
-
-        elif activity_type in (23, 24, 25):
-            # Update profile
-            raw = f"{username} made a profile update"
-
-            self.raw = raw
-            self.datetime_created = _time
-            self.type = "updateprofile"
-
-            self.username = username
-
-        elif activity_type in (26, 27):
-            # Comment (quite complicated)
-            comment_type: int = data["comment_type"]
-            fragment = data["comment_fragment"]
-            comment_id = data["comment_id"]
-            comment_obj_id = data["comment_obj_id"]
-            comment_obj_title = data["comment_obj_title"]
-
-            if comment_type == 0:
-                # Project comment
-                raw = f"{username} commented on project https://scratch.mit.edu/projects/{comment_obj_id}/#comments-{comment_id} {fragment!r}"
-
-            elif comment_type == 1:
-                # Profile comment
-                raw = f"{username} commented on user https://scratch.mit.edu/users/{comment_obj_title}/#comments-{comment_id} {fragment!r}"
-
-            elif comment_type == 2:
-                # Studio comment
-                # Scratch actually provides an incorrect link, but it is fixed here:
-                raw = f"{username} commented on studio https://scratch.mit.edu/studios/{comment_obj_id}/comments/#comments-{comment_id} {fragment!r}"
-
-            else:
-                raw = f"{username} commented {fragment!r}"  # This should never happen
-
-            self.raw = raw
-            self.datetime_created = _time
-            self.type = "addcomment"
-
-            self.username = username
-
-            self.comment_type = comment_type
-            self.comment_obj_id = comment_obj_id
-            self.comment_obj_title = comment_obj_title
-            self.comment_id = comment_id
-        else:
-            default_case = True
-
-        if default_case:
-            # This is coded in the scratch HTML, haven't found an example of it though
-            raw = f"{username} performed an action."
-
-            self.raw = raw
-            self.datetime_created = _time
-            self.type = "performaction"
-
-            self.username = username
-
-    def _update_from_html(self, data: PageElement):
-
-        self.raw = data
-
-        _time = data.find('div').find('span').findNext().findNext().text.strip()
-
-        if '\xa0' in _time:
-            while '\xa0' in _time:
-                _time = _time.replace('\xa0', ' ')
-
-        self.datetime_created = _time
-        self.actor_username = data.find('div').find('span').text
-
-        self.target_name = data.find('div').find('span').findNext().text
-        self.target_link = data.find('div').find('span').findNext()["href"]
-        self.target_id = data.find('div').find('span').findNext()["href"].split("/")[-2]
-
-        self.type = data.find('div').find_all('span')[0].next_sibling.strip()
-        if self.type == "loved":
-            self.type = "loveproject"
-
-        elif self.type == "favorited":
-            self.type = "favoriteproject"
-
-        elif "curator" in self.type:
-            self.type = "becomecurator"
-
-        elif "shared" in self.type:
-            self.type = "shareproject"
-
-        elif "is now following" in self.type:
-            if "users" in self.target_link:
-                self.type = "followuser"
-            else:
-                self.type = "followstudio"
-
-        return True
-
-    def actor(self):
-        """
-        Returns the user that performed the activity as User object
-        """
-        return self._make_linked_object("username", self.actor_username, user.User, exceptions.UserNotFound)
-
-    def target(self):
-        """
-        Returns the activity's target (depending on the activity, this is either a User, Project, Studio or Comment object).
-        May also return None if the activity type is unknown.
-        """
-
-        if "project" in self.type:  # target is a project
-            if "target_id" in self.__dict__:
-                return self._make_linked_object("id", self.target_id, project.Project, exceptions.ProjectNotFound)
-            if "project_id" in self.__dict__:
-                return self._make_linked_object("id", self.project_id, project.Project, exceptions.ProjectNotFound)
-
-        if self.type == "becomecurator" or self.type == "followstudio":  # target is a studio
-            if "target_id" in self.__dict__:
-                return self._make_linked_object("id", self.target_id, studio.Studio, exceptions.StudioNotFound)
-            if "gallery_id" in self.__dict__:
-                return self._make_linked_object("id", self.gallery_id, studio.Studio, exceptions.StudioNotFound)
-            # NOTE: the "becomecurator" type is ambigous - if it is inside the studio activity tab, the target is the user who joined
-            if "username" in self.__dict__:
-                return self._make_linked_object("username", self.username, user.User, exceptions.UserNotFound)
-
-        if self.type == "followuser" or "curator" in self.type:  # target is a user
-            if "target_name" in self.__dict__:
-                return self._make_linked_object("username", self.target_name, user.User, exceptions.UserNotFound)
-            if "followed_username" in self.__dict__:
-                return self._make_linked_object("username", self.followed_username, user.User, exceptions.UserNotFound)
-        if "recipient_username" in self.__dict__:  # the recipient_username field always indicates the target is a user
-            return self._make_linked_object("username", self.recipient_username, user.User, exceptions.UserNotFound)
-
-        if self.type == "addcomment":  # target is a comment
-            if self.comment_type == 0:
-                _c = project.Project(id=self.comment_obj_id, author_name=self._session.username,
-                                     _session=self._session).comment_by_id(self.comment_id)
-            if self.comment_type == 1:
-                _c = user.User(username=self.comment_obj_title, _session=self._session).comment_by_id(self.comment_id)
-            if self.comment_type == 2:
-                _c = user.User(id=self.comment_obj_id, _session=self._session).comment_by_id(self.comment_id)
-            else:
-                raise ValueError(f"{self.comment_type} is an invalid comment type")
-
-            return _c

scratchattach/site/alert.py

@@ -1,227 +0,0 @@
-# classroom alerts (& normal alerts in the future)
-
-from __future__ import annotations
-
-import json
-import pprint
-import warnings
-from dataclasses import dataclass, field, KW_ONLY
-from datetime import datetime
-from typing import TYPE_CHECKING, Any, Optional, Union
-from typing_extensions import Self
-
-from . import user, project, studio, comment, session
-from scratchattach.utils import enums
-
-if TYPE_CHECKING:
-    ...
-
-
-# todo: implement regular alerts
-# If you implement regular alerts, it may be applicable to make EducatorAlert a subclass.
-
-
-@dataclass
-class EducatorAlert:
-    """
-    Represents an alert for student activity, viewable at https://scratch.mit.edu/site-api/classrooms/alerts/
-
-    Attributes:
-        model: The type of alert (presumably); should always equal "educators.educatoralert" in this class
-        type: An integer that identifies the type of alert, differentiating e.g. against bans or autoban or censored comments etc
-        raw: The raw JSON data from the API
-        id: The ID of the alert (internally called 'pk' by scratch, not sure what this is for)
-        time_read: The time the alert was read
-        time_created: The time the alert was created
-        target: The user that the alert is about (the student)
-        actor: The user that created the alert (the admin)
-        target_object: The object that the alert is about (e.g. a project, studio, or comment)
-        notification_type: not sure what this is for, but inferred from the scratch HTML reference
-    """
-    _: KW_ONLY
-    # required attrs
-    target: user.User
-    actor: user.User
-    target_object: Optional[Union[project.Project, studio.Studio, comment.Comment, studio.Studio]]
-    notification_type: str
-    _session: Optional[session.Session]
-
-    # defaulted attrs
-    model: str = "educators.educatoralert"
-    type: int = -1
-    raw: dict = field(repr=False, default_factory=dict)
-    id: int = -1
-    time_read: datetime = datetime.fromtimestamp(0.0)
-    time_created: datetime = datetime.fromtimestamp(0.0)
-
-
-    @classmethod
-    def from_json(cls, data: dict[str, Any], _session: Optional[session.Session] = None) -> Self:
-        """
-        Load an EducatorAlert from a JSON object.
-
-        Arguments:
-            data (dict): The JSON object
-            _session (session.Session): The session object used to load this data, to 'connect' to the alerts rather than just 'get' them
-
-        Returns:
-            EducatorAlert: The loaded EducatorAlert object
-        """
-        model = data.get("model")  # With this class, should be equal to educators.educatoralert
-        assert isinstance(model, str)
-        alert_id = data.get("pk")  # not sure what kind of pk/id this is. Doesn't seem to be a user or class id.
-        assert isinstance(alert_id, int)
-
-        fields = data.get("fields")
-        assert isinstance(fields, dict)
-
-        time_read_raw = fields.get("educator_datetime_read")
-        assert isinstance(time_read_raw, str)
-        time_read: datetime = datetime.fromisoformat(time_read_raw)
-
-        admin_action = fields.get("admin_action")
-        assert isinstance(admin_action, dict)
-
-        time_created_raw = admin_action.get("datetime_created")
-        assert isinstance(time_created_raw, str)
-        time_created: datetime = datetime.fromisoformat(time_created_raw)
-
-        alert_type = admin_action.get("type")
-        assert isinstance(alert_type, int)
-
-        target_data = admin_action.get("target_user")
-        assert isinstance(target_data, dict)
-        target = user.User(username=target_data.get("username"),
-                           id=target_data.get("pk"),
-                           icon_url=target_data.get("thumbnail_url"),
-                           admin=target_data.get("admin", False),
-                           _session=_session)
-
-        actor_data = admin_action.get("actor")
-        assert isinstance(actor_data, dict)
-        actor = user.User(username=actor_data.get("username"),
-                          id=actor_data.get("pk"),
-                          icon_url=actor_data.get("thumbnail_url"),
-                          admin=actor_data.get("admin", False),
-                          _session=_session)
-
-        object_id = admin_action.get("object_id")  # this could be a comment id, a project id, etc.
-        assert isinstance(object_id, int)
-        target_object: project.Project | studio.Studio | comment.Comment | None = None
-
-        extra_data: dict[str, Any] = json.loads(admin_action.get("extra_data", "{}"))
-        # todo: if possible, properly implement the incomplete parts of this parser (look for warning.warn())
-        notification_type: str = ""
-
-        if "project_title" in extra_data:
-            # project
-            target_object = project.Project(id=object_id,
-                                            title=extra_data["project_title"],
-                                            _session=_session)
-        elif "comment_content" in extra_data:
-            # comment
-            comment_data: dict[str, Any] = extra_data["comment_content"]
-            content: str | None = comment_data.get("content")
-
-            comment_obj_id: int | None = comment_data.get("comment_obj_id")
-
-            comment_type: int | None = comment_data.get("comment_type")
-
-            if comment_type == 0:
-                # project
-                comment_source_type = "project"
-            elif comment_type == 1:
-                # profile
-                comment_source_type = "profile"
-            else:
-                # probably a studio
-                comment_source_type = "studio"
-                warnings.warn(
-                    f"The parser was not able to recognise the \"comment_type\" of {comment_type} in the alert JSON response.\n"
-                    f"Full response: \n{pprint.pformat(data)}.\n\n"
-                    f"Please draft an issue on github: https://github.com/TimMcCool/scratchattach/issues, providing this "
-                    f"whole error message. This will allow us to implement an incomplete part of this parser")
-
-            # the comment_obj's corresponding attribute of comment.Comment is the place() method. As it has no cache, the title data is wasted.
-            # if the comment_obj is deleted, this is still a valid way of working out the title/username
-
-            target_object = comment.Comment(
-                id=object_id,
-                content=content,
-                source=comment_source_type,
-                source_id=comment_obj_id,
-                _session=_session
-            )
-
-        elif "gallery_title" in extra_data:
-            # studio
-            # possible implemented incorrectly
-            target_object = studio.Studio(
-                id=object_id,
-                title=extra_data["gallery_title"],
-                _session=_session
-            )
-        elif "notification_type" in extra_data:
-            # possible implemented incorrectly
-            notification_type = extra_data["notification_type"]
-        else:
-            warnings.warn(
-                f"The parser was not able to recognise the \"extra_data\" in the alert JSON response.\n"
-                f"Full response: \n{pprint.pformat(data)}.\n\n"
-                f"Please draft an issue on github: https://github.com/TimMcCool/scratchattach/issues, providing this "
-                f"whole error message. This will allow us to implement an incomplete part of this parser")
-
-        return cls(
-            id=alert_id,
-            model=model,
-            type=alert_type,
-            raw=data,
-            time_read=time_read,
-            time_created=time_created,
-            target=target,
-            actor=actor,
-            target_object=target_object,
-            notification_type=notification_type,
-            _session=_session
-        )
-
-    def __str__(self):
-        return f"EducatorAlert: {self.message}"
-
-    @property
-    def alert_type(self) -> enums.AlertType:
-        """
-        Get an associated AlertType object for this alert (based on the type index)
-        """
-        alert_type = enums.AlertTypes.find(self.type)
-        if not alert_type:
-            alert_type = enums.AlertTypes.default.value
-
-        return alert_type
-
-    @property
-    def message(self):
-        """
-        Format the alert message using the alert type's message template, as it would be on the website.
-        """
-        raw_message = self.alert_type.message
-        comment_content = ""
-        if isinstance(self.target_object, comment.Comment):
-            comment_content = self.target_object.content
-
-        return raw_message.format(username=self.target.username,
-                                  project=self.target_object_title,
-                                  studio=self.target_object_title,
-                                  notification_type=self.notification_type,
-                                  comment=comment_content)
-
-    @property
-    def target_object_title(self):
-        """
-        Get the title of the target object (if applicable)
-        """
-        if isinstance(self.target_object, project.Project):
-            return self.target_object.title
-        if isinstance(self.target_object, studio.Studio):
-            return self.target_object.title
-        return None  # explicit