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

scratchattach/editor/monitor.py

@@ -1,183 +0,0 @@
-from __future__ import annotations
-
-import warnings
-from typing import Optional, TYPE_CHECKING
-
-from typing_extensions import deprecated
-
-if TYPE_CHECKING:
-    from .block import Block
-    from . import project
-
-from . import base
-
-
-class Monitor(base.ProjectSubcomponent):
-    def __init__(self, reporter: Optional[base.NamedIDComponent] = None,
-                 mode: str = "default",
-                 opcode: str = "data_variable",
-                 params: Optional[dict] = None,
-                 sprite_name: Optional[str] = None,
-                 value=0,
-                 width: int | float = 0,
-                 height: int | float = 0,
-                 x: int | float = 5,
-                 y: int | float = 5,
-                 visible: bool = False,
-                 slider_min: int | float = 0,
-                 slider_max: int | float = 100,
-                 is_discrete: bool = True, *, reporter_id: Optional[str] = None, _project: Optional[project.Project] = None):
-        """
-        Represents a variable/list monitor
-        https://en.scratch-wiki.info/wiki/Scratch_File_Format#Monitors
-
-        Instantiating these yourself and attaching these to projects can lead to interesting results!
-        """
-        assert isinstance(reporter, base.SpriteSubComponent) or reporter is None
-
-        self.reporter_id = reporter_id
-        """
-        ID referencing the VLB being referenced. Replaced with None during project instantiation, where the reporter attribute is updated
-        """
-
-        self.reporter = reporter
-        if params is None:
-            params = {}
-
-        self.mode = mode
-
-        self.opcode = opcode
-        self.params = params
-
-        self.sprite_name = sprite_name
-
-        self.value = value
-
-        self.width, self.height = width, height
-        self.x, self.y = x, y
-
-        self.visible = visible
-
-        self.slider_min, self.slider_max = slider_min, slider_max
-        self.is_discrete = is_discrete
-
-        super().__init__(_project)
-
-    def __repr__(self):
-        return f"Monitor<{self.opcode}>"
-
-    @property
-    def id(self):
-        if self.reporter is not None:
-            return self.reporter.id
-            # if isinstance(self.reporter, str):
-            #     return self.reporter
-            # else:
-            #     return self.reporter.id
-        else:
-            return self.reporter_id
-
-    @staticmethod
-    def from_json(data: dict):
-        _id = data["id"]
-        # ^^ NEED TO FIND REPORTER OBJECT
-
-        mode = data["mode"]
-
-        opcode = data["opcode"]
-        params: dict = data["params"]
-
-        sprite_name = data["spriteName"]
-
-        value = data["value"]
-
-        width, height = data["width"], data["height"]
-        x, y = data["x"], data["y"]
-
-        visible = data["visible"]
-
-        if "isDiscrete" in data.keys():
-            slider_min, slider_max = data["sliderMin"], data["sliderMax"]
-            is_discrete = data["isDiscrete"]
-        else:
-            slider_min, slider_max, is_discrete = None, None, None
-
-        return Monitor(None, mode, opcode, params, sprite_name, value, width, height, x, y, visible, slider_min,
-                       slider_max, is_discrete, reporter_id=_id)
-
-    def to_json(self):
-        _json = {
-            "id": self.id,
-            "mode": self.mode,
-
-            "opcode": self.opcode,
-            "params": self.params,
-
-            "spriteName": self.sprite_name,
-
-            "value": self.value,
-
-            "width": self.width,
-            "height": self.height,
-
-            "x": self.x,
-            "y": self.y,
-
-            "visible": self.visible
-        }
-        if self.is_discrete is not None:
-            _json["sliderMin"] = self.slider_min
-            _json["sliderMax"] = self.slider_max
-            _json["isDiscrete"] = self.is_discrete
-
-        return _json
-
-    def link_using_project(self):
-        assert self.project is not None
-
-        if self.opcode in ("data_variable", "data_listcontents", "event_broadcast_menu"):
-            new_vlb = self.project.find_vlb(self.reporter_id, "id")
-            if new_vlb is not None:
-                self.reporter = new_vlb
-                self.reporter_id = None
-
-    # todo: consider reimplementing this
-    @deprecated("This method does not work correctly (This may be fixed in the future)")
-    @staticmethod
-    def from_reporter(reporter: "Block", _id: str = None, mode: str = "default",
-                      opcode: str = None, sprite_name: str = None, value=0, width: int | float = 0,
-                      height: int | float = 0,
-                      x: int | float = 5, y: int | float = 5, visible: bool = False, slider_min: int | float = 0,
-                      slider_max: int | float = 100, is_discrete: bool = True, params: dict = None):
-        if "reporter" not in reporter.stack_type:
-            warnings.warn(f"{reporter} is not a reporter block; the monitor will return '0'")
-        elif "(menu)" in reporter.stack_type:
-            warnings.warn(f"{reporter} is a menu block; the monitor will return '0'")
-        # Maybe add note that length of list doesn't work fsr?? idk
-        if _id is None:
-            _id = reporter.opcode
-        if opcode is None:
-            opcode = reporter.opcode  # .replace('_', ' ')
-
-        if params is None:
-            params = {}
-        for field in reporter.fields:
-            if field.value_id is None:
-                params[field.id] = field.value
-            else:
-                params[field.id] = field.value, field.value_id
-
-        return Monitor(
-            _id,
-            mode,
-            opcode,
-
-            params,
-            sprite_name,
-            value,
-
-            width, height,
-            x, y,
-            visible,
-            slider_min, slider_max, is_discrete
-        )

