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

scratchattach/editor/backpack_json.py

@@ -0,0 +1,117 @@
+"""
+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

scratchattach/editor/base.py

@@ -0,0 +1,142 @@
+"""
+Editor base classes
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+from abc import ABC, abstractmethod
+from io import TextIOWrapper
+from typing import Optional, Any, TYPE_CHECKING, BinaryIO
+
+if TYPE_CHECKING:
+    from . import project, sprite, block, mutation, asset
+
+from . import build_defaulting
+
+
+class Base(ABC):
+    def dcopy(self):
+        """
+        :return: A **deep** copy of self
+        """
+        return copy.deepcopy(self)
+
+    def copy(self):
+        """
+        :return: A **shallow** copy of self
+        """
+        return copy.copy(self)
+
+
+class JSONSerializable(Base, ABC):
+    @staticmethod
+    @abstractmethod
+    def from_json(data: dict | list | Any):
+        pass
+
+    @abstractmethod
+    def to_json(self) -> dict | list | Any:
+        pass
+
+    def save_json(self, name: str = ''):
+        data = self.to_json()
+        with open(f"{self.__class__.__name__.lower()}{name}.json", "w") as f:
+            json.dump(data, f)
+
+
+class JSONExtractable(JSONSerializable, ABC):
+    @staticmethod
+    @abstractmethod
+    def load_json(data: str | bytes | TextIOWrapper | BinaryIO, load_assets: bool = True, _name: Optional[str] = None) -> tuple[
+        str, list[asset.AssetFile], str]:
+        """
+        Automatically extracts the JSON data as a string, as well as providing auto naming
+        :param data: Either a string of JSON, sb3 file as bytes or as a file object
+        :param load_assets: Whether to extract assets as well (if applicable)
+        :param _name: Any provided name (will automatically find one otherwise)
+        :return: tuple of the name, asset data & json as a string
+        """
+        ...
+
+
+class ProjectSubcomponent(JSONSerializable, ABC):
+    def __init__(self, _project: Optional[project.Project] = None):
+        self.project = _project
+
+
+class SpriteSubComponent(JSONSerializable, ABC):
+    def __init__(self, _sprite: sprite.Sprite = build_defaulting.SPRITE_DEFAULT):
+        if _sprite is build_defaulting.SPRITE_DEFAULT:
+            _sprite = build_defaulting.current_sprite()
+
+        self.sprite = _sprite
+
+    # @property
+    # def sprite(self):
+    #     if self._sprite is None:
+    #         print("ok, ", build_defaulting.current_sprite())
+    #         return build_defaulting.current_sprite()
+    #     else:
+    #         return self._sprite
+
+    # @sprite.setter
+    # def sprite(self, value):
+    #     self._sprite = value
+
+    @property
+    def project(self) -> project.Project:
+        return self.sprite.project
+
+
+class IDComponent(SpriteSubComponent, ABC):
+    def __init__(self, _id: str, _sprite: sprite.Sprite = build_defaulting.SPRITE_DEFAULT):
+        self.id = _id
+        super().__init__(_sprite)
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}: {self.id}>"
+
+
+class NamedIDComponent(IDComponent, ABC):
+    """
+    Base class for Variables, Lists and Broadcasts (Name + ID + sprite)
+    """
+
+    def __init__(self, _id: str, name: str, _sprite: sprite.Sprite = build_defaulting.SPRITE_DEFAULT):
+        self.name = name
+        super().__init__(_id, _sprite)
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} '{self.name}'>"
+
+
+class BlockSubComponent(JSONSerializable, ABC):
+    def __init__(self, _block: Optional[block.Block] = None):
+        self.block = _block
+
+    @property
+    def sprite(self) -> sprite.Sprite:
+        return self.block.sprite
+
+    @property
+    def project(self) -> project.Project:
+        return self.sprite.project
+
+
+class MutationSubComponent(JSONSerializable, ABC):
+    def __init__(self, _mutation: Optional[mutation.Mutation] = None):
+        self.mutation = _mutation
+
+    @property
+    def block(self) -> block.Block:
+        return self.mutation.block
+
+    @property
+    def sprite(self) -> sprite.Sprite:
+        return self.block.sprite
+
+    @property
+    def project(self) -> project.Project:
+        return self.sprite.project