scratchattach 2.1.12__py3-none-any.whl → 2.1.14__py3-none-any.whl

scratchattach/site/user.py

@@ -3,21 +3,37 @@ from __future__ import annotations
 
 import json
 import random
+import re
 import string
+from datetime import datetime, timezone
+from enum import Enum
+import warnings
+
+from typing_extensions import deprecated
+from bs4 import BeautifulSoup, Tag
+
+from ._base import BaseSiteComponent
+from scratchattach.eventhandlers import message_events
+
+from scratchattach.utils import commons
+from scratchattach.utils import exceptions
+from scratchattach.utils.commons import headers
+from scratchattach.utils.requests import requests
 
-from ..eventhandlers import message_events
 from . import project
-from ..utils import exceptions
 from . import studio
 from . import forum
-from bs4 import BeautifulSoup
-from ._base import BaseSiteComponent
-from ..utils.commons import headers
-from ..utils import commons
 from . import comment
 from . import activity
+from . import classroom
 
-from ..utils.requests import Requests as requests
+class Rank(Enum):
+    """
+    Possible ranks in scratch
+    """
+    NEW_SCRATCHER = 0
+    SCRATCHER = 1
+    SCRATCH_TEAM = 2
 
 class Verificator:
 
@@ -61,7 +77,7 @@ class User(BaseSiteComponent):
 
         # Info on how the .update method has to fetch the data:
         self.update_function = requests.get
-        self.update_API = f"https://api.scratch.mit.edu/users/{entries['username']}"
+        self.update_api = f"https://api.scratch.mit.edu/users/{entries['username']}"
 
         # Set attributes every User object needs to have:
         self._session = None
@@ -69,6 +85,10 @@ class User(BaseSiteComponent):
         self.username = None
         self.name = None
 
+        # cache value for classroom getter method (using @property)
+        # first value is whether the cache has actually been set (because it can be None), second is the value itself
+        self._classroom: tuple[bool, classroom.Classroom | None] = False, None
+
         # Update attributes from entries dict:
         entries.setdefault("name", entries.get("username"))
         self.__dict__.update(entries)
@@ -119,27 +139,73 @@ class User(BaseSiteComponent):
             raise exceptions.Unauthorized(
                 "You need to be authenticated as the profile owner to do this.")
 
+    @property
+    def classroom(self) -> classroom.Classroom | None:
+        """
+        Get a user's associated classroom, and return it as a `scratchattach.classroom.Classroom` object.
+        If there is no associated classroom, returns `None`
+        """
+        if not self._classroom[0]:
+            with requests.no_error_handling():
+                resp = requests.get(f"https://scratch.mit.edu/users/{self.username}/")
+            soup = BeautifulSoup(resp.text, "html.parser")
+
+            details = soup.find("p", {"class": "profile-details"})
+            assert isinstance(details, Tag)
+
+            class_name, class_id, is_closed = None, 0, False
+            for a in details.find_all("a"):
+                if not isinstance(a, Tag):
+                    continue
+                href = str(a.get("href"))
+                if re.match(r"/classes/\d*/", href):
+                    class_name = a.text.strip()[len("Student of: "):]
+                    is_closed = class_name.endswith("\n            (ended)") # as this has a \n, we can be sure
+                    if is_closed:
+                        class_name = class_name[:-7].strip()
+
+                    class_id = int(href.split('/')[2])
+                    break
+
+            if class_name:
+                self._classroom = True, classroom.Classroom(
+                    _session=self._session,
+                    id=class_id,
+                    title=class_name,
+                    is_closed=is_closed
+                )
+            else:
+                self._classroom = True, None
+
+        return self._classroom[1]
+
     def does_exist(self):
         """
         Returns:
             boolean : True if the user exists, False if the user is deleted, None if an error occured
         """
-        status_code = requests.get(f"https://scratch.mit.edu/users/{self.username}/").status_code
+        with requests.no_error_handling():
+            status_code = requests.get(f"https://scratch.mit.edu/users/{self.username}/").status_code
         if status_code == 200:
             return True
         elif status_code == 404:
             return False
 
