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

{scratchattach/site → site}/classroom.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import datetime
 import json
 import warnings
 from dataclasses import dataclass, field
@@ -14,7 +13,7 @@ if TYPE_CHECKING:
     from scratchattach.site.session import Session
 
 from scratchattach.utils.commons import requests
-from . import user, activity
+from . import user, activity, typed_dicts
 from ._base import BaseSiteComponent
 from scratchattach.utils import exceptions, commons
 from scratchattach.utils.commons import headers
@@ -22,16 +21,16 @@ from scratchattach.utils.commons import headers
 
 @dataclass
 class Classroom(BaseSiteComponent):
-    title: str = None
-    id: int = None
-    classtoken: str = None
+    title: str = ""
+    id: int = 0
+    classtoken: str = ""
 
-    author: user.User = None
-    about_class: str = None
-    working_on: str = None
+    author: Optional[user.User] = None
+    about_class: str = ""
+    working_on: str = ""
 
     is_closed: bool = False
-    datetime: datetime = None
+    datetime: datetime = datetime.fromtimestamp(0.0)
 
 
     update_function: Callable = field(repr=False, default=requests.get)
@@ -92,47 +91,30 @@ class Classroom(BaseSiteComponent):
                 if pfx in script.text:
                     educator_username = commons.webscrape_count(script.text, pfx, sfx, str)
 
-            ret = {"id": self.id,
-                   "title": title,
-                   "description": description,
-                   "status": status,
-                   "educator": {"username": educator_username},
-                   "is_closed": True
-                   }
+            ret: typed_dicts.ClassroomDict = {
+                "id": self.id,
+                "title": title,
+                "description": description,
+                "educator": {},
+                "status": status,
+                "is_closed": True
+                }
+
+            if educator_username:
+                ret["educator"]["username"] = educator_username
 
             return self._update_from_dict(ret)
         return success
 
-    def _update_from_dict(self, classrooms):
-        try:
-            self.id = int(classrooms["id"])
-        except Exception:
-            pass
-        try:
-            self.title = classrooms["title"]
-        except Exception:
-            pass
-        try:
-            self.about_class = classrooms["description"]
-        except Exception:
-            pass
-        try:
-            self.working_on = classrooms["status"]
-        except Exception:
-            pass
-        try:
-            self.datetime = datetime.datetime.fromisoformat(classrooms["date_start"])
-        except Exception:
-            pass
-        try:
-            self.author = user.User(username=classrooms["educator"]["username"], _session=self._session)
-        except Exception:
-            pass
-        try:
-            self.author._update_from_dict(classrooms["educator"])
-        except Exception:
-            pass
-        self.is_closed = classrooms.get("is_closed", False)
+    def _update_from_dict(self, data: typed_dicts.ClassroomDict):
+        self.id = int(data["id"])
+        self.title = data["title"]
+        self.about_class = data["description"]
+        self.working_on = data["status"]
+        self.datetime = datetime.fromisoformat(data["date_start"])
+        self.author = user.User(username=data["educator"]["username"], _session=self._session)
+        self.author.supply_data_dict(data["educator"])
+        self.is_closed = bool(data["date_end"])
         return True
 
     def student_count(self) -> int:
@@ -157,14 +139,24 @@ class Classroom(BaseSiteComponent):
             ret = []
             response = requests.get(f"https://scratch.mit.edu/classes/{self.id}/")
             soup = BeautifulSoup(response.text, "html.parser")
