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

editor/prim.py

@@ -0,0 +1,174 @@
+"""
+The PrimType(s) and Prim classes
+"""
+
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass
+from typing import Optional, Callable, Final
+
+from . import base, sprite, vlb, commons, build_defaulting
+from scratchattach.utils import enums, exceptions
+
+
+@dataclass
+class PrimType(base.JSONSerializable):
+    code: int
+    name: str
+    attrs: list = None
+    opcode: str = None
+
+    def __eq__(self, other):
+        if isinstance(other, str):
+            return self.name == other
+        elif isinstance(other, enums._EnumWrapper):
+            other = other.value
+        return super().__eq__(other)
+
+    @staticmethod
+    def from_json(data: int):
+        return PrimTypes.find(data, "code")
+
+    def to_json(self) -> int:
+        return self.code
+
+
+BASIC_ATTRS: Final[tuple[str]] = ("value",)
+VLB_ATTRS: Final[tuple[str]] = ("name", "id", "x", "y")
+
+
+class PrimTypes(enums._EnumWrapper):
+    # Yeah, they actually do have opcodes
+    NUMBER = PrimType(4, "number", BASIC_ATTRS, "math_number")
+    POSITIVE_NUMBER = PrimType(5, "positive number", BASIC_ATTRS, "math_positive_number")
+    POSITIVE_INTEGER = PrimType(6, "positive integer", BASIC_ATTRS, "math_whole_number")
+    INTEGER = PrimType(7, "integer", BASIC_ATTRS, "math_integer")
+    ANGLE = PrimType(8, "angle", BASIC_ATTRS, "math_angle")
+    COLOR = PrimType(9, "color", BASIC_ATTRS, "colour_picker")
+    STRING = PrimType(10, "string", BASIC_ATTRS, "text")
+    BROADCAST = PrimType(11, "broadcast", VLB_ATTRS, "event_broadcast_menu")
+    VARIABLE = PrimType(12, "variable", VLB_ATTRS, "data_variable")
+    LIST = PrimType(13, "list", VLB_ATTRS, "data_listcontents")
+
+    @classmethod
+    def find(cls, value, by: str, apply_func: Optional[Callable] = None) -> PrimType:
+        return super().find(value, by, apply_func=apply_func)
+
+
+def is_prim_opcode(opcode: str):
+    return opcode in PrimTypes.all_of("opcode") and opcode is not None
+
+
+class Prim(base.SpriteSubComponent):
+    def __init__(self, _primtype: PrimType | PrimTypes, _value: Optional[str | vlb.Variable | vlb.List | vlb.Broadcast] = None,
+                 _name: Optional[str] = None, _id: Optional[str] = None, _x: Optional[int] = None,
+                 _y: Optional[int] = None, _sprite: sprite.Sprite = build_defaulting.SPRITE_DEFAULT):
+        """
+        Class representing a Scratch string, number, angle, variable etc.
+        Technically blocks but behave differently
+        https://en.scratch-wiki.info/wiki/Scratch_File_Format#Targets:~:text=A%20few%20blocks,13
+        """
+        if isinstance(_primtype, PrimTypes):
+            _primtype = _primtype.value
+
+        self.type = _primtype
+
+        self.value = _value
+
+        self.name = _name
+        """
+        Once you get the object associated with this primitive (sprite.link_prims()), 
+        the name will be removed and the value will be changed from ``None``
+        """
+        self.value_id = _id
+        """
+        It's not an object accessed by id, but it may reference an object with an id.
+        
+        ----
+        
+        Once you get the object associated with it (sprite.link_prims()), 
+        the id will be removed and the value will be changed from ``None``
+        """
+
+        self.x = _x
+        self.y = _y
+
+        super().__init__(_sprite)
+
+    def __repr__(self):
+        if self.is_basic:
+            return f"Prim<{self.type.name}: {self.value}>"
+        elif self.is_vlb:
+            return f"Prim<{self.type.name}: {self.value}>"
+        else:
+            return f"Prim<{self.type.name}>"
+
+    @property
+    def is_vlb(self):
+        return self.type.attrs == VLB_ATTRS
+
+    @property
+    def is_basic(self):
+        return self.type.attrs == BASIC_ATTRS
+
+    @staticmethod
+    def from_json(data: list):
+        assert isinstance(data, list)
+
+        _type_idx = data[0]
+        _prim_type = PrimTypes.find(_type_idx, "code")
+
+        _value, _name, _value_id, _x, _y = (None,) * 5
+        if _prim_type.attrs == BASIC_ATTRS:
+            assert len(data) == 2
+            _value = data[1]
+
+        elif _prim_type.attrs == VLB_ATTRS:
+            assert len(data) in (3, 5)
+            _name, _value_id = data[1:3]
+
+            if len(data) == 5:
+                _x, _y = data[3:]
+
+        return Prim(_prim_type, _value, _name, _value_id, _x, _y)
+
+    def to_json(self) -> list:
+        if self.type.attrs == BASIC_ATTRS:
+            return [self.type.code, self.value]
+        else:
+            return commons.trim_final_nones([self.type.code, self.value.name, self.value.id, self.x, self.y])
+
+    def link_using_sprite(self):
+        # Link prim to var/list/broadcast
+        if self.is_vlb:
+            if self.type.name == "variable":
+                self.value = self.sprite.find_variable(self.value_id, "id")
+
+            elif self.type.name == "list":
+                self.value = self.sprite.find_list(self.value_id, "id")
+
+            elif self.type.name == "broadcast":
+                self.value = self.sprite.find_broadcast(self.value_id, "id")
+            else:
+                # This should never happen
+                raise exceptions.BadVLBPrimitiveError(f"{self} claims to be VLB, but is {self.type.name}")
+
+            if self.value is None:
+                if not self.project:
+                    new_vlb = vlb.construct(self.type.name.lower(), self.value_id, self.name)
+                    self.sprite.add_local_global(new_vlb)
+                    self.value = new_vlb
+
+                else:
+                    new_vlb = vlb.construct(self.type.name.lower(), self.value_id, self.name)
+                    self.sprite.stage.add_vlb(new_vlb)
+
+                    warnings.warn(
+                        f"Prim<name={self.name!r}, id={self.name!r}> has unknown {self.type.name} id; adding as global variable")
+            self.name = None
+            self.value_id = None
+
+    @property
+    def can_next(self):
+        return False

