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

{scratchattach/cloud → cloud}/_base.py

@@ -3,11 +3,11 @@ from __future__ import annotations
 import json
 import ssl
 import time
+import warnings
 from typing import Optional, Union, TypeVar, Generic, TYPE_CHECKING, Any
 from abc import ABC, abstractmethod, ABCMeta
 from threading import Lock
 from collections.abc import Iterator
-import warnings
 
 if TYPE_CHECKING:
     from _typeshed import SupportsRead
@@ -18,23 +18,25 @@ else:
         def read(self) -> T:
             pass
 
-class SupportsClose(ABC):
-    @abstractmethod
-    def close(self) -> None:
-        pass
 
 import websocket
 
 from scratchattach.site import session
 from scratchattach.eventhandlers import cloud_recorder
 from scratchattach.utils import exceptions
-from scratchattach.eventhandlers.cloud_requests import CloudRequests
+from scratchattach.eventhandlers.cloud_requests import CloudRequests, RespondOrder
 from scratchattach.eventhandlers.cloud_events import CloudEvents
 from scratchattach.eventhandlers.cloud_storage import CloudStorage
 from scratchattach.site import cloud_activity
 
+class SupportsClose(ABC):
+    @abstractmethod
+    def close(self) -> None:
+        pass
+
 T = TypeVar("T")
 
+
 class EventStream(SupportsRead[Iterator[dict[str, Any]]], SupportsClose):
     """
     Allows you to stream events
@@ -45,7 +47,7 @@ class AnyCloud(ABC, Generic[T]):
     Represents a cloud that is not necessarily using a websocket.
     """
     active_connection: bool
-    var_stets_since_first: int
+    var_sets_since_first: int
     _session: Optional[session.Session]
     
     @abstractmethod
@@ -58,6 +60,7 @@ class AnyCloud(ABC, Generic[T]):
 
     def reconnect(self):
         self.disconnect()
+        time.sleep(0.1)
         self.connect()
         
     @abstractmethod
@@ -65,17 +68,20 @@ class AnyCloud(ABC, Generic[T]):
         pass
 
     @abstractmethod
-    def set_var(self, variable: str, value: T) -> None:
+    def set_var(self, variable: str, value: T, *, max_retries : int = 2) -> None:
         """
         Sets a cloud variable.
 
         Args:
             variable (str): The name of the cloud variable that should be set (provided without the cloud emoji)
             value (Any): The value the cloud variable should be set to
+
+        Kwargs:
+            max_retries (int) : Maximum number of times to retry setting the var if setting fails before raising an exception
         """
 
     @abstractmethod
-    def set_vars(self, var_value_dict: dict[str, T], *, intelligent_waits: bool = True):
+    def set_vars(self, var_value_dict: dict[str, T], *, intelligent_waits: bool = True, max_retries : int = 2):
         """
         Sets multiple cloud variables at once (works for an unlimited amount of variables).
 
@@ -84,31 +90,67 @@ class AnyCloud(ABC, Generic[T]):
         
         Kwargs:
             intelligent_waits (boolean): When enabled, the method will automatically decide how long to wait before performing this cloud variable set, to make sure no rate limits are triggered
+            max_retries (int) : Maximum number of times to retry setting the var if setting fails before raising an exception        
         """
 
     @abstractmethod
-    def get_var(self, var, *, recorder_initial_values={}) -> T:
+    def get_var(self, var, *, recorder_initial_values: Optional[dict[str, Any]] = None) -> T:
         pass
 
     @abstractmethod
-    def get_all_vars(self, *, recorder_initial_values={}) -> dict[str, T]:
+    def get_all_vars(self, *, recorder_initial_values: Optional[dict[str, Any]] = None) -> dict[str, T]:
         pass
 
     def events(self) -> CloudEvents:
         return CloudEvents(self)
 
