scratchattach 2.1.9__py3-none-any.whl → 2.1.10a1__py3-none-any.whl

scratchattach/site/cloud_activity.py

@@ -1,103 +1,107 @@
-import time
-from ._base import BaseSiteComponent
-
-class CloudActivity(BaseSiteComponent):
-    """
-    Represents a cloud activity (a cloud variable set / creation / deletion).
-
-    Attributes:
-
-    :.username: The user who caused the cloud event (the user who added / set / deleted the cloud variable)
-
-    :.var: The name of the cloud variable that was updated (specified without the cloud emoji)
-
-    :.name: The name of the cloud variable that was updated (specified without the cloud emoji)
-
-    :.type: The activity type
-
-    :.timestamp: Then timestamp of when the action was performed
-
-    :.value: If the cloud variable was set, then this attribute provides the value the cloud variable was set to
-    
-    :.cloud: The cloud (as object inheriting from scratchattach.Cloud.BaseCloud) that the cloud activity corresponds to
-    """
-
-    def __init__(self, **entries):
-        # Set attributes every CloudActivity object needs to have:
-        self._session = None
-        self.cloud = None
-        self.user = None
-        self.username = None
-        self.type = None
-        self.timestamp = time.time()
-
-        # Update attributes from entries dict:
-        self.__dict__.update(entries)
-
-    def update(self):
-        print("Warning: CloudActivity objects can't be updated")
-        return False # Objects of this type cannot be updated
-
-    def __eq__(self, activity2):
-        # CloudLogEvents needs to check if two activites are equal (to finde new ones), therefore CloudActivity objects need to be comparable
-        return self.user == activity2.user and self.type == activity2.type and self.timestamp == activity2.timestamp and self.value == activity2.value and self.name == activity2.name
-    
-    def _update_from_dict(self, data) -> bool:
-        try: self.name = data["name"]
-        except Exception: pass
-        try: self.var = data["name"]
-        except Exception: pass
-        try: self.value = data["value"]
-        except Exception: pass
-        try: self.user = data["user"]
-        except Exception: pass
-        try: self.username = data["user"]
-        except Exception: pass
-        try: self.timestamp = data["timestamp"]
-        except Exception: pass
-        try: self.type = data["verb"].replace("_var","")
-        except Exception: pass
-        try: self.type = data["method"]
-        except Exception: pass
-        try: self.cloud = data["cloud"]
-        except Exception: pass
-        return True
-
-    def load_log_data(self):
-        if self.cloud is None:
-            print("Warning: There aren't cloud logs available for this cloud, therefore the user and exact timestamp can't be loaded")
-        else:
-            if hasattr(self.cloud, "logs"):
-                logs = self.cloud.logs(filter_by_var_named=self.var, limit=100)
-                matching = list(filter(lambda x: x.value == self.value and x.timestamp <= self.timestamp, logs))
-                if matching == []:
-                    return False
-                activity = matching[0]
-                self.username = activity.username
-                self.user = activity.username
-                self.timestamp = activity.timestamp
-                return True
-            else:
-                print("Warning: There aren't cloud logs available for this cloud, therefore the user and exact timestamp can't be loaded")
-        return False
-    
-    def actor(self):
-        """
-        Returns the user that performed the cloud activity as scratchattach.user.User object
-        """
-        if self.username is None:
-            return None
-        from ..site import user
-        from ..utils import exceptions
-        return self._make_linked_object("username", self.username, user.User, exceptions.UserNotFound)
-
-    def project(self):
-        """
-        Returns the project where the cloud activity was performed as scratchattach.project.Project object
-        """
-        if self.cloud is None:
-            return None
-        from ..site import project
-        from ..utils import exceptions
-        return self._make_linked_object("id", self.cloud.project_id, project.Project, exceptions.ProjectNotFound)
-
+from __future__ import annotations
+
+import time
+from ._base import BaseSiteComponent
+
+
+
+class CloudActivity(BaseSiteComponent):
+    """
+    Represents a cloud activity (a cloud variable set / creation / deletion).
+
+    Attributes:
+
+    :.username: The user who caused the cloud event (the user who added / set / deleted the cloud variable)
+
+    :.var: The name of the cloud variable that was updated (specified without the cloud emoji)
+
+    :.name: The name of the cloud variable that was updated (specified without the cloud emoji)
+
+    :.type: The activity type
+
+    :.timestamp: Then timestamp of when the action was performed
+
+    :.value: If the cloud variable was set, then this attribute provides the value the cloud variable was set to
+    
+    :.cloud: The cloud (as object inheriting from scratchattach.Cloud.BaseCloud) that the cloud activity corresponds to
+    """
+
+    def __init__(self, **entries):
+        # Set attributes every CloudActivity object needs to have:
+        self._session = None
+        self.cloud = None
+        self.user = None
+        self.username = None
+        self.type = None
+        self.timestamp = time.time()
+
+        # Update attributes from entries dict:
+        self.__dict__.update(entries)
+
+    def update(self):
+        print("Warning: CloudActivity objects can't be updated")
+        return False # Objects of this type cannot be updated
+
+    def __eq__(self, activity2):
+        # CloudLogEvents needs to check if two activites are equal (to finde new ones), therefore CloudActivity objects need to be comparable
+        return self.user == activity2.user and self.type == activity2.type and self.timestamp == activity2.timestamp and self.value == activity2.value and self.name == activity2.name
+    
+    def _update_from_dict(self, data) -> bool:
+        try: self.name = data["name"]
+        except Exception: pass
+        try: self.var = data["name"]
+        except Exception: pass
+        try: self.value = data["value"]
+        except Exception: pass
+        try: self.user = data["user"]
+        except Exception: pass
+        try: self.username = data["user"]
+        except Exception: pass
+        try: self.timestamp = data["timestamp"]
+        except Exception: pass
+        try: self.type = data["verb"].replace("_var","")
+        except Exception: pass
+        try: self.type = data["method"]
+        except Exception: pass
+        try: self.cloud = data["cloud"]
+        except Exception: pass
+        return True
+
+    def load_log_data(self):
+        if self.cloud is None:
+            print("Warning: There aren't cloud logs available for this cloud, therefore the user and exact timestamp can't be loaded")
+        else:
+            if hasattr(self.cloud, "logs"):
+                logs = self.cloud.logs(filter_by_var_named=self.var, limit=100)
+                matching = list(filter(lambda x: x.value == self.value and x.timestamp <= self.timestamp, logs))
+                if matching == []:
+                    return False
+                activity = matching[0]
+                self.username = activity.username
+                self.user = activity.username
+                self.timestamp = activity.timestamp
+                return True
+            else:
+                print("Warning: There aren't cloud logs available for this cloud, therefore the user and exact timestamp can't be loaded")
+        return False
+    
+    def actor(self):
+        """
+        Returns the user that performed the cloud activity as scratchattach.user.User object
+        """
+        if self.username is None:
+            return None
+        from ..site import user
+        from ..utils import exceptions
+        return self._make_linked_object("username", self.username, user.User, exceptions.UserNotFound)
+
+    def project(self):
+        """
+        Returns the project where the cloud activity was performed as scratchattach.project.Project object
+        """
+        if self.cloud is None:
+            return None
+        from ..site import project
+        from ..utils import exceptions
+        return self._make_linked_object("id", self.cloud.project_id, project.Project, exceptions.ProjectNotFound)
+