editor/project.py

@@ -0,0 +1,381 @@
+from __future__ import annotations
+
+import json
+import os
+import string
+import warnings
+from io import BytesIO, TextIOWrapper
+from typing import Optional, Iterable, Generator, BinaryIO
+from typing_extensions import deprecated
+from zipfile import ZipFile
+
+from . import base, meta, extension, monitor, sprite, asset, vlb, twconfig, comment, commons, mutation
+from scratchattach.site import session
+from scratchattach.utils import exceptions
+
+
+class Project(base.JSONExtractable):
+    """
+    A Project (body). Represents the editor contents of a scratch project
+    """
+    def __init__(self, _name: Optional[str] = None, _meta: Optional[meta.Meta] = None, _extensions: Iterable[extension.Extension] = (),
+                 _monitors: Iterable[monitor.Monitor] = (), _sprites: Iterable[sprite.Sprite] = (), *,
+                 _asset_data: Optional[list[asset.AssetFile]] = None, _session: Optional[session.Session] = None):
+        # Defaulting for list parameters
+        if _meta is None:
+            _meta = meta.Meta()
+        if _asset_data is None:
+            _asset_data = []
+
+        self._session = _session
+
+        self.name = _name
+
+        self.meta = _meta
+        self.extensions: list[extension.Extension] = list(_extensions)
+        self.monitors = list(_monitors)
+        self.sprites = list(_sprites)
+
+        self.asset_data = _asset_data
+
+        self._tw_config_comment = None
+
+        # Link subcomponents
+        for iterable in (self.monitors, self.sprites):
+            for _subcomponent in iterable:
+                _subcomponent.project = self
+
+        # Link sprites
+        _stage_count = 0
+
+        for _sprite in self.sprites:
+            if _sprite.is_stage:
+                _stage_count += 1
+
+            _sprite.link_subcomponents()
+
+        # Link monitors
+        for _monitor in self.monitors:
+            _monitor.link_using_project()
+
+        if _stage_count != 1:
+            raise exceptions.InvalidStageCount(f"Project {self}")
+
+    def __repr__(self):
+        _ret = "Project<"
+        if self.name is not None:
+            _ret += f"name={self.name}, "
+        _ret += f"meta={self.meta}"
+        _ret += '>'
+        return _ret
+
+    @property
+    def stage(self) -> Optional[sprite.Sprite]:
+        for _sprite in self.sprites:
+            if _sprite.is_stage:
+                return _sprite
+        warnings.warn(f"Could not find stage for {self.name}")
+        return None
+
+    def to_json(self) -> dict:
+        _json = {
+            "targets": [_sprite.to_json() for _sprite in self.sprites],
+            "monitors": [_monitor.to_json() for _monitor in self.monitors],
+            "extensions": [_extension.to_json() for _extension in self.extensions],
+            "meta": self.meta.to_json(),
+        }
+
+        return _json
+
+    @property
+    def assets(self) -> Generator[asset.Asset, None, None]:
+        for _sprite in self.sprites:
+            for _asset in _sprite.assets:
+                yield _asset
+
+    @property
+    def tw_config_comment(self) -> comment.Comment | None:
+        for _comment in self.stage.comments:
+            if twconfig.is_valid_twconfig(_comment.text):
+                return _comment
+        return None
+
+    @property
+    def tw_config(self) -> twconfig.TWConfig | None:
+        _comment = self.tw_config_comment
+        if _comment:
+            return twconfig.TWConfig.from_str(_comment.text)
+        return None
+
+    @property
+    def all_ids(self):
+        _ret = []
+        for _sprite in self.sprites:
+            _ret += _sprite.all_ids
+        return _ret
+
+    @property
+    def new_id(self):
+        return commons.gen_id()
+
+    @staticmethod
+    def from_json(data: dict):
+        assert isinstance(data, dict)
+
+        # Load metadata
+        _meta = meta.Meta.from_json(data.get("meta"))
+
+        # Load extensions
+        _extensions = []
+        for _extension_data in data.get("extensions", []):
+            _extensions.append(extension.Extension.from_json(_extension_data))
+
+        # Load monitors
+        _monitors = []
+        for _monitor_data in data.get("monitors", []):
+            _monitors.append(monitor.Monitor.from_json(_monitor_data))
+
+        # Load sprites (targets)
+        _sprites = []
+        for _sprite_data in data.get("targets", []):
+            _sprites.append(sprite.Sprite.from_json(_sprite_data))
+
+        return Project(None, _meta, _extensions, _monitors, _sprites)
+
+    @staticmethod
+    def load_json(data: str | bytes | TextIOWrapper | BinaryIO, load_assets: bool = True, _name: Optional[str] = None):
+        """
+        Load project JSON and assets from an .sb3 file/bytes/file path
+        :return: Project name, asset data, json string
+        """
+        _dir_for_name = None
+
+        if _name is None:
+            if hasattr(data, "name"):
+                _dir_for_name = data.name
+
+        if not isinstance(_name, str) and _name is not None:
+            _name = str(_name)
+
+        if isinstance(data, bytes):
+            data = BytesIO(data)
+
+        elif isinstance(data, str):
+            _dir_for_name = data
+            data = open(data, "rb")
+
+        if _name is None and _dir_for_name is not None:
+            # Remove any directory names and the file extension
+            _name = _dir_for_name.split('/')[-1]
+            _name = '.'.join(_name.split('.')[:-1])
+
+        asset_data = []
+        with data:
+            # For if the sb3 is just JSON (e.g. if it's exported from scratchattach)
+            if commons.is_valid_json(data):
+                json_str = data
+
+            else:
+                with ZipFile(data) as archive:
+                    json_str = archive.read("project.json")
+
+                    # Also load assets
+                    if load_assets:
+                        for filename in archive.namelist():
+                            if filename != "project.json":
+                                md5_hash = filename.split('.')[0]
+
+                                asset_data.append(
+                                    asset.AssetFile(filename, archive.read(filename), md5_hash)
+                                )
+
+                    else:
+                        warnings.warn(
+                            "Loading sb3 without loading assets. When exporting the project, there may be errors due to assets not being uploaded to the Scratch website")
+
+            return _name, asset_data, json_str
+
+    @classmethod
+    def from_sb3(cls, data: str | bytes | TextIOWrapper | BinaryIO, load_assets: bool = True, _name: Optional[str] = None):
+        """
+        Load a project from an .sb3 file/bytes/file path
+        """
+        _name, asset_data, json_str = cls.load_json(data, load_assets, _name)
+        data = json.loads(json_str)
+
+        project = cls.from_json(data)
+        project.name = _name
+        project.asset_data = asset_data
+
+        return project
+
+    @staticmethod
+    @deprecated("Use get_project(id).body() instead")
+    def from_id(project_id: int, _name: Optional[str] = None):
+        raise Exception("This method is deprecated")
+        # _proj = get_project(project_id)
+        # data = json.loads(_proj.get_json())
+
+        # if _name is None:
+        #     _name = _proj.title
+        # _name = str(_name)
+
+        # _proj = Project.from_json(data)
+        # _proj.name = _name
+        # return _proj
+
+    def find_vlb(self, value: str | None, by: str = "name",
+                 multiple: bool = False) -> Optional[vlb.Variable | vlb.List | vlb.Broadcast | list[
+        vlb.Variable | vlb.List | vlb.Broadcast]]:
+
+        _ret: list[vlb.Variable | vlb.List | vlb.Broadcast] = []
+        for _sprite in self.sprites:
+            val = _sprite.find_vlb(value, by, multiple)
+            if multiple:
+                _ret += val
+            else:
+                if val is not None:
+                    return val
+
+        if multiple:
+            return _ret
+
+        return None
+
+    def find_sprite(self, value: str | None, by: str = "name",
+                 multiple: bool = False) -> sprite.Sprite | list[sprite.Sprite]:
+        _ret = []
+        for _sprite in self.sprites:
+            if by == "name":
+                _val = _sprite.name
+            else:
+                _val = getattr(_sprite, by)
+
+            if _val == value:
+                if multiple:
+                    _ret.append(_sprite)
+                else:
+                    return _sprite
+
+        if multiple:
+            return _ret
+
+    def export(self, fp: str, *, auto_open: bool = False, export_as_zip: bool = True):
+        data = self.to_json()
+
+        if export_as_zip:
+            with ZipFile(fp, "w") as archive:
+                for _asset in self.assets:
+                    asset_file = _asset.asset_file
+                    if asset_file.filename not in archive.namelist():
+                        archive.writestr(asset_file.filename, asset_file.data)
+
+                archive.writestr("project.json", json.dumps(data))
+        else:
+            with open(fp, "w") as json_file:
+                json.dump(data, json_file)
+
+        if auto_open:
+            os.system(f"explorer.exe \"{fp}\"")
+
+    def add_monitor(self, _monitor: monitor.Monitor) -> monitor.Monitor:
+        """
+        Bind a monitor to this project. Doing these manually can lead to interesting results.
+        """
+        _monitor.project = self
+        _monitor.reporter_id = self.new_id
+        self.monitors.append(_monitor)
+        return _monitor
+
+    def obfuscate(self, *, goto_origin: bool=True) -> None:
+        """
+        Randomly set all the variable names etc. Do not upload this project to the scratch website, as it is
+        against the community guidelines.
+        """
+        # this code is an embarrassing mess. If certain features are added to sa.editor, then it could become a lot cleaner
+        chars = string.ascii_letters + string.digits + string.punctuation
+
+        def b10_to_cbase(b10: int | float):
+            ret = ''
+            new_base = len(chars)
+            while b10 >= 1:
+                ret = chars[int(b10 % new_base)] + ret
+                b10 /= new_base
+
+            return ret
+
+        used = 0
+
+        def rand():
+            nonlocal used
+            used += 1
+
+            return b10_to_cbase(used)
+
+        for _sprite in self.sprites:
+            procedure_mappings: dict[str, str] = {}
+            argument_mappings: dict[str, str] = {}
+            done_args: list[mutation.Argument] = []
+
+            for _variable in _sprite.variables:
+                _variable.name = rand()
+            for _list in _sprite.lists:
+                _list.name = rand()
+            # don't rename broadcasts as these can be dynamically called
+
+            def arg_get(name: str) -> str:
+                if name not in argument_mappings:
+                    argument_mappings[name] = rand()
+                return argument_mappings[name]
+
+            for _block in _sprite.blocks.values():
+                if goto_origin:
+                    _block.x, _block.y = 0, 0
+
+                # TODO: Add special handling for turbowarp debugger blocks
+                if _block.opcode in ("procedures_call", "procedures_prototype", "procedures_definition"):
+                    if _block.mutation is None:
+                        continue
+
+                    proccode = _block.mutation.proc_code
+                    if proccode is None:
+                        continue
+
+                    if proccode not in procedure_mappings:
+                        parsed_ppc = _block.mutation.parsed_proc_code
+
+                        if parsed_ppc is None:
+                            continue
+
+                        new: list[str | mutation.ArgumentType] = []
+                        for item in parsed_ppc:
+                            if isinstance(item, str):
+                                item = rand()
+
+                            new.append(item)
+
+                        new_proccode = mutation.construct_proccode(*new)
+                        procedure_mappings[proccode] = new_proccode
+
+                    _block.mutation.proc_code = procedure_mappings[proccode]
+
+                    assert _block.mutation.arguments is not None
+                    for arg in _block.mutation.arguments:
+                        if arg in done_args:
+                            continue
+                        done_args.append(arg)
+
+                        arg.name = arg_get(arg.name)
+
+                    # print(_block, _block.mutation)
+                elif _block.opcode in ("argument_reporter_string_number", "argument_reporter_boolean"):
+                    arg_name = _block.fields["VALUE"].value
+                    assert isinstance(arg_name, str)
+                    _block.fields["VALUE"].value = arg_get(arg_name)
+
+
+                # print(argument_mappings)
+
+            if goto_origin:
+                for _comment in _sprite.comments:
+                    _comment.x, _comment.y = 0, 0