-    def requests(self, *, no_packet_loss: bool = False, used_cloud_vars: list[str] = ["1", "2", "3", "4", "5", "6", "7", "8", "9"],
-                 respond_order="receive", debug: bool = False) -> CloudRequests:
+    def requests(self, *, no_packet_loss: bool = False, used_cloud_vars: Optional[list[str]] = None,
+                 respond_order=RespondOrder.RECEIVE, debug: bool = False) -> CloudRequests:
+        used_cloud_vars = used_cloud_vars or ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
         return CloudRequests(self, used_cloud_vars=used_cloud_vars, no_packet_loss=no_packet_loss,
                              respond_order=respond_order, debug=debug)
 
-    def storage(self, *, no_packet_loss: bool = False, used_cloud_vars: list[str] = ["1", "2", "3", "4", "5", "6", "7", "8", "9"]) -> CloudStorage:
+    def storage(self, *, no_packet_loss: bool = False, used_cloud_vars: Optional[list[str]] = None) -> CloudStorage:
+        used_cloud_vars = used_cloud_vars or ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
         return CloudStorage(self, used_cloud_vars=used_cloud_vars, no_packet_loss=no_packet_loss)
     
     @abstractmethod
     def create_event_stream(self) -> EventStream:
         pass
 
+class DummyCloud(AnyCloud[Any]):
+    class DummyEventStream(EventStream):
+        def read(self, length = ...):
+            return iter(())
+        
+        def close(self):
+            pass
+        
+    def connect(self):
+        pass
+
+    def disconnect(self):
+        pass
+    
+    def create_event_stream(self) -> EventStream:
+        return self.DummyEventStream()
+    
+    def _enforce_ratelimit(self, *, n: int) -> None:
+        pass
+
+    def set_var(self, variable: str, value: T, *, max_retries : int = 2) -> None:
+        pass
+
+    def set_vars(self, var_value_dict: dict[str, T], *, intelligent_waits: bool = True, max_retries : int = 2):
+        pass
+
+    def get_var(self, var, *, recorder_initial_values: Optional[dict[str, Any]] = None) -> Any:
+        pass
+
+    def get_all_vars(self, *, recorder_initial_values: Optional[dict[str, Any]] = None) -> dict[str, Any]:
+        return {}
+
+
 class WebSocketEventStream(EventStream):
     packets_left: list[Union[str, bytes]]
     source_cloud: BaseCloud
@@ -172,7 +214,7 @@ class BaseCloud(AnyCloud[Union[str, int]]):
     - must first call the constructor of the super class: super().__init__()
     - must then set some attributes
 
-    Attributes that must be specified in the __init__ function a class inheriting from this one:
+    Attributes that must be specified in the __init__ function of a class inheriting from this one:
         project_id: Project id of the cloud variables
 
         cloud_host: URL of the websocket server ("wss://..." or "ws://...")