-
-            for scrollable in soup.find_all("ul", {"class": "scroll-content"}):
-                for item in scrollable.contents:
-                    if not isinstance(item, bs4.NavigableString):
-                        if "user" in item.attrs["class"]:
-                            anchors = item.find_all("a")
-                            if len(anchors) == 2:
-                                ret.append(anchors[1].text.strip())
+            found = set("")
+
+            for result in soup.css.select("ul.scroll-content .user a"):
+                result_text = result.text.strip()
+                if result_text in found:
+                    continue
+                found.add(result_text)
+                ret.append(result_text)
+
+            # for scrollable in soup.find_all("ul", {"class": "scroll-content"}):
+            #     if not isinstance(scrollable, Tag):
+            #         continue
+            #     for item in scrollable.contents:
+            #         if not isinstance(item, bs4.NavigableString):
+            #             if "user" in item.attrs["class"]:
+            #                 anchors = item.find_all("a")
+            #                 if len(anchors) == 2:
+            #                     ret.append(anchors[1].text.strip())
 
             return ret
 
@@ -198,13 +190,19 @@ class Classroom(BaseSiteComponent):
             response = requests.get(f"https://scratch.mit.edu/classes/{self.id}/")
             soup = BeautifulSoup(response.text, "html.parser")
 
-            for scrollable in soup.find_all("ul", {"class": "scroll-content"}):
-                for item in scrollable.contents:
-                    if not isinstance(item, bs4.NavigableString):
-                        if "gallery" in item.attrs["class"]:
-                            anchor = item.find("a")
-                            if "href" in anchor.attrs:
-                                ret.append(commons.webscrape_count(anchor.attrs["href"], "/studios/", "/"))
+            for result in soup.css.select("ul.scroll-content .gallery a[href]:not([class])"):
+                value = result["href"]
+                if not isinstance(value, str):
+                    value = value[0]
+                ret.append(commons.webscrape_count(value, "/studios/", "/"))
+
+            # for scrollable in soup.find_all("ul", {"class": "scroll-content"}):
+            #     for item in scrollable.contents:
+            #         if not isinstance(item, bs4.NavigableString):
+            #             if "gallery" in item.attrs["class"]:
+            #                 anchor = item.find("a")
+            #                 if "href" in anchor.attrs:
+            #                     ret.append(commons.webscrape_count(anchor.attrs["href"], "/studios/", "/"))
             return ret
 
         text = requests.get(
@@ -317,7 +315,7 @@ class Classroom(BaseSiteComponent):
     def register_student(self, username: str, password: str = '', birth_month: Optional[int] = None,
                          birth_year: Optional[int] = None,
                          gender: Optional[str] = None, country: Optional[str] = None, is_robot: bool = False) -> None:
-        return register_by_token(self.id, self.classtoken, username, password, birth_month, birth_year, gender, country,
+        return register_by_token(self.id, self.classtoken, username, password, birth_month or 1, birth_year or 2000, gender or "(Prefer not to say)", country or "United+States",
                                  is_robot)
 
     def generate_signup_link(self):
@@ -356,8 +354,7 @@ class Classroom(BaseSiteComponent):
 
         return activities
 
-    def activity(self, student: str = "all", mode: str = "Last created", page: Optional[int] = None) -> list[
-        dict[str, Any]]:
+    def activity(self, student: str = "all", mode: str = "Last created", page: Optional[int] = None) -> list[activity.Activity]:
         """
         Get a list of private activity, only available to the class owner.
         Returns:
@@ -370,18 +367,16 @@ class Classroom(BaseSiteComponent):
 
         with requests.no_error_handling():
             try:
-                data = requests.get(
-                    f"https://scratch.mit.edu/site-api/classrooms/activity/{self.id}/{student}/",
-                    params={"page": page, "ascsort": ascsort, "descsort": descsort},
-                    headers=self._headers, cookies=self._cookies
-                ).json()
+                data = requests.get(f"https://scratch.mit.edu/site-api/classrooms/activity/{self.id}/{student}/",
+                                    params={"page": page, "ascsort": ascsort, "descsort": descsort},
+                                    headers=self._headers, cookies=self._cookies).json()
             except json.JSONDecodeError:
                 return []
 
-        _activity = []
+        _activity: list[activity.Activity] = []
         for activity_json in data:
             _activity.append(activity.Activity(_session=self._session))
-            _activity[-1]._update_from_json(activity_json)
+            _activity[-1]._update_from_json(activity_json)  # NOT the same as _update_from_dict
 
         return _activity
 
@@ -401,7 +396,13 @@ def get_classroom(class_id: str) -> Classroom:
 
         If you want to use these, get the user with :meth:`scratchattach.session.Session.connect_classroom` instead.
     """
-    warnings.warn("For methods that require authentication, use session.connect_classroom instead of get_classroom")
+    warnings.warn(
+        "For methods that require authentication, use session.connect_classroom instead of get_classroom\n"
+        "If you want to remove this warning, use warnings.filterwarnings('ignore', category=scratchattach.ClassroomAuthenticationWarning)\n"
+        "To ignore all warnings of the type GetAuthenticationWarning, which includes this warning, use "
+        "`warnings.filterwarnings('ignore', category=scratchattach.GetAuthenticationWarning)`.",
+        exceptions.ClassroomAuthenticationWarning
+    )
     return commons._get_object("id", class_id, Classroom, exceptions.ClassroomNotFound)
 
 
@@ -420,7 +421,13 @@ def get_classroom_from_token(class_token) -> Classroom:
 
         If you want to use these, get the user with :meth:`scratchattach.session.Session.connect_classroom` instead.
     """
-    warnings.warn("For methods that require authentication, use session.connect_classroom instead of get_classroom")
+    warnings.warn(
+        "For methods that require authentication, use session.connect_classroom instead of get_classroom. "
+        "If you want to remove this warning, use warnings.filterwarnings('ignore', category=ClassroomAuthenticationWarning). "
+        "To ignore all warnings of the type GetAuthenticationWarning, which includes this warning, use "
+        "warnings.filterwarnings('ignore', category=GetAuthenticationWarning).",
+        exceptions.ClassroomAuthenticationWarning
+    )
     return commons._get_object("classtoken", class_token, Classroom, exceptions.ClassroomNotFound)
 
 

{scratchattach/site → site}/cloud_activity.py

@@ -1,11 +1,18 @@
 from __future__ import annotations
 
 import time
-from ._base import BaseSiteComponent
-
+from typing import Union, TypeGuard, Optional
+from dataclasses import dataclass, field
+import warnings
 
+from scratchattach.cloud import _base
+from scratchattach.utils import exceptions
+from scratchattach.site import project, user
+from ._base import BaseSiteComponent
+from . import typed_dicts, session
 
-class CloudActivity(BaseSiteComponent):
+@dataclass
+class CloudActivity(BaseSiteComponent[Union[typed_dicts.CloudActivityDict, typed_dicts.CloudLogActivityDict]]):
     """
     Represents a cloud activity (a cloud variable set / creation / deletion).
 
@@ -25,6 +32,14 @@ class CloudActivity(BaseSiteComponent):
     
     :.cloud: The cloud (as object inheriting from scratchattach.Cloud.BaseCloud) that the cloud activity corresponds to
     """
+    username: str = field(kw_only=True, default="")
+    var: str = field(kw_only=True, default="")
+    name: str = field(kw_only=True, default="")
+    type: str = field(kw_only=True, default="set")
+    timestamp: float = field(kw_only=True, default=0.0)
+    value: Union[float, int, str] = field(kw_only=True, default="0.0")
+    cloud: _base.AnyCloud = field(kw_only=True, default_factory=lambda : _base.DummyCloud())
+    _session: Optional[session.Session] = field(kw_only=True, default=None)
 
     def __init__(self, **entries):
         # Set attributes every CloudActivity object needs to have:
@@ -39,32 +54,30 @@ class CloudActivity(BaseSiteComponent):
         self.__dict__.update(entries)
 
     def update(self):
-        print("Warning: CloudActivity objects can't be updated")
+        warnings.warn("CloudActivity objects can't be updated", exceptions.InvalidUpdateWarning)
         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
+    def _update_from_dict(self, data: Union[typed_dicts.CloudActivityDict, typed_dicts.CloudLogActivityDict]) -> bool:
+        def is_cloud_log_activity(activity: Union[typed_dicts.CloudActivityDict, typed_dicts.CloudLogActivityDict]) -> TypeGuard[typed_dicts.CloudLogActivityDict]:
+            return "verb" in activity
+        def is_cloud_activity(activity: Union[typed_dicts.CloudActivityDict, typed_dicts.CloudLogActivityDict]) -> TypeGuard[typed_dicts.CloudActivityDict]:
+            return "method" in activity
+        self.name = data["name"]
+        self.var = data["name"]
+        self.value = data["value"]
+        if is_cloud_log_activity(data):
+            self.user = data["user"]
+            self.username = data["user"]
+            self.timestamp = data["timestamp"]
+            self.type = data["verb"].removesuffix("_var")
+        elif is_cloud_activity(data):
+            self.type = data["method"]
+        if "cloud" in data:
+            self.cloud = data["cloud"]
         return True
 
     def load_log_data(self):
@@ -91,17 +104,18 @@ class CloudActivity(BaseSiteComponent):
         """
         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):
+    def project(self) -> Optional[project.Project]:
         """
         Returns the project where the cloud activity was performed as scratchattach.project.Project object
         """
+        def make_linked(cloud: _base.BaseCloud) -> project.Project:
+            return self._make_linked_object("id", cloud.project_id, project.Project, exceptions.ProjectNotFound)
         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)