+    # Will maybe be deprecated later, but for now still has its own purpose.
+    #@deprecated("This function is partially deprecated. Use user.rank() instead.")
     def is_new_scratcher(self):
         """
         Returns:
             boolean : True if the user has the New Scratcher status, else False
         """
         try:
-            res = requests.get(f"https://scratch.mit.edu/users/{self.username}/").text
-            group=res[res.rindex('<span class="group">'):][:70]
-            return "new scratcher" in group.lower()
-        except Exception:
+            with requests.no_error_handling():
+                res = requests.get(f"https://scratch.mit.edu/users/{self.username}/").text
+                group = res[res.rindex('<span class="group">'):][:70]
+                return "new scratcher" in group.lower()
+
+        except Exception as e:
+            warnings.warn(f"Caught exception {e=}")
             return None
 
     def message_count(self):
@@ -168,19 +234,21 @@ class User(BaseSiteComponent):
 
     def follower_count(self):
         # follower count
-        text = requests.get(
-            f"https://scratch.mit.edu/users/{self.username}/followers/",
-            headers = self._headers
-        ).text
-        return commons.webscrape_count(text, "Followers (", ")")
+        with requests.no_error_handling():
+            text = requests.get(
+                f"https://scratch.mit.edu/users/{self.username}/followers/",
+                headers = self._headers
+            ).text
+            return commons.webscrape_count(text, "Followers (", ")")
 
     def following_count(self):
         # following count
-        text = requests.get(
-            f"https://scratch.mit.edu/users/{self.username}/following/",
-            headers = self._headers
-        ).text
-        return commons.webscrape_count(text, "Following (", ")")
+        with requests.no_error_handling():
+            text = requests.get(
+                f"https://scratch.mit.edu/users/{self.username}/following/",
+                headers = self._headers
+            ).text
+            return commons.webscrape_count(text, "Following (", ")")
 
     def followers(self, *, limit=40, offset=0):
         """
@@ -214,7 +282,7 @@ class User(BaseSiteComponent):
         """
         return [i.name for i in self.following(limit=limit, offset=offset)]
 
-    def is_following(self, user):
+    def is_following(self, user: str):
         """
         Returns:
             boolean: Whether the user is following the user provided as argument
@@ -228,11 +296,11 @@ class User(BaseSiteComponent):
                 if user in following_names:
                     following = True
                     break
-                if following_names == []:
+                if not following_names:
                     break
                 offset += 20
-            except Exception:
-                print("Warning: API error when performing following check")
+            except Exception as e:
+                print(f"Warning: API error when performing following check: {e=}")
                 return following
         return following
 
@@ -241,28 +309,46 @@ class User(BaseSiteComponent):
         Returns:
             boolean: Whether the user is followed by the user provided as argument
         """
-        return User(username=user).is_following(self.username)
+        offset = 0
+        followed = False
+
+        while True:
+            try:
+                followed_names = self.follower_names(limit=20, offset=offset)
+                if user in followed_names:
+                    followed = True
+                    break
+                if not followed_names:
+                    break
+                offset += 20
+            except Exception as e:
+                print(f"Warning: API error when performing following check: {e=}")
+                return followed
+        return followed
 
     def project_count(self):
-        text = requests.get(
-            f"https://scratch.mit.edu/users/{self.username}/projects/",
-            headers = self._headers
-        ).text
-        return commons.webscrape_count(text, "Shared Projects (", ")")
+        with requests.no_error_handling():
+            text = requests.get(
+                f"https://scratch.mit.edu/users/{self.username}/projects/",
+                headers = self._headers
+            ).text
+            return commons.webscrape_count(text, "Shared Projects (", ")")
 
     def studio_count(self):