@@ -199,6 +241,9 @@ class BaseCloud(AnyCloud[Union[str, int]]):
 
         print_connect_messages: Whether to print a message on every connect to the cloud server. Defaults to False.
     """
+
+    _PACKET_FAILURE_SLEEPDURATIONS = (0.1, 0.2, 1.5) 
+
     project_id: Optional[Union[str, int]]
     cloud_host: str
     ws_shortterm_ratelimit: float
@@ -213,6 +258,12 @@ class BaseCloud(AnyCloud[Union[str, int]]):
     ws_timeout: Optional[int]
     websocket: websocket.WebSocket
     event_stream: Optional[EventStream] = None
+    
+    recorder: Optional[cloud_recorder.CloudRecorder]
+    
+    first_var_set: float
+    last_var_set: float
+    var_sets_since_first: int
 
     def __init__(self, *, project_id: Optional[Union[int, str]] = None, _session=None):
 
@@ -223,9 +274,9 @@ class BaseCloud(AnyCloud[Union[str, int]]):
         self.websocket = websocket.WebSocket(sslopt={"cert_reqs": ssl.CERT_NONE})
         self.recorder = None  # A CloudRecorder object that records cloud activity for the values to be retrieved later,
         # which will be saved in this attribute as soon as .get_var is called
-        self.first_var_set = 0
-        self.last_var_set = 0
-        self.var_stets_since_first = 0
+        self.first_var_set = 0.0
+        self.last_var_set = 0.0
+        self.var_sets_since_first = 0
 
         # Set default values for attributes that save configurations specific to the represented cloud:
         # (These attributes can be specifically in the constructors of classes inheriting from this base class)
@@ -248,57 +299,26 @@ class BaseCloud(AnyCloud[Union[str, int]]):
             raise exceptions.Unauthenticated(
                 "You need to use session.connect_cloud (NOT get_cloud) in order to perform this operation.")
 
-    def _send_packet(self, packet):
+    def _send_recursive(self, data : str, *, current_depth: int = 0, max_depth=0):
         try:
-            self.websocket.send(json.dumps(packet) + "\n")
+            self.websocket.send(data)
         except Exception:
-            time.sleep(0.1)
-            self.connect()
-            time.sleep(0.1)
-            try:
-                self.websocket.send(json.dumps(packet) + "\n")
-            except Exception:
-                time.sleep(0.2)
+            if current_depth < max_depth:
+                sleep_duration = self._PACKET_FAILURE_SLEEPDURATIONS[min(current_depth, len(self._PACKET_FAILURE_SLEEPDURATIONS)-1)]
+                time.sleep(sleep_duration)
                 self.connect()
-                time.sleep(0.2)
-                try:
-                    self.websocket.send(json.dumps(packet) + "\n")
-                except Exception:
-                    time.sleep(1.6)
-                    self.connect()
-                    time.sleep(1.4)
-                    try:
-                        self.websocket.send(json.dumps(packet) + "\n")
-                    except Exception:
-                        self.active_connection = False
-                        raise exceptions.CloudConnectionError(f"Sending packet failed three times in a row: {packet}")
-
-    def _send_packet_list(self, packet_list):
+                time.sleep(sleep_duration)
+                self._send_recursive(data, current_depth=current_depth+1, max_depth=max_depth)
+            else:
+                self.active_connection = False
+                raise exceptions.CloudConnectionError(f"Sending packet failed {max_depth+1} tries: {data}")
+
+    def _send_packet(self, packet, *, max_retries=2):
+        self._send_recursive(json.dumps(packet) + "\n", max_depth=max_retries)
+
+    def _send_packet_list(self, packet_list, *, max_retries=2):
         packet_string = "".join([json.dumps(packet) + "\n" for packet in packet_list])
-        try:
-            self.websocket.send(packet_string)
-        except Exception:
-            time.sleep(0.1)
-            self.connect()
-            time.sleep(0.1)
-            try:
-                self.websocket.send(packet_string)
-            except Exception:
-                time.sleep(0.2)
-                self.connect()
-                time.sleep(0.2)
-                try:
-                    self.websocket.send(packet_string)
-                except Exception:
-                    time.sleep(1.6)
-                    self.connect()
-                    time.sleep(1.4)
-                    try:
-                        self.websocket.send(packet_string)
-                    except Exception:
-                        self.active_connection = False
-                        raise exceptions.CloudConnectionError(
-                            f"Sending packet list failed four times in a row: {packet_list}")
+        self._send_recursive(packet_string, max_depth=max_retries)
 
     def _handshake(self):
         packet = {"method": "handshake", "user": self.username, "project_id": self.project_id}
@@ -348,23 +368,27 @@ class BaseCloud(AnyCloud[Union[str, int]]):
     def _enforce_ratelimit(self, *, n):
         # n is the amount of variables being set
         if (time.time() - self.first_var_set) / (
-                self.var_stets_since_first + 1) > self.ws_longterm_ratelimit:  # if the average delay between cloud variable sets has been bigger than the long-term rate-limit, cloud variables can be set fast (wait time smaller than long-term rate limit) again
-            self.var_stets_since_first = 0
+                self.var_sets_since_first + 1) > self.ws_longterm_ratelimit:  # if the average delay between cloud variable sets has been bigger than the long-term rate-limit, cloud variables can be set fast (wait time smaller than long-term rate limit) again
+            self.var_sets_since_first = 0
             self.first_var_set = time.time()
 
         wait_time = self.ws_shortterm_ratelimit * n
         if time.time() - self.first_var_set > 25:  # if cloud variables have been continously set fast (wait time smaller than long-term rate limit) for 25 seconds, they should be set slow now (wait time = long-term rate limit) to avoid getting rate-limited
             wait_time = self.ws_longterm_ratelimit * n
-        while self.last_var_set + wait_time >= time.time():
-            time.sleep(0.001)
+        sleep_time = self.last_var_set + wait_time - time.time()
+        if sleep_time > 0:
+            time.sleep(sleep_time)
 
-    def set_var(self, variable, value):
+    def set_var(self, variable, value, *, max_retries: int = 2):
         """
         Sets a cloud variable.
 
         Args:
             variable (str): The name of the cloud variable that should be set (provided without the cloud emoji)
             value (str): The value the cloud variable should be set to
