scratchattach 3.0.0b0__py3-none-any.whl → 3.0.0b2__py3-none-any.whl

scratchattach/editor/twconfig.py

@@ -0,0 +1,114 @@
+"""
+Parser for TurboWarp settings configuration
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from dataclasses import dataclass
+from typing import Any
+
+from . import commons, base
+
+_START = """Configuration for https://turbowarp.org/
+You can move, resize, and minimize this comment, but don't edit it by hand. This comment can be deleted to remove the stored settings.
+"""
+_END = " // _twconfig_"
+
+
+@dataclass
+class TWConfig(base.JSONSerializable):
+    framerate: int = None,
+    interpolation: bool = False,
+    hq_pen: bool = False,
+    max_clones: float | int | None = None,
+    misc_limits: bool = True,
+    fencing: bool = True
+    width: int = None
+    height: int = None
+
+    @staticmethod
+    def from_json(data: dict) -> TWConfig:
+        # Non-runtime options
+        _framerate = data.get("framerate")
+        _interpolation = data.get("interpolation", False)
+        _hq_pen = data.get("hq", False)
+
+        # Runtime options
+        _runtime_options = data.get("runtimeOptions", {})
+
+        # Luckily for us, the JSON module actually accepts the 'Infinity' literal. Otherwise, it would be a right pain
+        _max_clones = _runtime_options.get("maxClones")
+        _misc_limits = _runtime_options.get("miscLimits", True)
+        _fencing = _runtime_options.get("fencing", True)
+
+        # Custom stage size
+        _width = data.get("width")
+        _height = data.get("height")
+
+        return TWConfig(_framerate, _interpolation, _hq_pen, _max_clones, _misc_limits, _fencing, _width, _height)
+
+    def to_json(self) -> dict:
+        runtime_options = {}
+        commons.noneless_update(
+            runtime_options,
+            {
+                "maxClones": self.max_clones,
+                "miscLimits": none_if_eq(self.misc_limits, True),
+                "fencing": none_if_eq(self.fencing, True)
+            })
+
+        data = {}
+        commons.noneless_update(data, {
+            "framerate": self.framerate,
+            "runtimeOptions": runtime_options,
+            "interpolation": none_if_eq(self.interpolation, False),
+            "hq": none_if_eq(self.hq_pen, False),
+            "width": self.width,
+            "height": self.height
+        })
+        return data
+
+    @property
+    def infinite_clones(self):
+        return self.max_clones == math.inf
+
+    @staticmethod
+    def from_str(string: str):
+        return TWConfig.from_json(get_twconfig_data(string))
+
+
+def is_valid_twconfig(string: str) -> bool:
+    """
+    Checks if some text is TWConfig (does not check the JSON itself)
+    :param string: text (from a comment)
+    :return: Boolean whether it is TWConfig
+    """
+
+    if string.startswith(_START) and string.endswith(_END):
+        json_part = string[len(_START):-len(_END)]
+        if commons.is_valid_json(json_part):
+            return True
+    return False
+
+
+def get_twconfig_data(string: str) -> dict | None:
+    try:
+        return json.loads(string[len(_START):-len(_END)])
+    except ValueError:
+        return None
+
+
+# todo: move this to commons.py?
+def none_if_eq(data, compare) -> Any | None:
+    """
+    Returns None if data and compare are the same
+    :param data: Original data
+    :param compare: Data to compare
+    :return: Either the original data or None
+    """
+    if data == compare:
+        return None
+    else:
+        return data

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 scratchattach.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: list[str | int | float] = []
+
+        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, list[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

@@ -0,0 +1,101 @@
+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 scratchattach.utils.requests import requests
+from scratchattach.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)
+        print(f"{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 : list = []):
+        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

@@ -0,0 +1,130 @@
+"""CloudEvents class"""
+from __future__ import annotations
+
+import traceback
+
+from scratchattach.cloud import _base
+from ._base import BaseEventHandler
+from scratchattach.utils import exceptions
+from scratchattach.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
+        self.subsequent_reconnects = 0
+
+    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
+        
+        # TODO: refactor this method. It works, but is hard to read
+        while True:
+            try:
+                while True:
+                    # print("Checking for more events")
+                    for data in self.source_stream.read():
+                        # print(f"Got event {data}")
+                        self.subsequent_reconnects = 0
+                        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
+                                # print(f"Skipped as {_a.timestamp} < {self.startup_time + 500}")
+                                continue
+                            data["variable_name"] = data["name"]
+                            data["name"] = data["variable_name"].replace("☁ ", "")
+                            _a._update_from_dict(data)
+                            # print(f"sending event {_a}")
+                            self.call_event("on_"+_a.type, [_a])
+                        except Exception as e:
+                            print(f"Cloud events _updated ignored: {e} {traceback.format_exc()}")
+                            pass
+            except Exception:
+                self.subsequent_reconnects += 1
+                time.sleep(0.1) # cooldown
+
+            if self.subsequent_reconnects >= 5:
+                print(f"Warning: {self.subsequent_reconnects} subsequent cloud disconnects. Cloud may be down, causing CloudEvents to not call events.")
+            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
+        self.subsequent_failed_log_fetches = 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)
+            self.subsequent_failed_log_fetches = 0
+            for _a in data[::-1]:
+                if _a.timestamp <= self.last_timestamp:
+                    continue
+                self.last_timestamp = _a.timestamp
+                yield ("on_"+_a.type, [_a])
+        except Exception:
+            self.subsequent_failed_log_fetches += 1
+            if self.subsequent_failed_log_fetches == 20:
+                print("Warning: 20 subsequent clouddata log fetches failed. Scrach's cloud logs may be down, causing CloudLogEvents to not call events.")
+        
+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):
+        try:
+            logs = self.source_cloud.logs(limit=25)
+        except exceptions.FetchError:
+            logs = []
+
+        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

@@ -0,0 +1,26 @@
+"""CloudRecorder class (used by ScratchCloud, TwCloud and other classes inheriting from BaseCloud to deliver cloud var values)"""
+from __future__ import annotations
+
+from typing import Optional, Any
+
+from .cloud_events import CloudEvents
+
+
+class CloudRecorder(CloudEvents):
+    def __init__(self, cloud, *, initial_values: Optional[dict[str, Any]] = None):
+        initial_values = initial_values or {}
+
+        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