+        cloud = self.cloud
+        if not isinstance(cloud, _base.BaseCloud):
+            return None
+        return make_linked(cloud)
 

{scratchattach/site → site}/comment.py

@@ -1,103 +1,84 @@
 """Comment class"""
 from __future__ import annotations
 
+import warnings
 import html
+
+from dataclasses import dataclass
+from typing_extensions import assert_never
 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 . import user, project, studio, session
 from ._base import BaseSiteComponent
 from scratchattach.utils import exceptions
 
+class CommentSource(Enum):
+    PROJECT = auto()
+    USER_PROFILE = auto()
+    STUDIO = auto()
+    UNKNOWN = auto()
+
+@dataclass
 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
+    id: Optional[int | str] = None
+    source: CommentSource = CommentSource.UNKNOWN
+    source_id: Optional[int | str] = None
+    cached_replies: Optional[list[Comment]] = None
+    parent_id: Optional[int | str] = None
+    cached_parent_comment: Optional[Comment] = None
+    commentee_id: Optional[int] = None
+    content: Optional[str] = None
+    reply_count: Optional[int] = None
+    written_by_scratchteam: Optional[bool] = None
+    author_id: Optional[int] = None
+    author_name: Optional[str] = None
+
+    _session: Optional[session.Session] = None
 
     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"
