scratchattach 2.1.14__py3-none-any.whl → 3.0.0b0__py3-none-any.whl

scratchattach/editor/vlb.py

@@ -1,134 +0,0 @@
-"""
-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 = []
-
-        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,100 +0,0 @@
-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)
-
-    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

@@ -1,110 +0,0 @@
-"""CloudEvents class"""
-from __future__ import annotations
-
-from scratchattach.cloud import _base
-from ._base import BaseEventHandler
-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
-
-    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,26 +0,0 @@
-"""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