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

scratchattach/editor/prim.py

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

scratchattach/editor/project.py

@@ -1,279 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-import warnings
-from io import BytesIO, TextIOWrapper
-from typing import Optional, Iterable, Generator, BinaryIO
-from zipfile import ZipFile
-
-from . import base, meta, extension, monitor, sprite, asset, vlb, twconfig, comment, commons
-from scratchattach.site import session
-from scratchattach.site.project import get_project
-from scratchattach.utils import exceptions
-
-
-class Project(base.JSONExtractable):
-    """
-    sa.editor's equivalent of the ProjectBody. 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 = _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) -> sprite.Sprite:
-        for _sprite in self.sprites:
-            if _sprite.is_stage:
-                return _sprite
-        warnings.warn(f"Could not find stage for {self.name}")
-
-    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
-    def from_id(project_id: int, _name: Optional[str] = None):
-        _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) -> vlb.Variable | vlb.List | vlb.Broadcast | list[
-        vlb.Variable | vlb.List | vlb.Broadcast]:
-        _ret = []
-        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
-
-    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)