-        text = requests.get(
-            f"https://scratch.mit.edu/users/{self.username}/studios/",
-            headers = self._headers
-        ).text
-        return commons.webscrape_count(text, "Studios I Curate (", ")")
+        with requests.no_error_handling():
+            text = requests.get(
+                f"https://scratch.mit.edu/users/{self.username}/studios/",
+                headers = self._headers
+            ).text
+            return commons.webscrape_count(text, "Studios I Curate (", ")")
 
     def studios_following_count(self):
-        text = requests.get(
-            f"https://scratch.mit.edu/users/{self.username}/studios/",
-            headers = self._headers
-        ).text
-        return commons.webscrape_count(text, "Studios I Follow (", ")")
+        with requests.no_error_handling():
+            text = requests.get(
+                f"https://scratch.mit.edu/users/{self.username}/studios_following/",
+                headers = self._headers
+            ).text
+            return commons.webscrape_count(text, "Studios I Follow (", ")")
 
     def studios(self, *, limit=40, offset=0):
         _studios = commons.api_iterative(
@@ -313,8 +399,9 @@ class User(BaseSiteComponent):
             # The index of the first project on page #n is just (n-1) * 40
             first_idx = (page - 1) * 40
 
-            page_content = requests.get(f"https://scratch.mit.edu/projects/all/{self.username}/loves/"
-                                        f"?page={page}", headers=self._headers).content
+            with requests.no_error_handling():
+                page_content = requests.get(f"https://scratch.mit.edu/projects/all/{self.username}/loves/"
+                                            f"?page={page}", headers=self._headers).content
 
             soup = BeautifulSoup(
                 page_content,
@@ -349,7 +436,7 @@ class User(BaseSiteComponent):
                     # A thumbnail link (no need to webscrape this)
                     # A title
                     # An Author (called an owner for some reason)
-
+                    assert isinstance(project_element, Tag)
                     project_anchors = project_element.find_all("a")
                     # Each list item has three <a> tags, the first two linking the project
                     # 1st contains <img> tag
@@ -358,10 +445,16 @@ class User(BaseSiteComponent):
 
                     # This function is pretty handy!
                     # I'll use it for an id from a string like: /projects/1070616180/
-                    project_id = commons.webscrape_count(project_anchors[0].attrs["href"],
+                    first_anchor = project_anchors[0]
+                    second_anchor = project_anchors[1]
+                    third_anchor = project_anchors[2]
+                    assert isinstance(first_anchor, Tag)
+                    assert isinstance(second_anchor, Tag)
+                    assert isinstance(third_anchor, Tag)
+                    project_id = commons.webscrape_count(first_anchor.attrs["href"],
                                                          "/projects/", "/")
-                    title = project_anchors[1].contents[0]
-                    author = project_anchors[2].contents[0]
+                    title = second_anchor.contents[0]
+                    author = third_anchor.contents[0]
 
                     # Instantiating a project with the properties that we know
                     # This may cause issues (see below)
@@ -382,10 +475,11 @@ class User(BaseSiteComponent):
         return _projects
 
     def loves_count(self):
-        text = requests.get(
-            f"https://scratch.mit.edu/projects/all/{self.username}/loves/",
-            headers=self._headers
-        ).text
+        with requests.no_error_handling():
+            text = requests.get(
+                f"https://scratch.mit.edu/projects/all/{self.username}/loves/",
+                headers=self._headers
+            ).text
 
         # If there are no loved projects, then Scratch doesn't actually display the number - so we have to catch this
         soup = BeautifulSoup(text, "html.parser")
@@ -406,10 +500,11 @@ class User(BaseSiteComponent):
         return commons.parse_object_list(_projects, project.Project, self._session)
 
     def favorites_count(self):
-        text = requests.get(
-            f"https://scratch.mit.edu/users/{self.username}/favorites/",
-            headers = self._headers
-        ).text
+        with requests.no_error_handling():
+            text = requests.get(
+                f"https://scratch.mit.edu/users/{self.username}/favorites/",
+                headers=self._headers
+            ).text
         return commons.webscrape_count(text, "Favorites (", ")")
 
     def toggle_commenting(self):
@@ -544,17 +639,23 @@ class User(BaseSiteComponent):
             data = {
                 'id': text.split('<div id="comments-')[1].split('" class="comment')[0],
                 'author': {"username": text.split('" data-comment-user="')[1].split('"><img class')[0]},
-                'content': text.split('<div class="content">')[1].split('"</div>')[0],
+                'content': text.split('<div class="content">')[1].split('</div>')[0].strip(),
                 'reply_count': 0,
                 'cached_replies': []
             }
-            _comment = comment.Comment(source="profile", parent_id=None if parent_id=="" else parent_id, commentee_id=commentee_id, source_id=self.username, id=data["id"], _session = self._session)
+            _comment = comment.Comment(source="profile", parent_id=None if parent_id=="" else parent_id, commentee_id=commentee_id, source_id=self.username, id=data["id"], _session = self._session, datetime = datetime.now())
             _comment._update_from_dict(data)
             return _comment
         except Exception:
             if '{"error": "isFlood"}' in text:
                 raise(exceptions.CommentPostFailure(
                     "You are being rate-limited for running this operation too often. Implement a cooldown of about 10 seconds."))
+            elif '<script id="error-data" type="application/json">' in text:
+                raw_error_data = text.split('<script id="error-data" type="application/json">')[1].split('</script>')[0]
+                error_data = json.loads(raw_error_data)
+                expires = error_data['mute_status']['muteExpiresAt']
+                expires = datetime.fromtimestamp(expires, timezone.utc)
+                raise(exceptions.CommentPostFailure(f"You have been muted. Mute expires on {expires}"))
             else:
                 raise(exceptions.FetchError(f"Couldn't parse API response: {r.text!r}"))
 
@@ -581,7 +682,8 @@ class User(BaseSiteComponent):
         Returns:
             list<scratchattach.Activity>: The user's activity data as parsed list of scratchattach.activity.Activity objects
         """
-        soup = BeautifulSoup(requests.get(f"https://scratch.mit.edu/messages/ajax/user-activity/?user={self.username}&max={limit}").text, 'html.parser')
+        with requests.no_error_handling():
+            soup = BeautifulSoup(requests.get(f"https://scratch.mit.edu/messages/ajax/user-activity/?user={self.username}&max={limit}").text, 'html.parser')
 
         activities = []
         source = soup.find_all("li")
@@ -599,7 +701,8 @@ class User(BaseSiteComponent):
         Returns:
             str: The raw user activity HTML data
         """
-        return requests.get(f"https://scratch.mit.edu/messages/ajax/user-activity/?user={self.username}&max={limit}").text
+        with requests.no_error_handling():
+            return requests.get(f"https://scratch.mit.edu/messages/ajax/user-activity/?user={self.username}&max={limit}").text
 
 
     def follow(self):
@@ -668,7 +771,8 @@ class User(BaseSiteComponent):
         URL = f"https://scratch.mit.edu/site-api/comments/user/{self.username}/?page={page}"
         DATA = []
 
-        page_contents = requests.get(URL).content
+        with requests.no_error_handling():
+            page_contents = requests.get(URL).content
 
         soup = BeautifulSoup(page_contents, "html.parser")
 
@@ -813,6 +917,24 @@ class User(BaseSiteComponent):
         v = Verificator(self, verification_project_id)
         return v
 
+    def rank(self):
+        """
+        Finds the rank of the user.
+        May replace user.scratchteam and user.is_new_scratcher in the future.
+        """
+
+        if self.is_new_scratcher():
+            return Rank.NEW_SCRATCHER
+            # Is New Scratcher
+        
+        if not self.scratchteam:
+            return Rank.SCRATCHER
+            # Is Scratcher
+
+        return Rank.SCRATCH_TEAM
+        # Is Scratch Team member
+
+
 # ------ #
 
 def get_user(username) -> User:

scratchattach/utils/commons.py

@@ -1,13 +1,17 @@
 """v2 ready: Common functions used by various internal modules"""
 from __future__ import annotations
 
+import string
+
 from typing import Optional, Final, Any, TypeVar, Callable, TYPE_CHECKING, Union
+from threading import Event as ManualResetEvent
 from threading import Lock
 
 from . import exceptions
-from .requests import Requests as requests
+from .requests import requests
+
+from scratchattach.site import _base
 
-from ..site import _base
 
 headers: Final = {
     "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
@@ -130,7 +134,7 @@ def _get_object(identificator_name, identificator, __class: type[C], NotFoundExc
     # Internal function: Generalization of the process ran by get_user, get_studio etc.
     # Builds an object of class that is inheriting from BaseSiteComponent
     # # Class must inherit from BaseSiteComponent
-    from ..site import project
+    from scratchattach.site import project
     try:
         use_class: type = __class
         if __class is project.PartialProject:
@@ -182,44 +186,41 @@ class LockEvent:
     """
     Can be waited on and triggered. Not to be confused with threading.Event, which has to be reset.
     """
-    locks: list[Lock]
+    _event: ManualResetEvent
+    _locks: list[Lock]
+    _access_locks: Lock
     def __init__(self):
-        self.locks = []
-        self.use_locks = Lock()
+        self._event = ManualResetEvent()
+        self._locks = []
+        self._access_locks = Lock()
 
     def wait(self, blocking: bool = True, timeout: Optional[Union[int, float]] = None) -> bool:
         """
         Wait for the event.
         """
-        timeout = -1 if timeout is None else timeout
-        if not blocking:
-            timeout = 0
-        return self.on().acquire(timeout=timeout)
+        return self._event.wait(timeout if blocking else 0)
 
     def trigger(self):
         """
         Trigger all threads waiting on this event to continue.
         """
-        with self.use_locks:
-            for lock in self.locks:
+        with self._access_locks:
+            for lock in self._locks:
                 try:
-                    lock.release() # Unlock the lock once to trigger the event.
+                    lock.release()
                 except RuntimeError:
-                    lock.acquire(timeout=0) # Lock the lock again.
-            for lock in self.locks.copy():
-                try:
-                    lock.release() # Unlock the lock once more to make sure it was waited on.
-                    self.locks.remove(lock)
-                except RuntimeError:
-                    lock.acquire(timeout=0) # Lock the lock again.
+                    pass
+            self._locks.clear()
+            self._event.set()
+            self._event = ManualResetEvent()
 
     def on(self) -> Lock:
         """
-        Return a lock that will unlock once the event takes place.
+        Return a lock that will unlock once the event takes place. Return value has to be waited on to wait for the event.
         """
         lock = Lock()
-        with self.use_locks:
-            self.locks.append(lock)
+        with self._access_locks:
+            self._locks.append(lock)
         lock.acquire(timeout=0)
         return lock
 
@@ -241,3 +242,14 @@ def get_class_sort_mode(mode: str) -> tuple[str, str]:
         descsort = "title"
 
     return ascsort, descsort
+
+
+def b62_decode(s: str):
+    chars = string.digits + string.ascii_uppercase + string.ascii_lowercase
+
+    ret = 0
+    for char in s:
+        ret = ret * 62 + chars.index(char)
+
+    return ret
+

scratchattach/utils/enums.py

@@ -4,13 +4,12 @@ Adapted from https://translate-service.scratch.mit.edu/supported?language=en
 """
 from __future__ import annotations
 
-from enum import Enum
 from dataclasses import dataclass
-
+from enum import Enum
 from typing import Optional, Callable, Iterable
 
 
-@dataclass(init=True, repr=True)
+@dataclass
 class Language:
     name: str = None
     code: str = None
@@ -44,7 +43,7 @@ class _EnumWrapper(Enum):
 
                 if apply_func(_val) == value:
                     return item_obj
-                  
+
             except TypeError:
                 pass
 
@@ -167,7 +166,7 @@ class Languages(_EnumWrapper):
         return super().all_of(attr_name, apply_func)
 
 
-@dataclass(init=True, repr=True)
+@dataclass
 class TTSVoice:
     name: str
     gender: str
@@ -195,3 +194,43 @@ class TTSVoices(_EnumWrapper):
     def all_of(cls, attr_name: str = "name", apply_func: Optional[Callable] = None) -> Iterable:
         return super().all_of(attr_name, apply_func)
 
+
+@dataclass
+class AlertType:
+    id: int
+    message: str
+
+
+class AlertTypes(_EnumWrapper):
+    """
+    Enum for associating alert type indecies with their messages, for use with the str.format() method.
+    """
+    # Reference: https://github.com/TimMcCool/scratchattach/issues/304#issuecomment-2800110811
+    # NOTE: THE TEXT WITHIN THE BRACES HERE MATTERS! IF YOU WANT TO CHANGE IT, MAKE SURE TO EDIT `site.alert.EducatorAlert`!
+    ban = AlertType(0, "{username} was banned.")
+    unban = AlertType(1, "{username} was unbanned.")
+    excluded_from_homepage = AlertType(2, "{username} was excluded from homepage")
+    excluded_from_homepage2 = AlertType(3, "{username} was excluded from homepage") # for some reason there are duplicates
+    notified = AlertType(4, "{username} was notified by a Scratch Administrator. Notification type: {notification_type}") # not sure what notification type is
+    autoban = AlertType(5, "{username} was banned automatically")
+    autoremoved = AlertType(6, "{project} by {username} was removed automatically")
+    project_censored2 = AlertType(7, "{project} by {username} was censored.")  # <empty #7>
+    project_censored = AlertType(20, "{project} by {username} was censored.")
+    project_uncensored = AlertType(8, "{project} by {username} was uncensored.")
+    project_reviewed2 = AlertType(9, "{project} by {username} was reviewed by a Scratch Administrator.")  # <empty #9>
+    project_reviewed = AlertType(10, "{project} by {username} was reviewed by a Scratch Administrator.")
+    project_deleted = AlertType(11, "{project} by {username} was deleted by a Scratch Administrator.")
+    user_deleted2 = AlertType(12, "{username} was deleted by a Scratch Administrator")  # <empty #12>
+    user_deleted = AlertType(17, "{username} was deleted by a Scratch Administrator")
+    studio_reviewed2 = AlertType(13, "{studio} was reviewed by a Scratch Administrator.")  # <empty #13>
+    studio_reviewed = AlertType(14, "{studio} was reviewed by a Scratch Administrator.")
+    studio_deleted = AlertType(15, "{studio} was deleted by a Scratch Administrator.")
+    email_confirm2 = AlertType(16, "The email address of {username} was confirmed by a Scratch Administrator")  # <empty #16>
+    email_confirm = AlertType(18, "The email address of {username} was confirmed by a Scratch Administrator") # no '.' in HTML
+    email_unconfirm = AlertType(19, "The email address of {username} was set as not confirmed by a Scratch Administrator")
+    automute = AlertType(22, "{username} was automatically muted by our comment filters. The comment they tried to post was: {comment}")
+    default = AlertType(-1, "{username} had an admin action performed.") # default case
+
+    @classmethod
+    def find(cls, value, by: str = "id", apply_func: Optional[Callable] = None) -> AlertType:
+        return super().find(value, by, apply_func)

scratchattach/utils/exceptions.py

@@ -231,3 +231,13 @@ class LoginDataWarning(UserWarning):
     """
     Warns you not to accidentally share your login data.
     """
+
+class AnonymousSiteComponentWarning(UserWarning):
+    """
+    Warns about a usage of an anonymous site component.
+    """
+
+class UnexpectedWebsocketEventWarning(RuntimeWarning):
+    """
+    Warns about an unexpected occurrence with a websocket.
+    """