scratchattach 2.1.9__py3-none-any.whl → 2.1.10a1__py3-none-any.whl

scratchattach/editor/vlb.py

@@ -0,0 +1,134 @@
+"""
+Variables, lists & broadcasts
+"""
+# Perhaps ids should not be stored in these objects, but in the sprite, similarly
+# to how blocks/prims are stored
+
+from __future__ import annotations
+
+from typing import Optional, Literal
+
+from . import base, sprite, build_defaulting
+from ..utils import exceptions
+
+
+class Variable(base.NamedIDComponent):
+    def __init__(self, _id: str, _name: str, _value: Optional[str | int | float] = None, _is_cloud: bool = False,
+                 _sprite: sprite.Sprite = build_defaulting.SPRITE_DEFAULT):
+        """
+        Class representing a variable.
+        https://en.scratch-wiki.info/wiki/Scratch_File_Format#Targets:~:text=variables,otherwise%20not%20present
+        """
+        if _value is None:
+            _value = 0
+
+        self.value = _value
+        self.is_cloud = _is_cloud
+
+        super().__init__(_id, _name, _sprite)
+
+    @property
+    def is_global(self):
+        """
+        Works out whethere a variable is global based on whether the sprite is a stage
+        :return: Whether this variable is a global variable.
+        """
+        return self.sprite.is_stage
+
+    @staticmethod
+    def from_json(data: tuple[str, tuple[str, str | int | float] | tuple[str, str | int | float, bool]]):
+        """
+        Read data in format: (variable id, variable JSON)
+        """
+        assert len(data) == 2
+        _id, data = data
+
+        assert len(data) in (2, 3)
+        _name, _value = data[:2]
+
+        if len(data) == 3:
+            _is_cloud = data[2]
+        else:
+            _is_cloud = False
+
+        return Variable(_id, _name, _value, _is_cloud)
+
+    def to_json(self) -> tuple[str, str | int | float, bool] | tuple[str, str | int | float]:
+        """
+        Returns Variable data as a tuple
+        """
+        if self.is_cloud:
+            _ret = self.name, self.value, True
+        else:
+            _ret = self.name, self.value
+
+        return _ret
+
+
+class List(base.NamedIDComponent):
+    def __init__(self, _id: str, _name: str, _value: Optional[list[str | int | float]] = None,
+                 _sprite: sprite.Sprite = build_defaulting.SPRITE_DEFAULT):
+        """
+        Class representing a list.
+        https://en.scratch-wiki.info/wiki/Scratch_File_Format#Targets:~:text=lists,as%20an%20array
+        """
+        if _value is None:
+            _value = []
+
+        self.value = _value
+        super().__init__(_id, _name, _sprite)
+
+    @staticmethod
+    def from_json(data: tuple[str, tuple[str, str | int | float] | tuple[str, str | int | float, bool]]):
+        """
+        Read data in format: (variable id, variable JSON)
+        """
+        assert len(data) == 2
+        _id, data = data
+
+        assert len(data) == 2
+        _name, _value = data
+
+        return List(_id, _name, _value)
+
+    def to_json(self) -> tuple[str, tuple[str, str | int | float, bool] | tuple[str, str | int | float]]:
+        """
+        Returns List data as a tuple
+        """
+        return self.name, self.value
+
+
+class Broadcast(base.NamedIDComponent):
+    def __init__(self, _id: str, _name: str, _sprite: sprite.Sprite = build_defaulting.SPRITE_DEFAULT):
+        """
+        Class representing a broadcast.
+        https://en.scratch-wiki.info/wiki/Scratch_File_Format#Targets:~:text=broadcasts,in%20the%20stage
+        """
+        super().__init__(_id, _name, _sprite)
+
+    @staticmethod
+    def from_json(data: tuple[str, str]):
+        assert len(data) == 2
+        _id, _name = data
+
+        return Broadcast(_id, _name)
+
+    def to_json(self) -> str:
+        """
+        :return: Broadcast as JSON (just a string of its name)
+        """
+        return self.name
+
+
+def construct(vlb_type: Literal["variable", "list", "broadcast"], _id: Optional[str] = None, _name: Optional[str] = None,
+              _sprite: sprite.Sprite = build_defaulting.SPRITE_DEFAULT) -> Variable | List | Broadcast:
+    if vlb_type == "variable":
+        vlb_type = Variable
+    elif vlb_type == "list":
+        vlb_type = List
+    elif vlb_type == "broadcast":
+        vlb_type = Broadcast
+    else:
+        raise exceptions.InvalidVLBName(f"Bad VLB {vlb_type!r}")
+
+    return vlb_type(_id, _name, _sprite)