scratchattach/site/comment.py

@@ -1,190 +1,220 @@
-"""Comment class"""
-
-import json
-import re
-
-from ..utils import commons
-
-from . import user
-from . import session
-from . import project
-from . import studio
-from . import forum
-from ..utils import exceptions
-from ._base import BaseSiteComponent
-from ..utils.commons import headers
-from bs4 import BeautifulSoup
-
-from ..utils.requests import Requests as requests
-
-class Comment(BaseSiteComponent):
-
-    '''
-    Represents a Scratch comment (on a profile, studio or project)
-    '''
-
-    def str(self):
-        return str(self.content)
-
-    def __init__(self, **entries):
-
-        # Set attributes every Comment object needs to have:
-        self.id = None
-        self._session = None
-        self.source=None
-        self.source_id = None
-        self.cached_replies = None
-        self.parent_id = None
-        self.cached_parent_comment = None
-        if not "source" in entries:
-            "source" == "Unknown"
-
-        # Update attributes from entries dict:
-        self.__dict__.update(entries)
-
-    def update(self):
-        print("Warning: Comment objects can't be updated")
-        return False # Objects of this type cannot be updated
-
-    def _update_from_dict(self, data):
-        try: self.id = data["id"]
-        except Exception: pass
-        try: self.parent_id = data["parent_id"]
-        except Exception: pass
-        try: self.commentee_id = data["commentee_id"]
-        except Exception: pass
-        try: self.content = data["content"]
-        except Exception: pass
-        try: self.datetime_created = data["datetime_created"]
-        except Exception: pass
-        try: self.author_name = data["author"]["username"]
-        except Exception: pass
-        try: self.author_id = data["author"]["id"]
-        except Exception: pass
-        try: self.written_by_scratchteam = data["author"]["scratchteam"]
-        except Exception: pass
-        try: self.reply_count = data["reply_count"]
-        except Exception: pass
-        try: self.source = data["source"]
-        except Exception: pass
-        try: self.source_id = data["source_id"]
-        except Exception: pass
-        return True
-
-    # Methods for getting related entities
-
-    def author(self):
-        return self._make_linked_object("username", self.author_name, user.User, exceptions.UserNotFound)
-
-    def place(self):
-        """
-        Returns the place (the project, profile or studio) where the comment was posted as Project, User, or Studio object.
-
-        If the place can't be traced back, None is returned.
-        """
-        if self.source == "profile":
-            return self._make_linked_object("username", self.source_id, user.User, exceptions.UserNotFound)
-        if self.source == "studio":
-            return self._make_linked_object("id", self.source_id, studio.Studio, exceptions.UserNotFound)
-        if self.source == "project":
-            return self._make_linked_object("id", self.source_id, project.Project, exceptions.UserNotFound)
-
-    def parent_comment(self):
-        if self.parent_id is None:
-            return None
-        if self.cached_parent_comment is not None:
-            return self.cached_parent_comment
-        if self.source == "profile":
-            self.cached_parent_comment = user.User(username=self.source_id, _session=self._session).comment_by_id(self.parent_id)
-        if self.source == "project":
-            p = project.Project(id=self.source_id, _session=self._session)
-            p.update()
-            self.cached_parent_comment = p.comment_by_id(self.parent_id)
-        if self.source == "studio":
-            self.cached_parent_comment = studio.Studio(id=self.source_id, _session=self._session).comment_by_id(self.parent_id)
-        return self.cached_parent_comment
-    
-    def replies(self, *, use_cache=True, limit=40, offset=0):
-        """
-        Keyword Arguments:
-            use_cache (bool): Returns the replies cached on the first reply fetch. This makes it SIGNIFICANTLY faster for profile comments. Warning: For profile comments, the replies are retrieved and cached on object creation.
-        """
-        if (self.cached_replies is None) or (use_cache is False):
-            if self.source == "profile":
-                self.cached_replies = user.User(username=self.source_id, _session=self._session).comment_by_id(self.id).cached_replies[offset:offset+limit]
-            if self.source == "project":
-                p = project.Project(id=self.source_id, _session=self._session)
-                p.update()
-                self.cached_replies = p.comment_replies(comment_id=self.id, limit=limit, offset=offset)
-            if self.source == "studio":
-                self.cached_replies = studio.Studio(id=self.source_id, _session=self._session).comment_replies(comment_id=self.id, limit=limit, offset=offset)
-        return self.cached_replies
-    
-    # Methods for dealing with the comment
-
-    def reply(self, content, *, commentee_id=None):
-        """
-        Posts a reply comment to the comment.
-        
-        Warning:
-            Scratch only shows comments replying to top-level comments, and all replies to replies are actually replies to top-level comments in the API.
-
-            Therefore, if this comment is a reply, this method will not reply to the comment itself but to the corresponding top-level comment.
-    
-        Args:
-            content (str): Comment content to post.
-
-        Keyword args:
-            commentee_id (None or str): If set to None (default), it will automatically fill out the commentee ID with the user ID of the parent comment author. Set it to "" to mention no user.
-
-
-        Returns:
-            scratchattach.Comment: The created comment.
-        """
-
-        self._assert_auth()
-        parent_id = str(self.id)
-        if self.parent_id is not None:
-            parent_id = str(self.parent_id)
-        if commentee_id is None:
-            if "author_id" in self.__dict__:
-                commentee_id = self.author_id
-            else:
-                commentee_id = ""
-        if self.source == "profile":
-            return user.User(username=self.source_id, _session=self._session).reply_comment(content, parent_id=str(parent_id), commentee_id=commentee_id)
-        if self.source == "project":
-            p = project.Project(id=self.source_id, _session=self._session)
-            p.update()
-            return p.reply_comment(content, parent_id=str(parent_id), commentee_id=commentee_id)
-        if self.source == "studio":
-            return studio.Studio(id=self.source_id, _session=self._session).reply_comment(content, parent_id=str(parent_id), commentee_id=commentee_id)
-
-
-    def delete(self):
-        """
-        Deletes the comment.
-        """
-        self._assert_auth()
-        if self.source == "profile":
-            user.User(username=self.source_id, _session=self._session).delete_comment(comment_id=self.id)
-        if self.source == "project":
-            p = project.Project(id=self.source_id, _session=self._session)
-            p.update()
-            p.delete_comment(comment_id=self.id)
-        if self.source == "studio":
-            studio.Studio(id=self.source_id, _session=self._session).delete_comment(comment_id=self.id)
-
-    def report(self):
-        """
-        Reports the comment to the Scratch team.
-        """
-        self._assert_auth()
-        if self.source == "profile":
-            user.User(username=self.source_id, _session=self._session).report_comment(comment_id=self.id)
-        if self.source == "project":
-            p = project.Project(id=self.source_id, _session=self._session)
-            p.update()
-            p.report_comment(comment_id=self.id)
-        if self.source == "studio":
-            studio.Studio(id=self.source_id, _session=self._session).report_comment(comment_id=self.id)
+"""Comment class"""
+from __future__ import annotations
+
+from . import user, project, studio
+from ._base import BaseSiteComponent
+from ..utils import exceptions
+
+
+class Comment(BaseSiteComponent):
+    """
+    Represents a Scratch comment (on a profile, studio or project)
+    """
+
+    def str(self):
+        return str(self.content)
+
+    def __init__(self, **entries):
+
+        # Set attributes every Comment object needs to have:
+        self.id = None
+        self._session = None
+        self.source = None
+        self.source_id = None
+        self.cached_replies = None
+        self.parent_id = None
+        self.cached_parent_comment = None
+
+        # Update attributes from entries dict:
+        self.__dict__.update(entries)
+
+        if "source" not in entries:
+            self.source = "Unknown"
+
+    def update(self):
+        print("Warning: Comment objects can't be updated")
+        return False  # Objects of this type cannot be updated
+
+    def _update_from_dict(self, data):
+        try:
+            self.id = data["id"]
+        except Exception:
+            pass
+        try:
+            self.parent_id = data["parent_id"]
+        except Exception:
+            pass
+        try:
+            self.commentee_id = data["commentee_id"]
+        except Exception:
+            pass
+        try:
+            self.content = data["content"]
+        except Exception:
+            pass
+        try:
+            self.datetime_created = data["datetime_created"]
+        except Exception:
+            pass
+        try:
+            self.author_name = data["author"]["username"]
+        except Exception:
+            pass
+        try:
+            self.author_id = data["author"]["id"]
+        except Exception:
+            pass
+        try:
+            self.written_by_scratchteam = data["author"]["scratchteam"]
+        except Exception:
+            pass
+        try:
+            self.reply_count = data["reply_count"]
+        except Exception:
+            pass
+        try:
+            self.source = data["source"]
+        except Exception:
+            pass
+        try:
+            self.source_id = data["source_id"]
+        except Exception:
+            pass
+        return True
+
+    # Methods for getting related entities
+
+    def author(self) -> user.User:
+        return self._make_linked_object("username", self.author_name, user.User, exceptions.UserNotFound)
+
+    def place(self) -> user.User | studio.Studio | project.Project:
+        """
+        Returns the place (the project, profile or studio) where the comment was posted as Project, User, or Studio object.
+
+        If the place can't be traced back, None is returned.
+        """
+        if self.source == "profile":
+            return self._make_linked_object("username", self.source_id, user.User, exceptions.UserNotFound)
+        if self.source == "studio":
+            return self._make_linked_object("id", self.source_id, studio.Studio, exceptions.UserNotFound)
+        if self.source == "project":
+            return self._make_linked_object("id", self.source_id, project.Project, exceptions.UserNotFound)
+
+    def parent_comment(self) -> Comment | None:
+        if self.parent_id is None:
+            return None
+
+        if self.cached_parent_comment is not None:
+            return self.cached_parent_comment
+
+        if self.source == "profile":
+            self.cached_parent_comment = user.User(username=self.source_id, _session=self._session).comment_by_id(
+                self.parent_id)
+
+        elif self.source == "project":
+            p = project.Project(id=self.source_id, _session=self._session)
+            p.update()
+            self.cached_parent_comment = p.comment_by_id(self.parent_id)
+
+        elif self.source == "studio":
+            self.cached_parent_comment = studio.Studio(id=self.source_id, _session=self._session).comment_by_id(
+                self.parent_id)
+
+        return self.cached_parent_comment
+
+    def replies(self, *, use_cache: bool = True, limit=40, offset=0):
+        """
+        Keyword Arguments:
+            use_cache (bool): Returns the replies cached on the first reply fetch. This makes it SIGNIFICANTLY faster for profile comments. Warning: For profile comments, the replies are retrieved and cached on object creation.
+        """
+        if (self.cached_replies is None) or (not use_cache):
+            if self.source == "profile":
+                self.cached_replies = user.User(username=self.source_id, _session=self._session).comment_by_id(
+                    self.id).cached_replies[offset:offset + limit]
+
+            elif self.source == "project":
+                p = project.Project(id=self.source_id, _session=self._session)
+                p.update()
+                self.cached_replies = p.comment_replies(comment_id=self.id, limit=limit, offset=offset)
+
+            elif self.source == "studio":
+                self.cached_replies = studio.Studio(id=self.source_id, _session=self._session).comment_replies(
+                    comment_id=self.id, limit=limit, offset=offset)
+
+        return self.cached_replies
+
+    # Methods for dealing with the comment
+
+    def reply(self, content, *, commentee_id=None):
+        """
+        Posts a reply comment to the comment.
+        
+        Warning:
+            Scratch only shows comments replying to top-level comments, and all replies to replies are actually replies to top-level comments in the API.
+
+            Therefore, if this comment is a reply, this method will not reply to the comment itself but to the corresponding top-level comment.
+    
+        Args:
+            content (str): Comment content to post.
+
+        Keyword args:
+            commentee_id (None or str): If set to None (default), it will automatically fill out the commentee ID with the user ID of the parent comment author. Set it to "" to mention no user.
+
+
+        Returns:
+            scratchattach.Comment: The created comment.
+        """
+
+        self._assert_auth()
+        parent_id = str(self.id)
+        if self.parent_id is not None:
+            parent_id = str(self.parent_id)
+        if commentee_id is None:
+            if "author_id" in self.__dict__:
+                commentee_id = self.author_id
+            else:
+                commentee_id = ""
+        if self.source == "profile":
+            return user.User(username=self.source_id, _session=self._session).reply_comment(content,
+                                                                                            parent_id=str(parent_id),
+                                                                                            commentee_id=commentee_id)
+        if self.source == "project":
+            p = project.Project(id=self.source_id, _session=self._session)
+            p.update()
+            return p.reply_comment(content, parent_id=str(parent_id), commentee_id=commentee_id)
+        if self.source == "studio":
+            return studio.Studio(id=self.source_id, _session=self._session).reply_comment(content,
+                                                                                          parent_id=str(parent_id),
+                                                                                          commentee_id=commentee_id)
+
+    def delete(self):
+        """
+        Deletes the comment.
+        """
+        self._assert_auth()
+        if self.source == "profile":
+            user.User(username=self.source_id, _session=self._session).delete_comment(comment_id=self.id)
+
+        elif self.source == "project":
+            p = project.Project(id=self.source_id, _session=self._session)
+            p.update()
+            p.delete_comment(comment_id=self.id)
+
+        elif self.source == "studio":
+            studio.Studio(id=self.source_id, _session=self._session).delete_comment(comment_id=self.id)
+
+    def report(self):
+        """
+        Reports the comment to the Scratch team.
+        """
+        self._assert_auth()
+        if self.source == "profile":
+            user.User(username=self.source_id, _session=self._session).report_comment(comment_id=self.id)
+
+        elif self.source == "project":
+            p = project.Project(id=self.source_id, _session=self._session)
+            p.update()
+            p.report_comment(comment_id=self.id)
+
+        elif self.source == "studio":
+            studio.Studio(id=self.source_id, _session=self._session).report_comment(comment_id=self.id)