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

scratchattach-3.0.0b1.dist-info/RECORD

@@ -0,0 +1,79 @@
+cli/__about__.py,sha256=rWWgBXhOQakEGEip4jZgZsmGHkIU08m01PRgPUfmHdg,17
+cli/__init__.py,sha256=WAJmqnZi5RoJGlx3fngQAi9APNf84QlicncbsPRwhkg,700
+cli/context.py,sha256=7m9i-J2j36MN8uPJm8ydjMFKWZjJQAyu5NBluL8eQUE,4950
+cli/db.py,sha256=sV-AwyYc8WeHalpadAV1vD0HXkEmZrcvhLGJA0q0TD0,1920
+cli/namespace.py,sha256=qWH1QI9ot-5Y1ahpY9JHw8HTGnlFwHRKLoKxvxFqk5A,445
+cli/cmd/__init__.py,sha256=KiNP3GVwCf-NE_yzYgDvza3hR3Sr1B0-wqu5Xaxi_g4,110
+cli/cmd/group.py,sha256=j8jqy2N4KEChe6cUus5MczoqGKDzjOIgG2mBmxVmb-A,4144
+cli/cmd/login.py,sha256=BnPUCUDG58gNly76OZdBT22oxaZY50b_VHnQWx2p40I,1914
+cli/cmd/profile.py,sha256=jT-JoJhFCtzbyskdQpi8_ckVzrVqDghlh-zEEEchFDI,172
+cli/cmd/sessions.py,sha256=JzBx6BTjddqU-UGZz4CtYpBKb9CC7lbpXLk19Pz7Zoo,116
+cloud/__init__.py,sha256=MN7s4grQcciqUO7TiFjTbU2sC69m6XXlwOHNRbN3FKo,41
+cloud/_base.py,sha256=tXVWPsL9Ybvu2H0zQ5R9GexgeHAarEv4GS16foD3_qw,19251
+cloud/cloud.py,sha256=zq0Z-N2EF2uUxpJ0uZlITY2DeKkjb3TxwK_etci-xCM,8470
+editor/__init__.py,sha256=pdq-dg7fa4cj6eksu5yzUe27DGY6CLKVUtCSrbYCsM8,807
+editor/asset.py,sha256=Ut_Em2rzlzswi2aDTvyRZWvF5JKLY8IAmoLMOQLBpjQ,8148
+editor/backpack_json.py,sha256=zhNRKDmlA9Oz-IixjLRnSwVG6JfKURs31KhQPjJu_bs,3880
+editor/base.py,sha256=MUQ4zqw-IaFZDH9o_F9k7F3mptymR67E8ITkaMfnD5M,5311
+editor/block.py,sha256=2UKKQbrDdsI6dbswo2swvIr7jXiXA114TCtXDO9DSFw,19085
+editor/blockshape.py,sha256=Q8CAWsBc2O5VqcGhUxbJoW1RRfy7kBxz1AporkExBi8,25318
+editor/build_defaulting.py,sha256=rRDSXpIugWENYs6X50A_a3BJfWJuzEtwW1bv9IAyo-M,1421
+editor/comment.py,sha256=G_eFxeaC_vKbCFpDfw4oZxIReUBoBUaCA5q35O-AW6Y,2403
+editor/commons.py,sha256=0mm30KjAenl_V2BXbkdirFN62SraYfGUariXB-TXNlU,3583
+editor/extension.py,sha256=PFVl5SrS66M4Md98I_dsfeL9BLeWwvyWezmhnTRseIQ,1541
+editor/field.py,sha256=_AmBwrb5TeG_CRm312I69T2xXlzuKYeudpygPyA4698,2994
+editor/inputs.py,sha256=bmCLsxgGimkESbKEnhsnw_ZSRpBDsWRIcEoYPFMx9Zs,4505
+editor/meta.py,sha256=QCHk5DKvYAw7F5Gg4OIJNcB7PhK8u5YgfDmGQPWobTs,3330
+editor/monitor.py,sha256=A30XadTjw_G0KsTnwo3YEI31nkplc1DnO8AirjmB3zc,5921
+editor/mutation.py,sha256=o2msH-s6UxFZ-LuYF1BlR4CBm-ulKTVpStux54cxnDk,12246
+editor/pallete.py,sha256=OY76grzJLUWsAKi2x-mipEXv5f-9I-s9UjoLZ3FmtBM,2299
+editor/prim.py,sha256=v74mkdLwsXAKPy_KPesugv-xCxA6YcGU6_v7Zvc2YEY,5919
+editor/project.py,sha256=tWf9kULlJjMCV1t5AofIDFqGylBYQ31vpjDMJ3jM3_Q,12884
+editor/sprite.py,sha256=M_rrkErJswH9stKvrywrkaoNEwgRBbF7-Si17W-0vTs,21205
+editor/twconfig.py,sha256=iE6ylAsZzniAfhL09GkZSFn1XacYtCQPzRCUSPIBzDA,3324
+editor/vlb.py,sha256=Fl2gGwZyYh54uOhQ7XITfCgCpJTQB2P8wy47PKY3Qyk,4151
+editor/code_translation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+editor/code_translation/parse.py,sha256=FjuHVg_tNzkGcGSNwgH6MzAHcf5YCvaEUSYukyJkwbk,4932
+eventhandlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventhandlers/_base.py,sha256=97vFbuhSoJeYb-jrEWDdbZWQ7e_54CY3ktrq8d_-w8g,3142
+eventhandlers/cloud_events.py,sha256=LDENLVopVwKDVrcfkR1spKzT45ET-EKqBdtCzXoaS5g,5228
+eventhandlers/cloud_recorder.py,sha256=dvob4-aKLxE9WFqvCNv28M_r3r3OEkET6rwmu5yl4jk,795
+eventhandlers/cloud_requests.py,sha256=CQsA6wzW6C0xJYtw6g0X8x5DY5EHkDE1tAOMVigzhzA,25113
+eventhandlers/cloud_server.py,sha256=j2Iiuxsp9xOLeZ6S7iT7Yto8u599O57kRUZLMMIxjQ0,12431
+eventhandlers/cloud_storage.py,sha256=YYcvRjhIuOboWVemMKFEtUhrd6UeUFO_BlbAIH7oaeQ,4609
+eventhandlers/combine.py,sha256=YiWI6WI1BySioXpfYaMv8noBM14EjZa7dtsJsMTshEU,894
+eventhandlers/filterbot.py,sha256=V5dQErz_yFpSioh5VxUDaBW8L9ny1uMviTt7x-KFC1k,7612
+eventhandlers/message_events.py,sha256=KvznXAeNGk1WWCxd7PI95yovX-58TyCBNDdXbrYgb8Q,1776
+other/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+other/other_apis.py,sha256=yZ06rCZmJLSZZdfv1V_VgRBq5dUxS31YHkpsdOxAezw,17509
+other/project_json_capabilities.py,sha256=07t1iMgWm4Qd06jHyQ3vK7tROguvc2RQCo78enrdSlA,22646
+scratchattach-3.0.0b1.dist-info/licenses/LICENSE,sha256=1PRKLhZU4wYt5M-C9f7q0W3go3u_ojnZMNOdR3g3J-E,1080
+site/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+site/_base.py,sha256=D2SOp2aFiDP0hG7-xP8kK1pmoAz5TOi7_iWt6Ulpsbg,3283
+site/activity.py,sha256=g5fg97xHUAKOkaZ4VzKl3hVpICZhv1mpDCO6LlmkoTU,17871
+site/alert.py,sha256=V6asmcWy4tcQgWhG95rpqXP0KeUy7VQU9wD9AMhCqds,9324
+site/backpack_asset.py,sha256=__VZomGDJkbgWj2ridQQArMMLWoSMv8dpO7PPpvPgBU,3322
+site/browser_cookie3_stub.py,sha256=codk0knOP5C0YThaRazvqsqX7X7WnrD2UwFd1nFG7mg,1422
+site/browser_cookies.py,sha256=uQyjJJ4HCu46R4tPWCcTUqDMXSXhQ4KQUobqCSxScSA,1864
+site/classroom.py,sha256=lpHh2OkHeFzGUaFbf9PWIrosYOBo2cRrfc6fsex2w44,18139
+site/cloud_activity.py,sha256=vMQy2k3jzPbOa3_TiH23B9dTk4BQA_z0q_Ab6TFkeV8,5397
+site/comment.py,sha256=kUZxbjChs8K66vShz-Q1y1s72yJ44hFXJUYLsSb9rUs,9449
+site/forum.py,sha256=-XLi3UJOwDt0Ye8CqP4c-sSxOkPSe5fPVa9b7MOm64k,16553
+site/placeholder.py,sha256=BTOroGKA3lpgKPJXFeveEuMdcNkOIddpbNTrV-48s-o,5446
+site/project.py,sha256=Zc5TN4PEGC1fTze_rkU7_-Y1YDuSXrkHaJGD3eeLgqU,34750
+site/session.py,sha256=kd4IKaMXmtWGJJnFV3wOoLAF2S_012zHkdGcMZgUFxs,54451
+site/studio.py,sha256=sAqFJDjhxf-9NynLB7mrCgzxq8td1oqa1zTW9MP1yTM,26195
+site/typed_dicts.py,sha256=Hq65u56OSLdcoQ0F0A_CxZ8WBY5d_0VuJmUEMd8KmpU,3611
+site/user.py,sha256=P2nsSGo-Z1QlXzAQxstOOq-E4QGN9HVA4dIQaJd1YFY,47404
+utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+utils/commons.py,sha256=DpBTxRC2XeKURW5YJwAT6teAfYG7221GxClTaZ0-yQE,8465
+utils/encoder.py,sha256=1lOXBbqo2JGMdns6Q5WGhAB9p7Q8trduBk-SZgmcEKw,2559
+utils/enums.py,sha256=5HhXidczUYYVwHf6jfJcMA80jK4V0imaltLEu5epIF8,11127
+utils/exceptions.py,sha256=T1nBbbkTZVkZU7uNaqBqSbNTGtOaOnTVLRRqUTatTis,7556
+utils/optional_async.py,sha256=zTCFt6tpSvlcwns1RgAACKplA1SSFyVWAcDRS8kLLjE,4721
+utils/requests.py,sha256=Brl94PCyblaQopanXyyQZ8ZoaWuFrK3NqUTZWW22gpY,9608
+scratchattach-3.0.0b1.dist-info/METADATA,sha256=JnNVUZxbXAuGUH0mn9nE4Cuu17ko-wNNy1OLdPMPSWU,5633
+scratchattach-3.0.0b1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+scratchattach-3.0.0b1.dist-info/entry_points.txt,sha256=vNXuP05TQKEoIzmzmUzS7zbtSZx0p3JmeUW3QhNdYfg,56
+scratchattach-3.0.0b1.dist-info/top_level.txt,sha256=PFfH9Sb4fMOY99H0Xiuuc8nEGjAT_-anhTaORDZBd7A,48
+scratchattach-3.0.0b1.dist-info/RECORD,,