scratchattach/eventhandlers/_base.py

@@ -1,93 +1,100 @@
-from abc import ABC, abstractmethod
-from ..utils.requests import Requests as requests
-from threading import Thread
-from ..utils import exceptions
-import traceback
-from . import cloud_recorder
-
-class BaseEventHandler(ABC):
-
-    def __init__(self):
-        self._thread = None
-        self.running = False
-        self._events = {}
-        self._threaded_events = {}
-
-    def start(self, *, thread=True, ignore_exceptions=True):
-        """
-        Starts the event handler.
-
-        Keyword Arguments:
-            thread (bool): Whether the event handler should be run in a thread.
-            ignore_exceptions (bool): Whether to catch exceptions that happen in individual events
-        """
-        if self.running is False:
-            self.ignore_exceptions = ignore_exceptions
-            self.running = True
-            if thread:
-                self._thread = Thread(target=self._updater, args=())
-                self._thread.start()
-            else:
-                self._thread = None
-                self._updater()
-    
-    def call_event(self, event_name, args=[]):
-        try:
-            if event_name in self._threaded_events:
-                Thread(target=self._threaded_events[event_name], args=args).start()
-            if event_name in self._events:
-                self._events[event_name](*args)
-        except Exception as e:
-            if self.ignore_exceptions:
-                print(
-                    f"Warning: Caught error in event '{event_name}' - Full error below"
-                )
-                try:
-                    traceback.print_exc()
-                except Exception:
-                    print(e)
-            else:
-                raise(e)
-
-    @abstractmethod
-    def _updater(self):
-        pass
-
-    def stop(self):
-        """
-        Permanently stops the event handler.
-        """
-        self.running = False
-        if self._thread is not None:
-            self._thread = None
-
-    def pause(self):
-        """
-        Pauses the event handler.
-        """
-        self.running = False
-
-    def resume(self):
-        """
-        Resumes the event handler.
-        """
-        if self.running is False:
-            self.start()
-
-    def event(self, function=None, *, thread=False):
-        """
-        Decorator function. Adds an event.
-        """
-        def inner(function):
-            # called directly if the decorator provides arguments
-            if thread is True:
-                self._threaded_events[function.__name__] = function
-            else:
-                self._events[function.__name__] = function
-
-        if function is None:
-            # => the decorator provides arguments
-            return inner
-        else:
-            # => the decorator doesn't provide arguments
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections import defaultdict
+from threading import Thread
+from collections.abc import Callable
+import traceback
+from ..utils.requests import Requests as requests
+from ..utils import exceptions
+
+class BaseEventHandler(ABC):
+    _events: defaultdict[str, list[Callable]]
+    _threaded_events: defaultdict[str, list[Callable]]
+
+    def __init__(self):
+        self._thread = None
+        self.running = False
+        self._events = defaultdict(list)
+        self._threaded_events = defaultdict(list)
+
+    def start(self, *, thread=True, ignore_exceptions=True):
+        """
+        Starts the event handler.
+
+        Keyword Arguments:
+            thread (bool): Whether the event handler should be run in a thread.
+            ignore_exceptions (bool): Whether to catch exceptions that happen in individual events
+        """
+        if self.running is False:
+            self.ignore_exceptions = ignore_exceptions
+            self.running = True
+            if thread:
+                self._thread = Thread(target=self._updater, args=())
+                self._thread.start()
+            else:
+                self._thread = None
+                self._updater()
+    
+    def call_event(self, event_name, args=[]):
+        try:
+            if event_name in self._threaded_events:
+                for func in self._threaded_events[event_name]:
+                    Thread(target=func, args=args).start()
+            if event_name in self._events:
+                for func in self._events[event_name]:
+                    func(*args)
+        except Exception as e:
+            if self.ignore_exceptions:
+                print(
+                    f"Warning: Caught error in event '{event_name}' - Full error below"
+                )
+                try:
+                    traceback.print_exc()
+                except Exception:
+                    print(e)
+            else:
+                raise(e)
+
+    @abstractmethod
+    def _updater(self):
+        pass
+
+    def stop(self):
+        """
+        Permanently stops the event handler.
+        """
+        self.running = False
+        if self._thread is not None:
+            self._thread = None
+
+    def pause(self):
+        """
+        Pauses the event handler.
+        """
+        self.running = False
+
+    def resume(self):
+        """
+        Resumes the event handler.
+        """
+        if self.running is False:
+            self.start()
+
+    def event(self, function=None, *, thread=False):
+        """
+        Decorator function. Adds an event.
+        """
+        def inner(function):
+            # called directly if the decorator provides arguments
+            if thread is True:
+                self._threaded_events[function.__name__].append(function)
+            else:
+                self._events[function.__name__].append(function)
+
+        if function is None:
+            # => the decorator provides arguments
+            return inner
+        else:
+            # => the decorator doesn't provide arguments
             inner(function)