+        return self.text
 
     def update(self):
-        print("Warning: Comment objects can't be updated")
+        warnings.warn("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
+    def _update_from_dict(self, data: dict[str, str | dict | Any]):
+        self.id = data["id"]
+        self.parent_id = data.get("parent_id")
+        self.commentee_id = data.get("commentee_id")
+        self.content = str(data["content"])
+        self.datetime_created = data["datetime_created"]
+
+        author = data.get("author", {})
+        self.author_name = author.get("username", self.author_name)
+        self.author_id = author.get("id", self.author_id)
+        self.written_by_scratchteam = author.get("scratchteam", self.written_by_scratchteam)
+        self.reply_count = data.get("reply_count", self.reply_count)
+
+        source: str = data.get("source")
+        if self.source is CommentSource.UNKNOWN:
+            self.source = {
+                "project": CommentSource.PROJECT,
+                "studio": CommentSource.STUDIO,
+                "profile": CommentSource.USER_PROFILE,
+                None: CommentSource.UNKNOWN,
+            }[source]
+
+        self.source_id = data.get("source_id", self.source_id)
 
     @property
     def text(self) -> str:
-        if self.source == "profile":
+        """
+        Parsed version of Comment.content. This removes any escape codes, e.g. ''' becomes ', an apostrophe
+        """
+        if self.source is CommentSource.USER_PROFILE:
+            # user profile comments do not seem to be escaped
             return self.content
+
         return str(html.unescape(self.content))
 
     # Methods for getting related entities
@@ -111,14 +92,14 @@ class Comment(BaseSiteComponent):
 
         If the place can't be traced back, None is returned.
         """
-        if self.source == "profile":
+        if self.source == CommentSource.USER_PROFILE:
             return self._make_linked_object("username", self.source_id, user.User, exceptions.UserNotFound)
-        elif self.source == "studio":
+        elif self.source == CommentSource.STUDIO:
             return self._make_linked_object("id", self.source_id, studio.Studio, exceptions.UserNotFound)
-        elif self.source == "project":
+        elif self.source == CommentSource.PROJECT:
             return self._make_linked_object("id", self.source_id, project.Project, exceptions.UserNotFound)
         else:
-            raise ValueError("Unknown source.")
+            assert_never(self.source)
 
     def parent_comment(self) -> Comment | None:
         if self.parent_id is None:
@@ -148,18 +129,16 @@ class Comment(BaseSiteComponent):
             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]
+            if self.source == CommentSource.USER_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":
+            elif self.source == CommentSource.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":
+            elif self.source == CommentSource.STUDIO:
                 self.cached_replies = studio.Studio(id=self.source_id, _session=self._session).comment_replies(
                     comment_id=self.id, limit=limit, offset=offset)
 
@@ -185,6 +164,8 @@ class Comment(BaseSiteComponent):
 
         Returns:
             scratchattach.Comment: The created comment.
+            :param content: Content of the comment to send
+            :param commentee_id: ID of user to reply to
         """
 
         self._assert_auth()
@@ -192,51 +173,56 @@ class Comment(BaseSiteComponent):
         if self.parent_id is not None:
             parent_id = str(self.parent_id)
         if commentee_id is None:
-            if "author_id" in self.__dict__:
+            if self.author_id:
                 commentee_id = self.author_id
             else:
                 commentee_id = ""
-        if self.source == "profile":
+
+        if self.source == CommentSource.USER_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":
+        if self.source == CommentSource.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":
+
+        if self.source == CommentSource.STUDIO:
             return studio.Studio(id=self.source_id, _session=self._session).reply_comment(content,
                                                                                           parent_id=str(parent_id),
                                                                                           commentee_id=commentee_id)
+        raise ValueError(f"Unknown source: {self.source}")
 
     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 == CommentSource.USER_PROFILE:
+            return user.User(username=self.source_id, _session=self._session).delete_comment(comment_id=self.id)
 
-        elif self.source == "project":
+        elif self.source == CommentSource.PROJECT:
             p = project.Project(id=self.source_id, _session=self._session)
             p.update()
-            p.delete_comment(comment_id=self.id)
+            return 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)
+        elif self.source == CommentSource.STUDIO:
+            return studio.Studio(id=self.source_id, _session=self._session).delete_comment(comment_id=self.id)
+        
+        return None  # raise error?
 
     def report(self):
         """
         Reports the comment to the Scratch team.
         """
         self._assert_auth()
-        if self.source == "profile":
+        if self.source == CommentSource.USER_PROFILE:
             user.User(username=self.source_id, _session=self._session).report_comment(comment_id=self.id)
 
-        elif self.source == "project":
+        elif self.source == CommentSource.PROJECT:
             p = project.Project(id=self.source_id, _session=self._session)
             p.update()
             p.report_comment(comment_id=self.id)
 
-        elif self.source == "studio":
+        elif self.source == CommentSource.STUDIO:
             studio.Studio(id=self.source_id, _session=self._session).report_comment(comment_id=self.id)