+
+        Kwargs:
+            max_retries (int) : Maximum number of times to retry setting the var if setting fails before raising an exception        
         """
         self._assert_valid_value(value)
         if not isinstance(variable, str):
@@ -374,7 +398,7 @@ class BaseCloud(AnyCloud[Union[str, int]]):
             self.connect()
         self._enforce_ratelimit(n=1)
 
-        self.var_stets_since_first += 1
+        self.var_sets_since_first += 1
 
         packet = {
             "method": "set",
@@ -383,10 +407,10 @@ class BaseCloud(AnyCloud[Union[str, int]]):
             "user": self.username,
             "project_id": self.project_id,
         }
-        self._send_packet(packet)
+        self._send_packet(packet, max_retries=max_retries)
         self.last_var_set = time.time()
 
-    def set_vars(self, var_value_dict, *, intelligent_waits=True):
+    def set_vars(self, var_value_dict, *, intelligent_waits=True, max_retries: int = 2):
         """
         Sets multiple cloud variables at once (works for an unlimited amount of variables).
 
@@ -395,13 +419,14 @@ class BaseCloud(AnyCloud[Union[str, int]]):
         
         Kwargs:
             intelligent_waits (boolean): When enabled, the method will automatically decide how long to wait before performing this cloud variable set, to make sure no rate limits are triggered
+            max_retries (int) : Maximum number of times to retry setting the var if setting fails before raising an exception        
         """
         if not self.active_connection:
             self.connect()
         if intelligent_waits:
-            self._enforce_ratelimit(n=len(list(var_value_dict.keys())))
+            self._enforce_ratelimit(n=len(var_value_dict))
 
-        self.var_stets_since_first += len(list(var_value_dict.keys()))
+        self.var_sets_since_first += len(var_value_dict)
 
         packet_list = []
         for variable in var_value_dict:
@@ -418,27 +443,27 @@ class BaseCloud(AnyCloud[Union[str, int]]):
                 "project_id": self.project_id,
             }
             packet_list.append(packet)
-        self._send_packet_list(packet_list)
+        self._send_packet_list(packet_list, max_retries=max_retries)
         self.last_var_set = time.time()
 
-    def get_var(self, var, *, recorder_initial_values={}):
-        var = "☁ "+var.removeprefix("☁ ")
+    def _assert_recorder_running(self, *, recorder_initial_values: dict[str, Any]) -> cloud_recorder.CloudRecorder:
         if self.recorder is None:
             self.recorder = cloud_recorder.CloudRecorder(self, initial_values=recorder_initial_values)
             self.recorder.start()
             start_time = time.time()
             while not (self.recorder.cloud_values != {} or start_time < time.time() - 5):
                 time.sleep(0.01)
-        return self.recorder.get_var(var)
+        return self.recorder
 
-    def get_all_vars(self, *, recorder_initial_values={}):
-        if self.recorder is None:
-            self.recorder = cloud_recorder.CloudRecorder(self, initial_values=recorder_initial_values)
-            self.recorder.start()
-            start_time = time.time()
-            while not (self.recorder.cloud_values != {} or start_time < time.time() - 5):
-                time.sleep(0.01)
-        return self.recorder.get_all_vars()
+
+    def get_var(self, var, *, recorder_initial_values: Optional[dict[str, Any]] = None):
+        var = "☁ "+var.removeprefix("☁ ")
+        recorder = self._assert_recorder_running(recorder_initial_values=recorder_initial_values or {})
+        return recorder.get_var(var)
+
+    def get_all_vars(self, *, recorder_initial_values: Optional[dict[str, Any]] = None):
+        recorder = self._assert_recorder_running(recorder_initial_values=recorder_initial_values or {})
+        return recorder.get_all_vars()
 
     def create_event_stream(self):
         if self.event_stream:

{scratchattach/cloud → cloud}/cloud.py

@@ -1,17 +1,17 @@
 """v2 ready: ScratchCloud, TwCloud and CustomCloud classes"""
 
 from __future__ import annotations
+
 import warnings
+from typing import Optional, Any
 
 from websocket import WebSocketBadStatusException
 
 from ._base import BaseCloud
-from typing import Type
 from scratchattach.utils.requests import requests
 from scratchattach.utils import exceptions, commons
 from scratchattach.site import cloud_activity
 
-
 class ScratchCloud(BaseCloud):
     def __init__(self, *, project_id, _session=None):
         super().__init__()
@@ -32,15 +32,15 @@ class ScratchCloud(BaseCloud):
         try:
             super().connect()
         except WebSocketBadStatusException as e:
-            raise exceptions.CloudConnectionError(f"Error: Scratch's Cloud system may be down. Please try again later.") from e
+            raise exceptions.CloudConnectionError("Error: Scratch's Cloud system may be down. Please try again later.") from e
 
-    def set_var(self, variable, value):
+    def set_var(self, variable, value, *, max_retries : int = 2):
         self._assert_auth() # Setting a cloud var requires a login to the Scratch website
-        super().set_var(variable, value)
-    
-    def set_vars(self, var_value_dict, *, intelligent_waits=True):
+        super().set_var(variable, value, max_retries=max_retries)
+
+    def set_vars(self, var_value_dict, *, intelligent_waits=True, max_retries : int = 2):
         self._assert_auth() 
-        super().set_vars(var_value_dict, intelligent_waits=intelligent_waits)
+        super().set_vars(var_value_dict, intelligent_waits=intelligent_waits, max_retries=max_retries)
 
     def logs(self, *, filter_by_var_named=None, limit=100, offset=0) -> list[cloud_activity.CloudActivity]:
         """
