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

scratchattach/cloud/cloud.py

@@ -1,183 +0,0 @@
-"""v2 ready: ScratchCloud, TwCloud and CustomCloud classes"""
-
-from __future__ import annotations
-import warnings
-
-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__()
-        
-        self.project_id = project_id
-
-        # Configure this object's attributes specifically for being used with Scratch's cloud:
-        self.cloud_host = "wss://clouddata.scratch.mit.edu"
-        self.length_limit = 256
-        self._session = _session
-        if self._session is not None:
-            self.username = self._session.username
-            self.cookie = "scratchsessionsid=" + self._session.id + ";"
-            self.origin = "https://scratch.mit.edu"
-
-    def connect(self):
-        self._assert_auth() # Connecting to Scratch's cloud websocket requires a login to the Scratch website
-        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
-
-    def set_var(self, variable, value):
-        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):
-        self._assert_auth() 
-        super().set_vars(var_value_dict, intelligent_waits=intelligent_waits)
-
-    def logs(self, *, filter_by_var_named=None, limit=100, offset=0) -> list[cloud_activity.CloudActivity]:
-        """
-        Gets the data from Scratch's clouddata logs.
-        
-        Keyword Arguments:
-            filter_by_var_named (str or None): If you only want to get data for one cloud variable, set this argument to its name.
-            limit (int): Max. amount of returned activity.
-            offset (int): Offset of the first activity in the returned list.
-            log_url (str): If you want to get the clouddata from a cloud log API different to Scratch's normal cloud log API, set this argument to the URL of the API. Only set this argument if you know what you are doing. If you want to get the clouddata from the normal API, don't put this argument.
-        """
-        try:
-            data = requests.get(f"https://clouddata.scratch.mit.edu/logs?projectid={self.project_id}&limit={limit}&offset={offset}", timeout=10).json()
-            if filter_by_var_named is not None:
-                filter_by_var_named = filter_by_var_named.removeprefix("☁ ")
-                data = list(filter(lambda k: k["name"] == "☁ "+filter_by_var_named, data))
-            for x in data:
-                x["cloud"] = self
-            return commons.parse_object_list(data, cloud_activity.CloudActivity, self._session, "name")
-        except Exception as e:
-            raise exceptions.FetchError(str(e))
-
-    def get_var(self, var, *, use_logs=False):
-        var = var.removeprefix("☁ ")
-        if self._session is None or use_logs:
-            filtered = self.logs(limit=100, filter_by_var_named="☁ "+var)
-            if len(filtered) == 0:
-                return None
-            return filtered[0].value
-        else:
-            if self.recorder is None:
-                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)
-
-    def get_all_vars(self, *, use_logs=False):
-        if self._session is None or use_logs:
-            logs = self.logs(limit=100)
-            logs.reverse()
-            clouddata = {}
-            for activity in logs:
-                clouddata[activity.name] = activity.value
-            return clouddata
-        else:
-            if self.recorder is None:
-                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()
-
-    def events(self, *, use_logs=False):
-        if self._session is None or use_logs:
-            from scratchattach.eventhandlers.cloud_events import CloudLogEvents
-            return CloudLogEvents(self)
-        else:
-            return super().events()
-
-
-class TwCloud(BaseCloud):
-    def __init__(self, *, project_id, cloud_host="wss://clouddata.turbowarp.org", purpose="", contact="",
-                 _session=None):
-        super().__init__()
-        
-        self.project_id = project_id
-        
-        # Configure this object's attributes specifically for being used with TurboWarp's cloud:
-        self.cloud_host = cloud_host
-        self.ws_shortterm_ratelimit = 0 # TurboWarp doesn't enforce a wait time between cloud variable sets
-        self.ws_longterm_ratelimit = 0
-        self.length_limit = 100000 # TurboWarp doesn't enforce a cloud variable length
-        purpose_string = ""
-        if purpose != "" or contact != "":
-            purpose_string = f" (Purpose:{purpose}; Contact:{contact})"
-        self.header = {"User-Agent":f"scratchattach/2.0.0{purpose_string}"}
-
-class CustomCloud(BaseCloud):
-
-    def __init__(self, *, project_id, cloud_host, **kwargs):
-        super().__init__()
-        
-        self.project_id = project_id
-        self.cloud_host = cloud_host
-
-        # Configure this object's attributes specifically for the cloud that the developer wants to connect to:
-        # -> For this purpose, all additional keyword arguments (kwargs) will be set as attributes of the CustomCloud object
-        # This allows the maximum amount of attribute customization
-        # See the docstring for the cloud._base.BaseCloud class to find out what attributes can be set / specified as keyword args
-        self.__dict__.update(kwargs)
-
-        # 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:
-    """
-    Connects to a cloud (by default Scratch's cloud) as logged out user.
-
-    Warning:
-        Since this method doesn't connect a login / session to the returned object, setting Scratch cloud variables won't be possible with it.
-
-        To set Scratch cloud variables, use `scratchattach.site.session.Session.connect_scratch_cloud` instead.
-
-    Args:
-        project_id:
-    
-    Keyword arguments:
-        CloudClass: The class that the returned object should be of. By default this class is scratchattach.cloud.ScratchCloud.
-
-    Returns:
-        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
-    )
-    return CloudClass(project_id=project_id)
-
-def get_scratch_cloud(project_id):
-    """
-    Warning:
-        Since this method doesn't connect a login / session to the returned object, setting Scratch cloud variables won't be possible with it.
-
-        To set Scratch cloud variables, use `scratchattach.Session.connect_scratch_cloud` instead.
-
-        
-    Returns:
-        scratchattach.cloud.ScratchCloud: An object representing the Scratch cloud of a project.
-    """
-    warnings.warn(
-        "To set Scratch cloud variables, use session.connect_scratch_cloud instead of get_scratch_cloud",
-        exceptions.AnonymousSiteComponentWarning
-    )
-    return ScratchCloud(project_id=project_id)
-
-def get_tw_cloud(project_id, *, purpose="", contact="", cloud_host="wss://clouddata.turbowarp.org"):
-    """
-    Returns:
-        scratchattach.cloud.TwCloud: An object representing the TurboWarp cloud of a project.
-    """
-    return TwCloud(project_id=project_id, purpose=purpose, contact=contact, cloud_host=cloud_host)

scratchattach/editor/__init__.py

@@ -1,21 +0,0 @@
-"""
-scratchattach.editor (sbeditor v2) - a library for all things sb3
-"""
-
-from .asset import Asset, Costume, Sound
-from .project import Project
-from .extension import Extensions, Extension
-from .mutation import Mutation, Argument, parse_proc_code
-from .meta import Meta, set_meta_platform
-from .sprite import Sprite
-from .block import Block
-from .prim import Prim, PrimTypes
-from .backpack_json import load_script as load_script_from_backpack
-from .twconfig import TWConfig, is_valid_twconfig
-from .inputs import Input, ShadowStatuses
-from .field import Field
-from .vlb import Variable, List, Broadcast
-from .comment import Comment
-from .monitor import Monitor
-
-from .build_defaulting import add_chain, add_comment, add_block

scratchattach/editor/asset.py

@@ -1,253 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from hashlib import md5
-import requests
-
-from . import base, commons, sprite, build_defaulting
-from typing import Optional
-
-
-@dataclass(init=True, repr=True)
-class AssetFile:
-    """
-    Represents the file information for an asset
-    - stores the filename, data, and md5 hash
-    """
-    filename: str
-    _data: bytes = field(repr=False, default_factory=bytes)
-    _md5: str = field(repr=False, default_factory=str)
-
-    @property
-    def data(self):
-        """
-        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/")
-            if rq.status_code != 200:
-                raise ValueError(f"Can't download asset {self.filename}\nIs not uploaded to scratch! Response: {rq.text}")
-
-            self._data = rq.content
-
-        return self._data
-
-    @property
-    def md5(self):
-        """
-        Compute/retrieve the md5 hash value of the asset file data
-        """
-        if self._md5 is None:
-            self._md5 = md5(self.data).hexdigest()
-
-        return self._md5
-
-
-class Asset(base.SpriteSubComponent):
-    def __init__(self,
-                 name: str = "costume1",
-                 file_name: str = "b7853f557e4426412e64bb3da6531a99.svg",
-                 _sprite: commons.SpriteInput = build_defaulting.SPRITE_DEFAULT):
-        """
-        Represents a generic asset. Can be a sound or an image.
-        https://en.scratch-wiki.info/wiki/Scratch_File_Format#Assets
-        """
-        try:
-            asset_id, data_format = file_name.split('.')
-        except ValueError:
-            raise ValueError(f"Invalid file name: {file_name}, # of '.' in {file_name} ({file_name.count('.')}) != 2; "
-                             f"(too many/few values to unpack)")
-        self.name = name
-
-        self.id = asset_id
-        self.data_format = data_format
-
-        super().__init__(_sprite)
-
-    def __repr__(self):
-        return f"Asset<{self.name!r}>"
-
-    @property
-    def folder(self):
-        """
-        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
-        """
-        return commons.get_name_nofldr(self.name)
-
-    @property
-    def file_name(self):
-        """
-        Get the exact file name, as it would be within an sb3 file
-        equivalent to the md5ext value using in scratch project JSON
-        """
-        return f"{self.id}.{self.data_format}"
-
-    @property
-    def md5ext(self):
-        """
-        Get the exact file name, as it would be within an sb3 file
-        equivalent to the md5ext value using in scratch project JSON
-        """
-        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
-        """
-        if self.project is None:
-            return self.sprite
-        else:
-            return self.project
-
-    @property
-    def asset_file(self) -> AssetFile:
-        """
-        Get the associated asset file object for this asset object
-        """
-        for asset_file in self.parent.asset_data:
-            if asset_file.filename == self.file_name:
-                return asset_file
-
-        # No pre-existing asset file object; create one and add it to the project
-        asset_file = AssetFile(self.file_name)
-        self.project.asset_data.append(asset_file)
-        return asset_file
-
-    @staticmethod
-    def from_json(data: dict):
-        """
-        Load asset data from project.json
-        """
-        _name = data.get("name")
-        assert isinstance(_name, str)
-        _file_name = data.get("md5ext")
-        if _file_name is None:
-            if "dataFormat" in data and "assetId" in data:
-                _id = data["assetId"]
-                _data_format = data["dataFormat"]
-                _file_name = f"{_id}.{_data_format}"
-            else:
-                _file_name = ""
-        assert isinstance(_file_name, str)
-
-        return Asset(_name, _file_name)
-
-    def to_json(self) -> dict:
-        """
-        Convert asset data to project.json format
-        """
-        return {
-            "name": self.name,
-
-            "assetId": self.id,
-            "md5ext": self.file_name,
-            "dataFormat": self.data_format,
-        }
-
-    # todo: implement below:
-    """
-    @staticmethod
-    def from_file(fp: str, name: str = None):
-        image_types = ("png", "jpg", "jpeg", "svg")
-        sound_types = ("wav", "mp3")
-        
-        # Should save data as well so it can be uploaded to scratch if required (add to project asset data)
-        ...
-    """
-
-
-class Costume(Asset):
-    def __init__(self,
-                 name: str = "Cat",
-                 file_name: str = "b7853f557e4426412e64bb3da6531a99.svg",
-
-                 bitmap_resolution=None,
-                 rotation_center_x: int | float = 48,
-                 rotation_center_y: int | float = 50,
-                 _sprite: commons.SpriteInput = build_defaulting.SPRITE_DEFAULT):
-        """
-        A costume (image). An asset with additional properties
-        https://en.scratch-wiki.info/wiki/Scratch_File_Format#Costumes
-        """
-        super().__init__(name, file_name, _sprite)
-
-        self.bitmap_resolution = bitmap_resolution
-        self.rotation_center_x = rotation_center_x
-        self.rotation_center_y = rotation_center_y
-
-    @staticmethod
-    def from_json(data):
-        """
-        Load costume data from project.json
-        """
-        _asset_load = Asset.from_json(data)
-
-        bitmap_resolution = data.get("bitmapResolution")
-
-        rotation_center_x = data["rotationCenterX"]
-        rotation_center_y = data["rotationCenterY"]
-        return Costume(_asset_load.name, _asset_load.file_name,
-
-                       bitmap_resolution, rotation_center_x, rotation_center_y)
-
-    def to_json(self) -> dict:
-        """
-        Convert costume to project.json format
-        """
-        _json = super().to_json()
-        _json.update({
-            "bitmapResolution": self.bitmap_resolution,
-            "rotationCenterX": self.rotation_center_x,
-            "rotationCenterY": self.rotation_center_y
-        })
-        return _json
-
-
-class Sound(Asset):
-    def __init__(self,
-                 name: str = "pop",
-                 file_name: str = "83a9787d4cb6f3b7632b4ddfebf74367.wav",
-
-                 rate: Optional[int] = None,
-                 sample_count: Optional[int] = None,
-                 _sprite: sprite.Sprite = build_defaulting.SPRITE_DEFAULT):
-        """
-        A sound. An asset with additional properties
-        https://en.scratch-wiki.info/wiki/Scratch_File_Format#Sounds
-        """
-        super().__init__(name, file_name, _sprite)
-
-        self.rate = rate
-        self.sample_count = sample_count
-
-    @staticmethod
-    def from_json(data):
-        """
-        Load sound from project.json
-        """
-        _asset_load = Asset.from_json(data)
-
-        rate = data.get("rate")
-        sample_count = data.get("sampleCount")
-        return Sound(_asset_load.name, _asset_load.file_name, rate, sample_count)
-
-    def to_json(self) -> dict:
-        """
-        Convert Sound to project.json format
-        """
-        _json = super().to_json()
-        commons.noneless_update(_json, {
-            "rate": self.rate,
-            "sampleCount": self.sample_count
-        })
-        return _json

scratchattach/editor/backpack_json.py

@@ -1,117 +0,0 @@
-"""
-Module to deal with the backpack's weird JSON format, by overriding 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]:
-    """
-    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")
-        else:
-            prim_name = value.get("value")
-            prim_id = value.get("id")
-
-        # There really should only be 1 item, and this function can only return for that item
-        return prim_value, prim_name, prim_id
-    return (None,) * 3
-
-
-class BpField(field.Field):
-    """
-    A normal field but with a different load method
-    """
-
-    @staticmethod
-    def from_json(data: dict[str, str]) -> field.Field:
-        # We can very simply convert it to the regular format
-        data = [data.get("value"), data.get("id")]
-        return field.Field.from_json(data)
-
-
-class BpInput(inputs.Input):
-    """
-    A normal input but with a different load method
-    """
-
-    @staticmethod
-    def from_json(data: dict[str, str]) -> inputs.Input:
-        # The actual data is stored in a separate prim block
-        _id = data.get("shadow")
-        _obscurer_id = data.get("block")
-
-        if _obscurer_id == _id:
-            # If both the shadow and obscurer are the same, then there is no actual obscurer
-            _obscurer_id = None
-        # We cannot work out the shadow status yet since that is located in the primitive
-        return inputs.Input(None, _id=_id, _obscurer_id=_obscurer_id)
-
-
-class BpBlock(block.Block):
-    """
-    A normal block but with a different load method
-    """
-
-    @staticmethod
-    def from_json(data: dict) -> prim.Prim | block.Block:
-        """
-        Load a block in the **backpack** JSON format
-        :param data: A dictionary (not list)
-        :return: A new block/prim object
-        """
-        _opcode = data["opcode"]
-
-        _x, _y = data.get("x"), data.get("y")
-        if prim.is_prim_opcode(_opcode):
-            # This is actually a prim
-            prim_value, prim_name, prim_id = parse_prim_fields(data["fields"])
-            return prim.Prim(prim.PrimTypes.find(_opcode, "opcode"),
-                             prim_value, prim_name, prim_id)
-
-        _next_id = data.get("next")
-        _parent_id = data.get("parent")
-
-        _shadow = data.get("shadow", False)
-        _top_level = data.get("topLevel", _parent_id is None)
-
-        _inputs = {}
-        for _input_code, _input_data in data.get("inputs", {}).items():
-            _inputs[_input_code] = BpInput.from_json(_input_data)
-
-        _fields = {}
-        for _field_code, _field_data in data.get("fields", {}).items():
-            _fields[_field_code] = BpField.from_json(_field_data)
-
-        if "mutation" in data:
-            _mutation = mutation.Mutation.from_json(data["mutation"])
-        else:
-            _mutation = None
-
-        return block.Block(_opcode, _shadow, _top_level, _mutation, _fields, _inputs, _x, _y, _next_id=_next_id,
-                           _parent_id=_parent_id)
-
-
-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
-    """
-    # Using a sprite since it simplifies things, e.g. local global loading
-    _blockchain = sprite.Sprite()
-
-    for _block_data in _script_data:
-        _block = BpBlock.from_json(_block_data)
-        _block.sprite = _blockchain
-        _blockchain.blocks[_block_data["id"]] = _block
-
-    _blockchain.link_subcomponents()
-    return _blockchain