scratchattach/eventhandlers/cloud_events.py

@@ -1,103 +1,110 @@
-"""CloudEvents class"""
-
-from ..cloud import cloud
-from ._base import BaseEventHandler
-from ..site import cloud_activity
-import time
-import json
-from threading import Thread
-
-class CloudEvents(BaseEventHandler):
-    """
-    Class that calls events when on cloud updates that are received through a websocket connection.
-    """
-    def __init__(self, cloud):
-        super().__init__()
-        self.cloud = cloud
-        self._session = cloud._session
-        self.source_cloud = type(cloud)(project_id=cloud.project_id)
-        self.source_cloud._session = cloud._session
-        self.source_cloud.cookie = cloud.cookie
-        self.source_cloud.header = cloud.header
-        self.source_cloud.origin = cloud.origin
-        self.source_cloud.username = cloud.username
-        self.source_cloud.ws_timeout = None # No timeout -> allows continous listening
-        self.startup_time = time.time() * 1000
-
-    def _updater(self):
-        """
-        A process that listens for cloud activity and executes events on cloud activity
-        """
-        self.source_cloud.connect()
-        
-        self.call_event("on_ready")
-
-        if self.running is False:
-            return
-        while True:
-            try:
-                while True:
-                    data = self.source_cloud.websocket.recv().split('\n')   
-                    result = []
-                    for i in data:
-                        try:
-                            _a = cloud_activity.CloudActivity(timestamp=time.time()*1000, _session=self._session, cloud=self.cloud)
-                            if _a.timestamp < self.startup_time + 500: # catch the on_connect message sent by TurboWarp's (and sometimes Scratch's) cloud server
-                                continue
-                            data = json.loads(i)
-                            data["name"] = data["name"].replace("☁ ", "")
-                            _a._update_from_dict(data)
-                            self.call_event("on_"+_a.type, [_a])
-                        except Exception as e:
-                            pass
-            except Exception:
-                print("CloudEvents: Disconnected. Reconnecting ...", time.time())
-                time.sleep(0.1) # cooldown
-            while True:
-                try:
-                    self.source_cloud.connect()
-                except Exception:
-                    print("CloudEvents: Reconnecting failed, trying again in 10 seconds.", time.time())
-                    time.sleep(10)
-                else:
-                    break
-
-            print("CloudEvents: Reconnected.", time.time())
-            self.call_event("on_reconnect", [])
-
-
-class CloudLogEvents(BaseEventHandler):
-    """
-    Class that calls events on cloud updates that are received from a clouddata log.
-    """
-    def __init__(self, cloud, *, update_interval=0.1):
-        super().__init__()
-        if not hasattr(cloud, "logs"):
-            raise ValueError("Cloud log events can't be used with a cloud that has no logs available")
-        self.cloud = cloud
-        self.source_cloud = cloud
-        self.update_interval = update_interval
-        self._session = cloud._session
-        self.last_timestamp = 0
-
-    def _updater(self):
-        logs = self.source_cloud.logs(limit=25)
-        self.last_timestamp = 0
-        if len(logs) != 0:
-            self.last_timestamp = logs[0].timestamp
-
-        self.call_event("on_ready")
-
-        while True:
-            if self.running is False:
-                return
-            try:
-                data = self.source_cloud.logs(limit=25)
-                for _a in data[::-1]:
-                    if _a.timestamp <= self.last_timestamp:
-                        continue
-                    self.last_timestamp = _a.timestamp
-                    self.call_event("on_"+_a.type, [_a])
-            except Exception:
-                pass
-            time.sleep(self.update_interval)
+"""CloudEvents class"""
+from __future__ import annotations
+
+from ..cloud import _base
+from ._base import BaseEventHandler
+from ..site import cloud_activity
+import time
+import json
+from collections.abc import Iterator
+
+class CloudEvents(BaseEventHandler):
+    """
+    Class that calls events when on cloud updates that are received through a websocket connection.
+    """
+    def __init__(self, cloud: _base.AnyCloud):
+        super().__init__()
+        self.cloud = cloud
+        self._session = cloud._session
+        self.source_stream = cloud.create_event_stream()
+        self.startup_time = time.time() * 1000
+
+    def disconnect(self):
+        self.source_stream.close()
+
+    def _updater(self):
+        """
+        A process that listens for cloud activity and executes events on cloud activity
+        """
+        
+        self.call_event("on_ready")
+
+        if self.running is False:
+            return
+        while True:
+            try:
+                while True:
+                    for data in self.source_stream.read():
+                        try:
+                            _a = cloud_activity.CloudActivity(timestamp=time.time()*1000, _session=self._session, cloud=self.cloud)
+                            if _a.timestamp < self.startup_time + 500: # catch the on_connect message sent by TurboWarp's (and sometimes Scratch's) cloud server
+                                continue
+                            data["variable_name"] = data["name"]
+                            data["name"] = data["variable_name"].replace("☁ ", "")
+                            _a._update_from_dict(data)
+                            self.call_event("on_"+_a.type, [_a])
+                        except Exception as e:
+                            pass
+            except Exception:
+                print("CloudEvents: Disconnected. Reconnecting ...", time.time())
+                time.sleep(0.1) # cooldown
+
+            print("CloudEvents: Reconnected.", time.time())
+            self.call_event("on_reconnect", [])
+
+class ManualCloudLogEvents:
+    """
+    Class that calls events on cloud updates that are received from a clouddata log.
+    """
+    def __init__(self, cloud: _base.LogCloud):
+        if not isinstance(cloud, _base.LogCloud):
+            raise ValueError("Cloud log events can't be used with a cloud that has no logs available")
+        self.cloud = cloud
+        self.source_cloud = cloud
+        self._session = cloud._session
+        self.last_timestamp = 0
+    
+    def update(self) -> Iterator[tuple[str, list[cloud_activity.CloudActivity]]]:
+        """
+        Update once and yield all packets
+        """
+        try:
+            data = self.source_cloud.logs(limit=25)
+            for _a in data[::-1]:
+                if _a.timestamp <= self.last_timestamp:
+                    continue
+                self.last_timestamp = _a.timestamp
+                yield ("on_"+_a.type, [_a])
+        except Exception:
+            pass
+        
+
+class CloudLogEvents(BaseEventHandler):
+    """
+    Class that calls events on cloud updates that are received from a clouddata log.
+    """
+    def __init__(self, cloud: _base.LogCloud, *, update_interval=0.1):
+        super().__init__()
+        if not isinstance(cloud, _base.LogCloud):
+            raise ValueError("Cloud log events can't be used with a cloud that has no logs available")
+        self.cloud = cloud
+        self.source_cloud = cloud
+        self.update_interval = update_interval
+        self._session = cloud._session
+        self.last_timestamp = 0
+        self.manual_cloud_log_events = ManualCloudLogEvents(cloud)
+
+    def _updater(self):
+        logs = self.source_cloud.logs(limit=25)
+        self.last_timestamp = 0
+        if len(logs) != 0:
+            self.last_timestamp = logs[0].timestamp
+
+        self.call_event("on_ready")
+
+        while True:
+            if self.running is False:
+                return
+            for event_type, event_data in self.manual_cloud_log_events.update():
+                self.call_event(event_type, event_data)
+            time.sleep(self.update_interval)