scratchattach/editor/mutation.py

@@ -1,324 +0,0 @@
-from __future__ import annotations
-
-import json
-import warnings
-from dataclasses import dataclass
-from typing import Optional, TYPE_CHECKING, Iterable, Any
-
-from . import base, commons
-from scratchattach.utils import enums
-
-if TYPE_CHECKING:
-    from . import block
-
-
-@dataclass
-class ArgumentType(base.Base):
-    type: str
-    proc_str: str
-
-    def __eq__(self, other):
-        if isinstance(other, enums._EnumWrapper):
-            other = other.value
-
-        assert isinstance(other, ArgumentType)
-
-        return self.type == other.type
-
-    def __repr__(self):
-        return f"<ArgType {self.type!r}>"
-
-    @property
-    def default(self) -> str | None:
-        if self.proc_str == "%b":
-            return "false"
-        elif self.proc_str == "%s":
-            return ''
-        else:
-            return None
-
-
-@dataclass
-class ArgSettings(base.Base):
-    ids: bool
-    names: bool
-    defaults: bool
-
-    def __int__(self):
-        return (int(self.ids) +
-                int(self.names) +
-                int(self.defaults))
-
-    def __eq__(self, other):
-        return (self.ids == other.ids and
-                self.names == other.names and
-                self.defaults == other.defaults)
-
-    def __gt__(self, other):
-        return int(self) > int(other)
-
-    def __lt__(self, other):
-        return int(self) > int(other)
-
-
-@dataclass
-class Argument(base.MutationSubComponent):
-    name: str
-    default: str = ''
-
-    _id: str = None
-    """
-    Argument ID: Will be used to replace other parameters during block instantiation.
-    """
-
-    @property
-    def index(self):
-        return self.mutation.arguments.index(self)
-
-    @property
-    def type(self) -> None | ArgumentType:
-        i = 0
-        goal = self.index
-        for token in parse_proc_code(self.mutation.proc_code):
-            if isinstance(token, ArgumentType):
-                if i == goal:
-                    return token
-                i += 1
-
-    @staticmethod
-    def from_json(data: dict | list | Any):
-        warnings.warn("No from_json method defined for Arguments (yet?)")
-
-    def to_json(self) -> dict | list | Any:
-        warnings.warn("No to_json method defined for Arguments (yet?)")
-
-    def link_using_mutation(self):
-        if self._id is None:
-            self._id = self.block.new_id
-
-
-class ArgTypes(enums._EnumWrapper):
-    BOOLEAN = ArgumentType("boolean", "%b")
-    NUMBER_OR_TEXT = ArgumentType("number or text", "%s")
-
-
-def parse_proc_code(_proc_code: str) -> list[str, ArgumentType] | None:
-    """
-    Parse a proccode (part of a mutation) into argument types and strings
-    """
-
-    if _proc_code is None:
-        return None
-    token = ''
-    tokens = []
-
-    last_char = ''
-    for char in _proc_code:
-        if last_char == '%':
-            if char in "sb":
-                # If we've hit an %s or %b
-                token = token[:-1]
-                # Clip the % sign off the token
-
-                if token != '':
-                    # Make sure not to append an empty token
-                    tokens.append(token)
-
-                # Add the parameter token
-                token = f"%{char}"
-                if token == "%b":
-                    tokens.append(ArgTypes.BOOLEAN.value.dcopy())
-                elif token == "%s":
-                    tokens.append(ArgTypes.NUMBER_OR_TEXT.value.dcopy())
-
-                token = ''
-                continue
-
-        token += char
-        last_char = char
-
-    if token != '':
-        tokens.append(token)
-
-    return tokens
-
-
-class Mutation(base.BlockSubComponent):
-    def __init__(self, _tag_name: str = "mutation", _children: Optional[list] = None, _proc_code: Optional[str] = None,
-                 _is_warp: Optional[bool] = None, _arguments: Optional[list[Argument]] = None, _has_next: Optional[bool] = None,
-                 _argument_settings: Optional[ArgSettings] = None, *,
-                 _block: Optional[block.Block] = None):
-        """
-        Mutation for Control:stop block and procedures
-        https://en.scratch-wiki.info/wiki/Scratch_File_Format#Mutations
-        """
-        # Defaulting for args
-        if _children is None:
-            _children = []
-
-        if _argument_settings is None:
-            if _arguments:
-                _argument_settings = ArgSettings(
-                    _arguments[0]._id is None,
-                    _arguments[0].name is None,
-                    _arguments[0].default is None
-                )
-            else:
-                _argument_settings = ArgSettings(False, False, False)
-
-        self.tag_name = _tag_name
-        self.children = _children
-
-        self.proc_code = _proc_code
-        self.is_warp = _is_warp
-        self.arguments = _arguments
-        self.og_argument_settings = _argument_settings
-
-        self.has_next = _has_next
-
-        super().__init__(_block)
-
-    def __repr__(self):
-        if self.arguments is not None:
-            return f"Mutation<args={self.arguments}>"
-        else:
-            return f"Mutation<hasnext={self.has_next}>"
-
-    @property
-    def argument_ids(self):
-        if self.arguments is not None:
-            return [_arg._id for _arg in self.arguments]
-        else:
-            return None
-
-    @property
-    def argument_names(self):
-        if self.arguments is not None:
-            return [_arg.name for _arg in self.arguments]
-        else:
-            return None
-
-    @property
-    def argument_defaults(self):
-        if self.arguments is not None:
-            return [_arg.default for _arg in self.arguments]
-        else:
-            return None
-
-    @property
-    def argument_settings(self) -> ArgSettings:
-        return ArgSettings(bool(commons.safe_get(self.argument_ids, 0)),
-                           bool(commons.safe_get(self.argument_names, 0)),
-                           bool(commons.safe_get(self.argument_defaults, 0)))
-
-    @property
-    def parsed_proc_code(self) -> list[str, ArgumentType] | None:
-        """
-        Parse the proc code into arguments & strings
-        """
-        return parse_proc_code(self.proc_code)
-
-    @staticmethod
-    def from_json(data: dict) -> Mutation:
-        assert isinstance(data, dict)
-
-        _tag_name = data.get("tagName", "mutation")
-        _children = data.get("children", [])
-
-        # procedures_prototype & procedures_call attrs
-        _proc_code = data.get("proccode")
-        _is_warp = data.get("warp")
-        if isinstance(_is_warp, str):
-            _is_warp = json.loads(_is_warp)
-
-        _argument_ids = data.get("argumentids")
-        # For some reason these are stored as JSON strings
-        if _argument_ids is not None:
-            _argument_ids = json.loads(_argument_ids)
-
-        # procedures_prototype attrs
-        _argument_names = data.get("argumentnames")
-        _argument_defaults = data.get("argumentdefaults")
-        # For some reason these are stored as JSON strings
-        if _argument_names is not None:
-            assert isinstance(_argument_names, str)
-            _argument_names = json.loads(_argument_names)
-        if _argument_defaults is not None:
-            assert isinstance(_argument_defaults, str)
-            _argument_defaults = json.loads(_argument_defaults)
-        _argument_settings = ArgSettings(_argument_ids is not None,
-                                         _argument_names is not None,
-                                         _argument_defaults is not None)
-
-        # control_stop attrs
-        _has_next = data.get("hasnext")
-        if isinstance(_has_next, str):
-            _has_next = json.loads(_has_next)
-
-        def get(_lst: list | tuple | None, _idx: int):
-            if _lst is None:
-                return None
-
-            if len(_lst) <= _idx:
-                return None
-            else:
-                return _lst[_idx]
-
-        if _argument_ids is None:
-            _arguments = None
-        else:
-            _arguments = []
-            for i, _arg_id in enumerate(_argument_ids):
-                _arg_name = get(_argument_names, i)
-                _arg_default = get(_argument_defaults, i)
-
-                _arguments.append(Argument(_arg_name, _arg_default, _arg_id))
-
-        return Mutation(_tag_name, _children, _proc_code, _is_warp, _arguments, _has_next, _argument_settings)
-
-    def to_json(self) -> dict | None:
-        _json = {
-            "tagName": self.tag_name,
-            "children": self.children,
-        }
-        commons.noneless_update(_json, {
-            "proccode": self.proc_code,
-            "warp": commons.dumps_ifnn(self.is_warp),
-            "argumentids": commons.dumps_ifnn(self.argument_ids),
-            "argumentnames": commons.dumps_ifnn(self.argument_names),
-            "argumentdefaults": commons.dumps_ifnn(self.argument_defaults),
-
-            "hasNext": commons.dumps_ifnn(self.has_next)
-        })
-
-        return _json
-
-    def link_arguments(self):
-        if self.arguments is None:
-            return
-
-        # You only need to fetch argument data if you actually have arguments
-        if len(self.arguments) > 0:
-            if self.arguments[0].name is None:
-                # This requires linking
-                _proc_uses = self.sprite.find_block(self.argument_ids, "argument ids", True)
-                # Note: Sometimes there may not be any argument ids provided. There will be no way to find out the names
-                # Technically, defaults can be found by using the proc code
-                for _use in _proc_uses:
-                    if _use.mutation.argument_settings > self.argument_settings:
-                        self.arguments = _use.mutation.arguments
-                        if int(self.argument_settings) == 3:
-                            # If all of our argument data is filled, we can stop early
-                            return
-
-                # We can still work out argument defaults from parsing the proc code
-                if self.arguments[0].default is None:
-                    _parsed = self.parsed_proc_code
-                    _arg_phs: Iterable[ArgumentType] = filter(lambda tkn: isinstance(tkn, ArgumentType),
-                                                              _parsed)
-                    for i, _arg_ph in enumerate(_arg_phs):
-                        self.arguments[i].default = _arg_ph.default
-
-            for _argument in self.arguments:
-                _argument.mutation = self
-                _argument.link_using_mutation()