@@ -63,7 +63,7 @@ class ScratchCloud(BaseCloud):
         except Exception as e:
             raise exceptions.FetchError(str(e))
 
-    def get_var(self, var, *, use_logs=False):
+    def get_var(self, var, *, recorder_initial_values: Optional[dict[str, Any]] = None, use_logs=False):
         var = var.removeprefix("☁ ")
         if self._session is None or use_logs:
             filtered = self.logs(limit=100, filter_by_var_named="☁ "+var)
@@ -75,9 +75,9 @@ class ScratchCloud(BaseCloud):
                 initial_values = self.get_all_vars(use_logs=True)
                 return super().get_var("☁ "+var, recorder_initial_values=initial_values)
             else:
-                return super().get_var("☁ "+var)
+                return super().get_var("☁ "+var, recorder_initial_values=recorder_initial_values)
 
-    def get_all_vars(self, *, use_logs=False):
+    def get_all_vars(self, *, recorder_initial_values: Optional[dict[str, Any]] = None, use_logs=False):
         if self._session is None or use_logs:
             logs = self.logs(limit=100)
             logs.reverse()
@@ -90,7 +90,7 @@ class ScratchCloud(BaseCloud):
                 initial_values = self.get_all_vars(use_logs=True)
                 return super().get_all_vars(recorder_initial_values=initial_values)
             else:
-                return super().get_all_vars()
+                return super().get_all_vars(recorder_initial_values=recorder_initial_values)
 
     def events(self, *, use_logs=False):
         if self._session is None or use_logs:
@@ -134,7 +134,7 @@ class CustomCloud(BaseCloud):
         # If even more customization is needed, the developer can create a class inheriting from cloud._base.BaseCloud to override functions like .set_var etc.
 
 