scratchattach/eventhandlers/cloud_recorder.py

@@ -1,21 +1,26 @@
-"""CloudRecorder class (used by ScratchCloud, TwCloud and other classes inheriting from BaseCloud to deliver cloud var values)"""
-
-from .cloud_events import CloudEvents
-
-class CloudRecorder(CloudEvents):
-
-    def __init__(self, cloud, *, initial_values={}):
-        super().__init__(cloud)
-        self.cloud_values = initial_values
-        self.event(self.on_set)
-
-    def get_var(self, var):
-        if not var in self.cloud_values:
-            return None
-        return self.cloud_values[var]
-    
-    def get_all_vars(self):
-        return self.cloud_values
-    
-    def on_set(self, activity):
-        self.cloud_values[activity.var] = activity.value
+"""CloudRecorder class (used by ScratchCloud, TwCloud and other classes inheriting from BaseCloud to deliver cloud var values)"""
+from __future__ import annotations
+
+from .cloud_events import CloudEvents
+from typing import Optional
+
+
+class CloudRecorder(CloudEvents):
+    def __init__(self, cloud, *, initial_values: Optional[dict] = None):
+        if initial_values is None:
+            initial_values = {}
+
+        super().__init__(cloud)
+        self.cloud_values = initial_values
+        self.event(self.on_set)
+
+    def get_var(self, var):
+        if var not in self.cloud_values:
+            return None
+        return self.cloud_values[var]
+
+    def get_all_vars(self):
+        return self.cloud_values
+
+    def on_set(self, activity):
+        self.cloud_values[activity.var] = activity.value