scratchattach/editor/pallete.py

@@ -1,90 +0,0 @@
-"""
-Collection of block information, stating input/field names and opcodes
-New version of sbuild.py
-
-May want to completely change this later
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Optional
-
-from . import prim
-from scratchattach.utils.enums import _EnumWrapper
-
-
-@dataclass
-class FieldUsage:
-    name: str
-    value_type: Optional[prim.PrimTypes] = None
-
-
-@dataclass
-class SpecialFieldUsage(FieldUsage):
-    name: str
-    value_type: None = None # Order cannot be changed
-    attrs: list[str] = field(default_factory=list)
-
-
-
-@dataclass
-class InputUsage:
-    name: str
-    value_type: Optional[prim.PrimTypes] = None
-    default_obscurer: Optional[BlockUsage] = None
-
-
-@dataclass
-class BlockUsage:
-    opcode: str
-    fields: Optional[list[FieldUsage]] = None
-    if fields is None:
-        fields = []
-
-    inputs: Optional[list[InputUsage]] = None
-    if inputs is None:
-        inputs = []
-
-
-class BlockUsages(_EnumWrapper):
-    # Special Enum blocks
-    MATH_NUMBER = BlockUsage(
-        "math_number",
-        [SpecialFieldUsage("NUM", attrs=["name", "value"])]
-    )
-    MATH_POSITIVE_NUMBER = BlockUsage(
-        "math_positive_number",
-        [SpecialFieldUsage("NUM", attrs=["name", "value"])]
-    )
-    MATH_WHOLE_NUMBER = BlockUsage(
-        "math_whole_number",
-        [SpecialFieldUsage("NUM", attrs=["name", "value"])]
-    )
-    MATH_INTEGER = BlockUsage(
-        "math_integer",
-        [SpecialFieldUsage("NUM", attrs=["name", "value"])]
-    )
-    MATH_ANGLE = BlockUsage(
-        "math_angle",
-        [SpecialFieldUsage("NUM", attrs=["name", "value"])]
-    )
-    COLOUR_PICKER = BlockUsage(
-        "colour_picker",
-        [SpecialFieldUsage("COLOUR", attrs=["name", "value"])]
-    )
-    TEXT = BlockUsage(
-        "text",
-        [SpecialFieldUsage("TEXT", attrs=["name", "value"])]
-    )
-    EVENT_BROADCAST_MENU = BlockUsage(
-        "event_broadcast_menu",
-        [SpecialFieldUsage("BROADCAST_OPTION", attrs=["name", "id", "value", "variableType"])]
-    )
-    DATA_VARIABLE = BlockUsage(
-        "data_variable",
-        [SpecialFieldUsage("VARIABLE", attrs=["name", "id", "value", "variableType"])]
-    )
-    DATA_LISTCONTENTS = BlockUsage(
-        "data_listcontents",
-        [SpecialFieldUsage("LIST", attrs=["name", "id", "value", "variableType"])]
-    )