-def get_cloud(project_id, *, CloudClass:Type[BaseCloud]=ScratchCloud) -> BaseCloud:
+def get_cloud(project_id, *, CloudClass: type[BaseCloud] = ScratchCloud) -> BaseCloud:
     """
     Connects to a cloud (by default Scratch's cloud) as logged out user.
 
@@ -153,8 +153,8 @@ def get_cloud(project_id, *, CloudClass:Type[BaseCloud]=ScratchCloud) -> BaseClo
         Type[scratchattach.cloud._base.BaseCloud]: An object representing the cloud of a project. Can be of any class inheriting from BaseCloud.
     """
     warnings.warn(
-        "Warning: To set Scratch cloud variables, use session.connect_cloud instead of get_cloud",
-        exceptions.AnonymousSiteComponentWarning
+        "To set Scratch cloud variables, use session.connect_cloud instead of get_cloud",
+        exceptions.CloudAuthenticationWarning
     )
     return CloudClass(project_id=project_id)
 
@@ -171,7 +171,7 @@ def get_scratch_cloud(project_id):
     """
     warnings.warn(
         "To set Scratch cloud variables, use session.connect_scratch_cloud instead of get_scratch_cloud",
-        exceptions.AnonymousSiteComponentWarning
+        exceptions.CloudAuthenticationWarning
     )
     return ScratchCloud(project_id=project_id)
 

{scratchattach/editor → editor}/__init__.py

@@ -3,9 +3,10 @@ scratchattach.editor (sbeditor v2) - a library for all things sb3
 """
 
 from .asset import Asset, Costume, Sound
+from .blockshape import BlockShapes
 from .project import Project
 from .extension import Extensions, Extension
-from .mutation import Mutation, Argument, parse_proc_code
+from .mutation import Mutation, Argument, ArgumentType, parse_proc_code, construct_proccode, ArgTypes
 from .meta import Meta, set_meta_platform
 from .sprite import Sprite
 from .block import Block

{scratchattach/editor → editor}/asset.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from hashlib import md5
+from hashlib import md5, sha256
 import requests
 
 from . import base, commons, sprite, build_defaulting
@@ -11,21 +11,22 @@ from typing import Optional
 @dataclass(init=True, repr=True)
 class AssetFile:
     """
-    Represents the file information for an asset
+    Represents the file information for an asset (not the asset metdata)
     - stores the filename, data, and md5 hash
     """
     filename: str
-    _data: bytes = field(repr=False, default_factory=bytes)
+    _data: Optional[bytes] = field(repr=False, default=None)
     _md5: str = field(repr=False, default_factory=str)
 
     @property
-    def data(self):
+    def data(self) -> bytes:
         """
         Return the contents of the asset file, as bytes
         """
         if self._data is None:
             # Download and cache
             rq = requests.get(f"https://assets.scratch.mit.edu/internalapi/asset/{self.filename}/get/")
+            # print(f"Downloaded {url}")
             if rq.status_code != 200:
                 raise ValueError(f"Can't download asset {self.filename}\nIs not uploaded to scratch! Response: {rq.text}")
 
@@ -33,16 +34,23 @@ class AssetFile:
 
         return self._data
 
+    @data.setter
+    def data(self, data: bytes):
+        self._data = data
+
     @property
-    def md5(self):
+    def md5(self) -> str:
         """
-        Compute/retrieve the md5 hash value of the asset file data
+        Compute/retrieve the md5 hex-digest of the asset file data
         """
         if self._md5 is None:
             self._md5 = md5(self.data).hexdigest()
 
         return self._md5
 
+    @property
+    def sha256(self) -> str:
+        return sha256(self.data).hexdigest()
 
 class Asset(base.SpriteSubComponent):
     def __init__(self,
@@ -50,7 +58,7 @@ class Asset(base.SpriteSubComponent):
                  file_name: str = "b7853f557e4426412e64bb3da6531a99.svg",
                  _sprite: commons.SpriteInput = build_defaulting.SPRITE_DEFAULT):
         """
-        Represents a generic asset. Can be a sound or an image.
+        Represents a generic asset, with metadata. Can be a sound or a costume.
         https://en.scratch-wiki.info/wiki/Scratch_File_Format#Assets
         """
         try:
