scratchattach 2.1.14__py3-none-any.whl → 3.0.0b0__py3-none-any.whl

scratchattach/site/cloud_activity.py

@@ -1,107 +0,0 @@
-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 scratchattach.site import user
-        from scratchattach.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 scratchattach.site import project
-        from scratchattach.utils import exceptions
-        return self._make_linked_object("id", self.cloud.project_id, project.Project, exceptions.ProjectNotFound)
-

scratchattach/site/comment.py

@@ -1,242 +0,0 @@
-"""Comment class"""
-from __future__ import annotations
-
-import html
-from typing import Union, Optional, Any
-from typing_extensions import assert_never  # importing from typing caused me errors
-from enum import Enum, auto
-
-from . import user, project, studio
-from ._base import BaseSiteComponent
-from scratchattach.utils import exceptions
-
-class Comment(BaseSiteComponent):
-    """
-    Represents a Scratch comment (on a profile, studio or project)
-    """
-    id: Union[int, str]
-    source: str
-    source_id: Union[int, str]
-    cached_replies: Optional[list[Comment]]
-    parent_id: Optional[Union[int, str]]
-    cached_parent_comment: Optional[Comment]
-    commentee_id: Optional[int]
-    content: Any
-
-    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
-
-    @property
-    def text(self) -> str:
-        if self.source == "profile":
-            return self.content
-        return str(html.unescape(self.content))
-
-    # 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)
-        elif self.source == "studio":
-            return self._make_linked_object("id", self.source_id, studio.Studio, exceptions.UserNotFound)
-        elif self.source == "project":
-            return self._make_linked_object("id", self.source_id, project.Project, exceptions.UserNotFound)
-        else:
-            raise ValueError("Unknown source.")
-
-    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":
-                _cached_replies = user.User(username=self.source_id, _session=self._session).comment_by_id(
-                    self.id).cached_replies
-                if _cached_replies is not None:
-                    self.cached_replies = _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)