{scratchattach-2.1.15b0.dist-info → scratchattach-3.0.0b1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

scratchattach-3.0.0b1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+scratch = scratchattach.__main__:main

scratchattach-3.0.0b1.dist-info/top_level.txt

@@ -0,0 +1,7 @@
+cli
+cloud
+editor
+eventhandlers
+other
+site
+utils

{scratchattach/site → site}/_base.py

@@ -1,18 +1,23 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import TypeVar, Optional
+from typing import TypeVar, Optional, Self, Union, Any, Generic
+import json
 
 import requests
-from scratchattach.utils import exceptions, commons
+
+from scratchattach.utils import exceptions, commons, optional_async
+from scratchattach.utils import requests as m_requests
 from . import session
 
+D = TypeVar("D")
 C = TypeVar("C", bound="BaseSiteComponent")
-class BaseSiteComponent(ABC):
+class BaseSiteComponent(ABC, Generic[D]):
     _session: Optional[session.Session]
     update_api: str
     _headers: dict[str, str]
     _cookies: dict[str, str]
+    oa_http_session: Optional[m_requests.OAHTTPSession] = None
 
     # @abstractmethod
     # def __init__(self):  # dataclasses do not implement __init__ directly
@@ -32,7 +37,7 @@ class BaseSiteComponent(ABC):
         if "429" in str(response):
             return "429"
 
-        if response.text == '{\n  "response": "Too many requests"\n}':
+        if json.loads(response.text) == {"response": "Too many requests"}:
             return "429"
 
         # If no error: Parse JSON:
@@ -41,9 +46,13 @@ class BaseSiteComponent(ABC):
             return False
 
         return self._update_from_dict(response)
+    
+    def updated(self) -> Self:
+        self.update()
+        return self
 
     @abstractmethod
-    def _update_from_dict(self, data) -> bool:
+    def _update_from_dict(self, data: D) -> bool:
         """
         Parses the API response that is fetched in the update-method. Class specific, must be overridden in classes inheriting from this one.
         """
@@ -59,8 +68,26 @@ class BaseSiteComponent(ABC):
         Class must inherit from BaseSiteComponent
         """
         return commons._get_object(identificator_id, identificator, Class, NotFoundException, self._session)
+    
+    def supply_data_dict(self, data: D) -> bool:
+        return self._update_from_dict(data)
 
     update_function = requests.get
     """
     Internal function run on update. Function is a method of the 'requests' module/class
     """
+    
+    def _make_request(
+        self,
+        method: Union[m_requests.HTTPMethod, str],
+        url: str,
+        *,
+        cookies: Optional[dict[str, str]] = None,
+        headers: Optional[dict[str, str]] = None,
+        params: Optional[dict[str, str]] = None,
+        data: Optional[Union[dict[str, str], str]] = None,
+        json: Optional[Any] = None
+    ) -> optional_async.CARequest:
+        if self.oa_http_session is None:
+            raise ValueError("This BaseSiteComponent has no oa_http_session.")
+        return self.oa_http_session.request(method, url, cookies=cookies, headers=headers, params=params, data=data, json=json)

site/activity.py

@@ -0,0 +1,426 @@
+"""Activity and CloudActivity class"""
+from __future__ import annotations
+
+import html
+import warnings
+
+from dataclasses import dataclass
+from typing import Optional, Any
+from enum import Enum
+
+from bs4 import Tag
+
+from . import user, project, studio, session, forum
+from ._base import BaseSiteComponent
+from scratchattach.utils import exceptions
+
+class ActivityTypes(Enum):
+    loveproject = "loveproject"
+    favoriteproject = "favoriteproject"
+    becomecurator = "becomecurator"
+    followuser = "followuser"
+    followstudio = "followstudio"
+    shareproject = "shareproject"
+    remixproject = "remixproject"
+    becomeownerstudio = "becomeownerstudio"
+    addcomment = "addcomment"
+    curatorinvite = "curatorinvite"
+    userjoin = "userjoin"
+    studioactivity = "studioactivity"
+    forumpost = "forumpost"
+    updatestudio = "updatestudio"
+    createstudio = "createstudio"
+    promotetomanager = "promotetomanager"
+    updateprofile = "updateprofile"
+    removeprojectfromstudio = "removeprojectfromstudio"
+    addprojecttostudio = "addprojecttostudio"
+    performaction = "performaction"
+
+@dataclass
+class Activity(BaseSiteComponent):
+    """
+    Represents a Scratch activity (message or other user page activity)
+    """
+    _session: Optional[session.Session] = None
+    raw: Any = None
+
+    id: Optional[int] = None
+    actor_username: Optional[str] = None
+
+    project_id: Optional[int] = None
+    gallery_id: Optional[int] = None
+    username: Optional[str] = None
+    followed_username: Optional[str] = None
+    recipient_username: Optional[str] = None
+    title: Optional[str] = None
+    project_title: Optional[str] = None
+    gallery_title: Optional[str] = None
+    topic_title: Optional[str] = None
+    topic_id: Optional[int] = None
+    target_name: Optional[str] = None
+    target_id: Optional[int | str] = None
+
+    parent_title: Optional[str] = None
+    parent_id: Optional[int] = None
+
+    comment_type: Optional[int] = None
+    comment_obj_id = None
+    comment_obj_title: Optional[str] = None
+    comment_id: Optional[int] = None
+    comment_fragment: Optional[str] = None
+
+    changed_fields: Optional[dict[str, str]] = None
+    is_reshare: Optional[bool] = None
+
+    datetime_created: Optional[str] = None
+    time: Any = None
+    type: Optional[ActivityTypes] = None
+
+    def __repr__(self):
+        return f"Activity({repr(self.raw)})"
+
+    def __str__(self):
+        return '-A ' + ' '.join(self.parts)
+
+    @property
+    def parts(self):
+        """
+        Return format: [actor username] + N * [action, object]
+        :return: A list of parts of the message. Join the parts to get a readable version, which is done with str(activity)
+        """
+        match self.type:
+            case ActivityTypes.loveproject:
+                return [f"{self.actor_username}", "loved", f"-P {self.title!r} ({self.project_id})"]
+            case ActivityTypes.favoriteproject:
+                return [f"{self.actor_username}", "favorited", f"-P {self.project_title!r} ({self.project_id})"]
+            case ActivityTypes.becomecurator:
+                return [f"{self.actor_username}", "now curating", f"-S {self.title!r} ({self.gallery_id})"]
+            case ActivityTypes.followuser:
+                return [f"{self.actor_username}", "followed", f"-U {self.followed_username}"]
+            case ActivityTypes.followstudio:
+                return [f"{self.actor_username}", "followed", f"-S {self.title!r} ({self.gallery_id})"]
+            case ActivityTypes.shareproject:
+                return [f"{self.actor_username}", "reshared" if self.is_reshare else "shared",
+                        f"-P {self.title!r} ({self.project_id})"]
+            case ActivityTypes.remixproject:
+                return [f"{self.actor_username}", "remixed",
+                        f"-P {self.parent_title!r} ({self.parent_id}) as -P {self.title!r} ({self.project_id})"]
+            case ActivityTypes.becomeownerstudio:
+                return [f"{self.actor_username}", "became owner of", f"-S {self.gallery_title!r} ({self.gallery_id})"]
+
+            case ActivityTypes.addcomment:
+                ret = [self.actor_username, "commented on"]
+
+                match self.comment_type:
+                    case 0:
+                        # project
+                        ret.append(f"-P {self.comment_obj_title!r} ({self.comment_obj_id}")
+                    case 1:
+                        # user
+                        ret.append(f"-U {self.comment_obj_title}")
+
+                    case 2:
+                        # studio
+                        ret.append(f"-S {self.comment_obj_title!r} ({self.comment_obj_id}")
+
+                    case _:
+                        raise ValueError(f"Unknown comment type: {self.comment_type}")
+
+                ret[-1] += f"#{self.comment_id})"
+
+                ret.append(f"{html.unescape(self.comment_fragment)}")
+
+                return ret
+
+            case ActivityTypes.curatorinvite:
+                return [f"{self.actor_username}", "invited you to curate", f"-S {self.title!r} ({self.gallery_id})"]
+
+            case ActivityTypes.userjoin:
+                # This is also the first message you get - 'Welcome to Scratch'
+                return [f"{self.actor_username}", "joined Scratch"]
+
+            case ActivityTypes.studioactivity:
+                # the actor username should be systemuser
+                return [f"{self.actor_username}", 'Studio activity', '', f"-S {self.title!r} ({self.gallery_id})"]
+
+            case ActivityTypes.forumpost:
+                return [f"{self.actor_username}", "posted in", f"-F {self.topic_title} ({self.topic_id})"]
+
+            case ActivityTypes.updatestudio:
+                return [f"{self.actor_username}", "updated", f"-S {self.gallery_title} ({self.gallery_id})"]
+
+            case ActivityTypes.createstudio:
+                return [f"{self.actor_username}", "created", f"-S {self.gallery_title} ({self.gallery_id})"]
+
+            case ActivityTypes.promotetomanager:
+                return [f"{self.actor_username}", "promoted", f"-U {self.recipient_username}", "in",
+                        f"-S {self.gallery_title} ({self.gallery_id})"]
+
+            case ActivityTypes.updateprofile:
+                return [f"{self.actor_username}", "updated their profile.", f"Changed fields: {self.changed_fields}"]
+
+            case ActivityTypes.removeprojectfromstudio:
+                return [f"{self.actor_username}", "removed", f"-P {self.project_title} ({self.project_id})", "from",
+                        f"-S {self.gallery_title} ({self.gallery_id})"]
+
+            case ActivityTypes.addprojecttostudio:
+                return [f"{self.actor_username}", "added", f"-P {self.project_title} ({self.project_id})", "to",
+                        f"-S {self.gallery_title} ({self.gallery_id})"]
+
+            case ActivityTypes.performaction:
+                return [f"{self.actor_username}", "performed an action"]
+
+            case _:
+                raise NotImplementedError(
+                    f"Activity type {self.type!r} is not implemented!\n"
+                    f"{self.raw=}\n"
+                    f"Raise an issue on github: https://github.com/TimMcCool/scratchattach/issues")
+
+    def update(self):
+        print("Warning: Activity objects can't be updated")
+        return False  # Objects of this type cannot be updated
+
+    def _update_from_dict(self, data):
+        self.raw = data
+
+        self._session = data.get("_session", self._session)
+        self.raw = data.get("raw", self.raw)
+
+        self.id = data.get("id", self.id)
+        self.actor_username = data.get("actor_username", self.actor_username)
+
+        self.project_id = data.get("project_id", self.project_id)
+        self.gallery_id = data.get("gallery_id", self.gallery_id)
+        self.username = data.get("username", self.username)
+        self.followed_username = data.get("followed_username", self.followed_username)
+        self.recipient_username = data.get("recipient_username", self.recipient_username)
+        self.title = data.get("title", self.title)
+        self.project_title = data.get("project_title", self.project_title)
+        self.gallery_title = data.get("gallery_title", self.gallery_title)
+        self.topic_title = data.get("topic_title", self.topic_title)
+        self.topic_id = data.get("topic_id", self.topic_id)
+        self.target_name = data.get("target_name", self.target_name)
+        self.target_id = data.get("target_id", self.target_id)
+
+        self.parent_title = data.get("parent_title", self.parent_title)
+        self.parent_id = data.get("parent_id", self.parent_id)
+
+        self.comment_type = data.get("comment_type", self.comment_type)
+        self.comment_obj_id = data.get("comment_obj_id", self.comment_obj_id)
+        self.comment_obj_title = data.get("comment_obj_title", self.comment_obj_title)
+        self.comment_id = data.get("comment_id", self.comment_id)
+        self.comment_fragment = data.get("comment_fragment", self.comment_fragment)
+
+        self.changed_fields = data.get("changed_fields", self.changed_fields)
+        self.is_reshare = data.get("is_reshare", self.is_reshare)
+
+        self.datetime_created = data.get("datetime_created", self.datetime_created)
+        self.time = data.get("time", self.time)
+
+        _type = data.get("type", self.type)
+        if _type:
+            self.type = ActivityTypes[_type]
+
+        return True
+
+    def _update_from_json(self, data: dict):
+        """
+        Update using JSON, used in the classroom API.
+        """
+        activity_type = data["type"]
+
+        _time = data["datetime_created"] if "datetime_created" in data else None
+
+        if "actor" in data:
+            username = data["actor"]["username"]
+        elif "actor_username" in data:
+            username = data["actor_username"]
+        else:
+            username = None
+
+        if recipient := data.get("recipient"):
+            recipient_username = recipient["username"]
+        elif recipient_username := data.get("recipient_username"):
+            pass
+        elif project_creator := data.get("project_creator"):
+            recipient_username = project_creator["username"]
+        else:
+            recipient_username = None
+
+        default_case = False
+        # Even if `activity_type` is an invalid value; it will default to 'user performed an action'
+        self.actor_username = username
+        self.username = username
+        self.raw = data
+        self.datetime_created = _time
+        if activity_type == 0:
+            self.type = ActivityTypes.followuser
+            self.followed_username = data["followed_username"]
+
+        elif activity_type == 1:
+            self.type = ActivityTypes.followstudio
+            self.gallery_id = data["gallery"]
+
+        elif activity_type == 2:
+            self.type = ActivityTypes.loveproject
+            self.project_id = data["project"]
+            self.recipient_username = recipient_username
+
+        elif activity_type == 3:
+            self.type = ActivityTypes.favoriteproject
+            self.project_id = data["project"]
+            self.recipient_username = recipient_username
+
+        elif activity_type == 7:
+            self.type = ActivityTypes.addprojecttostudio
+            self.project_id = data["project"]
+            self.gallery_id = data["gallery"]
+            self.recipient_username = recipient_username
+
+        elif activity_type in (8, 9, 10):
+            self.type = ActivityTypes.shareproject
+            self.is_reshare = data["is_reshare"]
+            self.project_id = data["project"]
+            self.recipient_username = recipient_username
+
+        elif activity_type == 11:
+            self.type = ActivityTypes.remixproject
+            self.parent_id = data["parent"]
+            warnings.warn(f"This may be incorrectly implemented.\n"
+                          f"Raw data: {data}\n"
+                          f"Please raise an issue on gh: https://github.com/TimMcCool/scratchattach/issues")
+            self.recipient_username = recipient_username
+
+        # type 12 does not exist in the HTML. That's why it was removed, not merged with type 13.
+
+        elif activity_type == 13:
+            self.type = ActivityTypes.createstudio
+            self.gallery_id = data["gallery"]
+
+        elif activity_type == 15:
+            self.type = ActivityTypes.updatestudio
+            self.gallery_id = data["gallery"]
+
+        elif activity_type in (16, 17, 18, 19):
+            self.type = ActivityTypes.removeprojectfromstudio
+            self.gallery_id = data["gallery"]
+            self.project_id = data["project"]
+
+        elif activity_type in (20, 21, 22):
+            self.type = ActivityTypes.promotetomanager
+            self.recipient_username = recipient_username
+            self.gallery_id = data["gallery"]
+
+        elif activity_type in (23, 24, 25):
+            self.type = ActivityTypes.updateprofile
+            self.changed_fields = data.get("changed_fields", {})
+
+        elif activity_type in (26, 27):
+            # Comment in either project, user, or studio
+            self.type = ActivityTypes.addcomment
+            self.comment_fragment = data["comment_fragment"]
+            self.comment_type = data["comment_type"]
+            self.comment_obj_id = data["comment_obj_id"]
+            self.comment_obj_title = data["comment_obj_title"]
+            self.comment_id = data["comment_id"]
+
+        else:
+            # This is coded in the scratch HTML, haven't found an example of it though
+            self.type = ActivityTypes.performaction
+
+
+    def _update_from_html(self, data: Tag):
+
+        self.raw = data
+
+        _time = data.find('div').find('span').find_next().find_next().text.strip()
+
+        if '\xa0' in _time:
+            while '\xa0' in _time:
+                _time = _time.replace('\xa0', ' ')
+
+        self.datetime_created = _time
+        self.actor_username = data.find('div').find('span').text
+
+        self.target_name = data.find('div').find('span').find_next().text
+        self.target_link = data.find('div').find('span').find_next()["href"]
+        # note that target_id can also be a username, so it isn't exclusively an int
+        self.target_id = data.find('div').find('span').find_next()["href"].split("/")[-2]
+
+        _type = data.find('div').find_all('span')[0].next_sibling.strip()
+        if _type == "loved":
+            self.type = ActivityTypes.loveproject
+
+        elif _type == "favorited":
+            self.type = ActivityTypes.favoriteproject
+
+        elif "curator" in _type:
+            self.type = ActivityTypes.becomecurator
+
+        elif "shared" in _type:
+            self.type = ActivityTypes.shareproject
+
+        elif "is now following" in _type:
+            if "users" in self.target_link:
+                self.type = ActivityTypes.followuser
+            else:
+                self.type = ActivityTypes.followstudio
+
+        return True
+
+    def actor(self):
+        """
+        Returns the user that performed the activity as User object
+        """
+        return self._make_linked_object("username", self.actor_username, user.User, exceptions.UserNotFound)
+
+    def target(self):
+        """
+        Returns the activity's target (depending on the activity, this is either a User, Project, Studio or Comment object).
+        May also return None if the activity type is unknown.
+        """
+        _type = self.type.value
+
+        if "project" in _type:  # target is a project
+            if self.target_id:
+                return self._make_linked_object("id", self.target_id, project.Project, exceptions.ProjectNotFound)
+            if self.project_id:
+                return self._make_linked_object("id", self.project_id, project.Project, exceptions.ProjectNotFound)
+
+        if _type == "becomecurator" or _type == "followstudio":  # target is a studio
+            if self.target_id:
+                return self._make_linked_object("id", self.target_id, studio.Studio, exceptions.StudioNotFound)
+            if self.gallery_id:
+                return self._make_linked_object("id", self.gallery_id, studio.Studio, exceptions.StudioNotFound)
+            # NOTE: the "becomecurator" type is ambigous - if it is inside the studio activity tab, the target is the user who joined
+            if self.username:
+                return self._make_linked_object("username", self.username, user.User, exceptions.UserNotFound)
+
+        if _type == "followuser" or "curator" in _type:  # target is a user
+            if self.target_name:
+                return self._make_linked_object("username", self.target_name, user.User, exceptions.UserNotFound)
+            if self.followed_username:
+                return self._make_linked_object("username", self.followed_username, user.User, exceptions.UserNotFound)
+
+        if self.recipient_username:  # the recipient_username field always indicates the target is a user
+            return self._make_linked_object("username", self.recipient_username, user.User, exceptions.UserNotFound)
+
+        if _type == "addcomment":  # target is a comment
+            if self.comment_type == 0:
+                # we need author name, but it has not been saved in this object
+                _proj = self._session.connect_project(self.comment_obj_id)
+                _c = _proj.comment_by_id(self.comment_id)
+
+            elif self.comment_type == 1:
+                _c = user.User(username=self.comment_obj_title, _session=self._session).comment_by_id(self.comment_id)
+            elif self.comment_type == 2:
+                _c = user.User(id=self.comment_obj_id, _session=self._session).comment_by_id(self.comment_id)
+            else:
+                raise ValueError(f"{self.comment_type} is an invalid comment type")
+
+            return _c
+
+        if _type == "forumpost":
+            return forum.ForumTopic(id=603418, _session=self._session, title=self.title)
+
+        return None

{scratchattach/site → site}/alert.py

@@ -7,8 +7,7 @@ import pprint
 import warnings
 from dataclasses import dataclass, field, KW_ONLY
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Optional, Union
-from typing_extensions import Self
+from typing_extensions import TYPE_CHECKING, Any, Optional, Union, Self
 
 from . import user, project, studio, comment, session
 from scratchattach.utils import enums
@@ -129,13 +128,13 @@ class EducatorAlert:
 
             if comment_type == 0:
                 # project
-                comment_source_type = "project"
+                comment_source_type = comment.CommentSource.PROJECT
             elif comment_type == 1:
                 # profile
-                comment_source_type = "profile"
+                comment_source_type = comment.CommentSource.USER_PROFILE
             else:
                 # probably a studio
-                comment_source_type = "studio"
+                comment_source_type = comment.CommentSource.STUDIO
                 warnings.warn(
                     f"The parser was not able to recognise the \"comment_type\" of {comment_type} in the alert JSON response.\n"
                     f"Full response: \n{pprint.pformat(data)}.\n\n"

{scratchattach/site → site}/backpack_asset.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import time
 import logging
+import warnings
 
 from ._base import BaseSiteComponent
 from scratchattach.utils import exceptions
@@ -39,7 +40,7 @@ class BackpackAsset(BaseSiteComponent):
         self.__dict__.update(entries)
 
     def update(self):
-        print("Warning: BackpackAsset objects can't be updated")
+        warnings.warn("Warning: BackpackAsset objects can't be updated")
         return False  # Objects of this type cannot be updated