@@ -71,14 +79,14 @@ class Asset(base.SpriteSubComponent):
     @property
     def folder(self):
         """
-        Get the folder name of this asset, based on the asset name. Uses the turbowarp syntax
+        Get the folder name of this asset, based on the asset name. Uses the TurboWarp syntax
         """
         return commons.get_folder_name(self.name)
 
     @property
     def name_nfldr(self):
         """
-        Get the asset name after removing the folder name
+        Get the asset name after removing the folder name. Uses the TurboWarp syntax
         """
         return commons.get_name_nofldr(self.name)
 
@@ -95,14 +103,16 @@ class Asset(base.SpriteSubComponent):
         """
         Get the exact file name, as it would be within an sb3 file
         equivalent to the md5ext value using in scratch project JSON
+
+        (alias for file_name)
         """
         return self.file_name
 
     @property
     def parent(self):
         """
-        Return the project that this asset is attached to. If there is no attached project,
-        try returning the attached sprite
+        Return the project (body) that this asset is attached to. If there is no attached project,
+        try returning the attached sprite instead.
         """
         if self.project is None:
             return self.sprite
@@ -194,8 +204,8 @@ class Costume(Asset):
 
         bitmap_resolution = data.get("bitmapResolution")
 
-        rotation_center_x = data["rotationCenterX"]
-        rotation_center_y = data["rotationCenterY"]
+        rotation_center_x = data.get("rotationCenterX", 0)
+        rotation_center_y = data.get("rotationCenterY", 0)
         return Costume(_asset_load.name, _asset_load.file_name,
 
                        bitmap_resolution, rotation_center_x, rotation_center_y)
@@ -206,10 +216,12 @@ class Costume(Asset):
         """
         _json = super().to_json()
         _json.update({
-            "bitmapResolution": self.bitmap_resolution,
             "rotationCenterX": self.rotation_center_x,
             "rotationCenterY": self.rotation_center_y
         })
+        if self.bitmap_resolution is not None:
+            _json["bitmapResolution"] = self.bitmap_resolution
+
         return _json
 
 

{scratchattach/editor → editor}/backpack_json.py

@@ -1,18 +1,16 @@
 """
-Module to deal with the backpack's weird JSON format, by overriding with new load methods
+Module to deal with the backpack's weird JSON format, by overriding editor classes with new load methods
 """
 from __future__ import annotations
 
 from . import block, prim, field, inputs, mutation, sprite
 
 
-def parse_prim_fields(_fields: dict[str]) -> tuple[str | None, str | None, str | None]:
+def parse_prim_fields(_fields: dict[str, dict[str, str]]) -> tuple[str | None, str | None, str | None]:
     """
     Function for reading the fields in a backpack **primitive**
     """
     for key, value in _fields.items():
-        key: str
-        value: dict[str, str]
         prim_value, prim_name, prim_id = (None,) * 3
         if key == "NUM":
             prim_value = value.get("value")
@@ -103,7 +101,7 @@ def load_script(_script_data: list[dict]) -> sprite.Sprite:
     """
     Loads a script into a sprite from the backpack JSON format
     :param _script_data: Backpack script JSON data
-    :return: a blockchain object containing the script
+    :return: a Sprite object containing the script
     """
     # Using a sprite since it simplifies things, e.g. local global loading
     _blockchain = sprite.Sprite()

{scratchattach/editor → editor}/base.py

@@ -52,7 +52,7 @@ class JSONSerializable(Base, ABC):
 
     def save_json(self, name: str = ''):
         """
-        Save a json file
+        Save json to a file. Adds '.json' for you.
         """
         data = self.to_json()
         with open(f"{self.__class__.__name__.lower()}{name}.json", "w") as f:
@@ -92,9 +92,7 @@ class SpriteSubComponent(JSONSerializable, ABC):
     sprite: module_sprite.Sprite
     def __init__(self, _sprite: "commons.SpriteInput" = build_defaulting.SPRITE_DEFAULT):
         if _sprite is build_defaulting.SPRITE_DEFAULT:
-            retrieved_sprite = build_defaulting.current_sprite()
-            assert retrieved_sprite is not None, "You don't have any sprites."
-            _sprite = retrieved_sprite
+            _sprite = build_defaulting.current_sprite()
         self.sprite = _sprite
 
     @property