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

other/project_json_capabilities.py

@@ -0,0 +1,475 @@
+"""Project JSON reading and editing capabilities.
+This code is still in BETA, there are still bugs and potential consistency issues to be fixed. New features will be added."""
+
+# Note: You may want to make this into multiple files for better organisation
+from __future__ import annotations
+
+import hashlib
+import json
+import random
+import string
+import zipfile
+from abc import ABC, abstractmethod
+from scratchattach.utils import exceptions
+from scratchattach.utils.commons import empty_project_json
+from scratchattach.utils.requests import requests
+# noinspection PyPep8Naming
+def load_components(json_data: list, ComponentClass: type, target_list: list):
+    for element in json_data:
+        component = ComponentClass()
+        component.from_json(element)
+        target_list.append(component)
+class ProjectBody:
+    class BaseProjectBodyComponent(ABC):
+        def __init__(self, **entries):
+            # Attributes every object needs to have:
+            self.id = None
+            # Update attributes from entries dict:
+            self.__dict__.update(entries)
+        @abstractmethod
+        def from_json(self, data: dict):
+            pass
+        @abstractmethod
+        def to_json(self):
+            pass
+        def _generate_new_id(self):
+            """
+            Generates a new id and updates the id.
+            Warning:
+                When done on Block objects, the next_id attribute of the parent block and the parent_id attribute of the next block will NOT be updated by this method.
+            """
+            self.id = ''.join(random.choices(string.ascii_letters + string.digits, k=20))
+    class Block(BaseProjectBodyComponent):
+        # Thanks to @MonkeyBean2 for some scripts
+        def from_json(self, data: dict):
+            self.opcode = data["opcode"]  # The name of the block
+            self.next_id = data.get("next", None)  # The id of the block attached below this block
+            self.parent_id = data.get("parent", None)  # The id of the block that this block is attached to
+            self.input_data = data.get("inputs", None)  # The blocks inside of the block (if the block is a loop or an if clause for example)
+            self.fields = data.get("fields", None)  # The values inside the block's inputs
+            self.shadow = data.get("shadow", False)  # Whether the block is displayed with a shadow
+            self.topLevel = data.get("topLevel", False)  # Whether the block has no parent
+            self.mutation = data.get("mutation", None)  # For custom blocks
+            self.x = data.get("x", None)  # x position if topLevel
+            self.y = data.get("y", None)  # y position if topLevel
+        def to_json(self):
+            output = {"opcode": self.opcode, "next": self.next_id, "parent": self.parent_id, "inputs": self.input_data,
+                      "fields": self.fields, "shadow": self.shadow, "topLevel": self.topLevel,
+                      "mutation": self.mutation, "x": self.x, "y": self.y}
+            return {k: v for k, v in output.items() if v}
+        def attached_block(self):
+            return self.sprite.block_by_id(self.next_id)
+        def previous_block(self):
+            return self.sprite.block_by_id(self.parent_id)
+        def top_level_block(self):
+            block = self
+            return block
+        def previous_chain(self):
+            # to implement: a method that detects circular block chains (to make sure this method terminates)
+            chain = []
+            block = self
+            while block.parent_id is not None:
+                block = block.previous_block()
+                chain.insert(0, block)
+            return chain
+        def attached_chain(self):
+            chain = []
+            block = self
+            while block.next_id is not None:
+                block = block.attached_block()
+                chain.append(block)
+            return chain
+        def complete_chain(self):
+            return self.previous_chain() + [self] + self.attached_chain()
+        def duplicate_single_block(self):
+            new_block = ProjectBody.Block(**self.__dict__)
+            new_block.parent_id = None
+            new_block.next_id = None
+            new_block._generate_new_id()
+            self.sprite.blocks.append(new_block)
+            return new_block
+        def duplicate_chain(self):
+            blocks_to_dupe = [self] + self.attached_chain()
+            duped = []
+            for i in range(len(blocks_to_dupe)):
+                new_block = ProjectBody.Block(**blocks_to_dupe[i].__dict__)
+                new_block.parent_id = None
+                new_block.next_id = None
+                new_block._generate_new_id()
+                if i != 0:
+                    new_block.parent_id = duped[i - 1].id
+                    duped[i - 1].next_id = new_block.id
+                duped.append(new_block)
+            self.sprite.blocks += duped
+            return duped
+        def _reattach(self, new_parent_id, new_next_id_of_old_parent):
+            if self.parent_id is not None:
+                old_parent_block = self.sprite.block_by_id(self.parent_id)
+                self.sprite.blocks.remove(old_parent_block)
+                old_parent_block.next_id = new_next_id_of_old_parent
+                self.sprite.blocks.append(old_parent_block)
+            self.parent_id = new_parent_id
+            if self.parent_id is not None:
+                new_parent_block = self.sprite.block_by_id(self.parent_id)
+                self.sprite.blocks.remove(new_parent_block)
+                new_parent_block.next_id = self.id
+                self.sprite.blocks.append(new_parent_block)
+            self.topLevel = new_parent_id is None
+        def reattach_single_block(self, new_parent_id):
+            old_parent_id = str(self.parent_id)
+            self._reattach(new_parent_id, self.next_id)
+            if self.next_id is not None:
+                old_next_block = self.sprite.block_by_id(self.next_id)
+                self.sprite.blocks.remove(old_next_block)
+                old_next_block.parent_id = old_parent_id
+                self.sprite.blocks.append(old_next_block)
+            self.next_id = None
+        def reattach_chain(self, new_parent_id):
+            self._reattach(new_parent_id, None)
+        def delete_single_block(self):
+            self.sprite.blocks.remove(self)
+            self.reattach_single_block(None, self.next_id)
+        def delete_chain(self):
+            self.sprite.blocks.remove(self)
+            self.reattach_chain(None)
+            to_delete = self.attached_chain()
+            for block in to_delete:
+                self.sprite.blocks.remove(block)
+        def inputs_as_blocks(self):
+            if self.input_data is None:
+                return None
+            inputs = []
+            for input in self.input_data:
+                inputs.append(self.sprite.block_by_id(self.input_data[input][1]))
+    class Sprite(BaseProjectBodyComponent):
+        def from_json(self, data: dict):
+            self.isStage = data["isStage"]
+            self.name = data["name"]
+            self.id = self.name  # Sprites are uniquely identifiable through their name
+            self.variables = []
+            for variable_id in data["variables"]:  # self.lists is a dict with the list_id as key and info as value
+                pvar = ProjectBody.Variable(id=variable_id)
+                pvar.from_json(data["variables"][variable_id])
+                self.variables.append(pvar)
+            self.lists = []
+            for list_id in data["lists"]:  # self.lists is a dict with the list_id as key and info as value
+                plist = ProjectBody.List(id=list_id)
+                plist.from_json(data["lists"][list_id])
+                self.lists.append(plist)
+            self.broadcasts = data["broadcasts"]
+            self.blocks = []
+            for block_id in data["blocks"]:  # self.blocks is a dict with the block_id as key and block content as value
+                if isinstance(data["blocks"][block_id],
+                              dict):  # Sometimes there is a weird list at the end of the blocks list. This list is ignored
+                    block = ProjectBody.Block(id=block_id, sprite=self)
+                    block.from_json(data["blocks"][block_id])
+                    self.blocks.append(block)
+            self.comments = data["comments"]
+            self.currentCostume = data["currentCostume"]
+            self.costumes = []
+            load_components(data["costumes"], ProjectBody.Asset, self.costumes)  # load lists
+            self.sounds = []
+            load_components(data["sounds"], ProjectBody.Asset, self.sounds)  # load lists
+            self.volume = data["volume"]
+            self.layerOrder = data["layerOrder"]
+            if self.isStage:
+                self.tempo = data.get("tempo", None)
+                self.videoTransparency = data.get("videoTransparency", None)
+                self.videoState = data.get("videoState", None)
+                self.textToSpeechLanguage = data.get("textToSpeechLanguage", None)
+            else:
+                self.visible = data.get("visible", None)
+                self.x = data.get("x", None)
+                self.y = data.get("y", None)
+                self.size = data.get("size", None)
+                self.direction = data.get("direction", None)
+                self.draggable = data.get("draggable", None)
+                self.rotationStyle = data.get("rotationStyle", None)
+        def to_json(self):
+            return_data = dict(self.__dict__)
+            if "projectBody" in return_data:
+                return_data.pop("projectBody")
+            return_data.pop("id")
+            return_data["variables"] = {}
+            for variable in self.variables:
+                return_data["variables"][variable.id] = variable.to_json()
+            return_data["lists"] = {}
+            for plist in self.lists:
+                return_data["lists"][plist.id] = plist.to_json()
+            return_data["blocks"] = {}
+            for block in self.blocks:
+                return_data["blocks"][block.id] = block.to_json()
+            return_data["costumes"] = [custome.to_json() for custome in self.costumes]
+            return_data["sounds"] = [sound.to_json() for sound in self.sounds]
+            return return_data
+        def variable_by_id(self, variable_id):
+            matching = list(filter(lambda x: x.id == variable_id, self.variables))
+            if matching == []:
+                return None
+            return matching[0]
+        def list_by_id(self, list_id):
+            matching = list(filter(lambda x: x.id == list_id, self.lists))
+            if matching == []:
+                return None
+            return matching[0]
+        def variable_by_name(self, variable_name):
+            matching = list(filter(lambda x: x.name == variable_name, self.variables))
+            if matching == []:
+                return None
+            return matching[0]
+        def list_by_name(self, list_name):
+            matching = list(filter(lambda x: x.name == list_name, self.lists))
+            if matching == []:
+                return None
+            return matching[0]
+        def block_by_id(self, block_id):
+            matching = list(filter(lambda x: x.id == block_id, self.blocks))
+            if matching == []:
+                return None
+            return matching[0]
+        # -- Functions to modify project contents --
+        def create_sound(self, asset_content, *, name="new sound", dataFormat="mp3", rate=4800, sampleCount=4800):
+            data = asset_content if isinstance(asset_content, bytes) else open(asset_content, "rb").read()
+            new_asset_id = hashlib.md5(data).hexdigest()
+            new_asset = ProjectBody.Asset(assetId=new_asset_id, name=name, id=new_asset_id, dataFormat=dataFormat,
+                                          rate=rate, sampleCound=sampleCount, md5ext=new_asset_id + "." + dataFormat,
+                                          filename=new_asset_id + "." + dataFormat)
+            self.sounds.append(new_asset)
+            if not hasattr(self, "projectBody"):
+                print(
+                    "Warning: Since there's no project body connected to this object, the new sound asset won't be uploaded to Scratch")
+            elif self.projectBody._session is None:
+                print(
+                    "Warning: Since there's no login connected to this object, the new sound asset won't be uploaded to Scratch")
+            else:
+                self._session.upload_asset(data, asset_id=new_asset_id, file_ext=dataFormat)
+            return new_asset
+        def create_costume(self, asset_content, *, name="new costume", dataFormat="svg", rotationCenterX=0,
+                           rotationCenterY=0):
+            data = asset_content if isinstance(asset_content, bytes) else open(asset_content, "rb").read()
+            new_asset_id = hashlib.md5(data).hexdigest()
+            new_asset = ProjectBody.Asset(assetId=new_asset_id, name=name, id=new_asset_id, dataFormat=dataFormat,
+                                          rotationCenterX=rotationCenterX, rotationCenterY=rotationCenterY,
+                                          md5ext=new_asset_id + "." + dataFormat,
+                                          filename=new_asset_id + "." + dataFormat)
+            self.costumes.append(new_asset)
+            if not hasattr(self, "projectBody"):
+                print(
+                    "Warning: Since there's no project body connected to this object, the new costume asset won't be uploaded to Scratch")
+            elif self.projectBody._session is None:
+                print(
+                    "Warning: Since there's no login connected to this object, the new costume asset won't be uploaded to Scratch")
+            else:
+                self._session.upload_asset(data, asset_id=new_asset_id, file_ext=dataFormat)
+            return new_asset
+        def create_variable(self, name, *, value=0, is_cloud=False):
+            new_var = ProjectBody.Variable(name=name, value=value, is_cloud=is_cloud)
+            self.variables.append(new_var)
+            return new_var
+        def create_list(self, name, *, value=[]):
+            new_list = ProjectBody.List(name=name, value=value)
+            self.lists.append(new_list)
+            return new_list
+        def add_block(self, block, *, parent_id=None):
+            block.parent_id = None
+            block.next_id = None
+            if parent_id is not None:
+                block.reattach_single_block(parent_id)
+            self.blocks.append(block)
+        def add_block_chain(self, block_chain, *, parent_id=None):
+            parent = parent_id
+            for block in block_chain:
+                self.add_block(block, parent_id=parent)
+                parent = str(block.id)
+    class Variable(BaseProjectBodyComponent):
+        def __init__(self, **entries):
+            super().__init__(**entries)
+            if self.id is None:
+                self._generate_new_id()
+        def from_json(self, data: list):
+            self.name = data[0]
+            self.saved_value = data[1]
+            self.is_cloud = len(data) == 3
+        def to_json(self):
+            if self.is_cloud:
+                return [self.name, self.saved_value, True]
+            else:
+                return [self.name, self.saved_value]
+        def make_cloud_variable(self):
+            self.is_cloud = True
+    class List(BaseProjectBodyComponent):
+        def __init__(self, **entries):
+            super().__init__(**entries)
+            if self.id is None:
+                self._generate_new_id()
+        def from_json(self, data: list):
+            self.name = data[0]
+            self.saved_content = data[1]
+        def to_json(self):
+            return [self.name, self.saved_content]
+    class Monitor(BaseProjectBodyComponent):
+        def from_json(self, data: dict):
+            self.__dict__.update(data)
+        def to_json(self):
+            return_data = dict(self.__dict__)
+            if "projectBody" in return_data:
+                return_data.pop("projectBody")
+            return return_data
+        def target(self):
+            if not hasattr(self, "projectBody"):
+                print("Can't get represented object because the origin projectBody of this monitor is not saved")
+                return
+            if "VARIABLE" in self.params:
+                return self.projectBody.sprite_by_name(self.spriteName).variable_by_name(self.params["VARIABLE"])
+            if "LIST" in self.params:
+                return self.projectBody.sprite_by_name(self.spriteName).list_by_name(self.params["LIST"])
+    class Asset(BaseProjectBodyComponent):
+        def from_json(self, data: dict):
+            self.__dict__.update(data)
+            self.id = self.assetId
+            self.filename = self.md5ext
+            self.download_url = f"https://assets.scratch.mit.edu/internalapi/asset/{self.filename}"
+        def to_json(self):
+            return_data = dict(self.__dict__)
+            return_data.pop("filename")
+            return_data.pop("id")
+            return_data.pop("download_url")
+            return return_data
+        def download(self, *, filename=None, dir=""):
+            if not (dir.endswith("/") or dir.endswith("\\")):
+                dir = dir + "/"
+            try:
+                if filename is None:
+                    filename = str(self.filename)
+                response = requests.get(
+                    self.download_url,
+                    timeout=10,
+                )
+                open(f"{dir}{filename}", "wb").write(response.content)
+            except Exception:
+                raise (
+                    exceptions.FetchError(
+                        "Failed to download asset"
+                    )
+                )
+    def __init__(self, *, sprites=[], monitors=[], extensions=[], meta=[{"agent": None}], _session=None):
+        # sprites are called "targets" in the initial API response
+        self.sprites = sprites
+        self.monitors = monitors
+        self.extensions = extensions
+        self.meta = meta
+        self._session = _session
+    def from_json(self, data: dict):
+        """
+        Imports the project data from a dict that contains the raw project json
+        """
+        # Load sprites:
+        self.sprites = []
+        load_components(data["targets"], ProjectBody.Sprite, self.sprites)
+        # Save origin of sprite in Sprite object:
+        for sprite in self.sprites:
+            sprite.projectBody = self
+            # Load monitors:
+        self.monitors = []
+        load_components(data["monitors"], ProjectBody.Monitor, self.monitors)
+        # Save origin of monitor in Monitor object:
+        for monitor in self.monitors:
+            monitor.projectBody = self
+        # Set extensions and meta attributs:
+        self.extensions = data["extensions"]
+        self.meta = data["meta"]
+    def to_json(self):
+        """
+        Returns a valid project JSON dict with the contents of this project
+        """
+        return_data = {}
+        return_data["targets"] = [sprite.to_json() for sprite in self.sprites]
+        return_data["monitors"] = [monitor.to_json() for monitor in self.monitors]
+        return_data["extensions"] = self.extensions
+        return_data["meta"] = self.meta
+        return return_data
+    # -- Functions to get info --
+    def blocks(self):
+        return [block for sprite in self.sprites for block in sprite.blocks]
+    def block_count(self):
+        return len(self.blocks())
+    def assets(self):
+        return [sound for sprite in self.sprites for sound in sprite.sounds] + [costume for sprite in self.sprites for
+                                                                                costume in sprite.costumes]
+    def asset_count(self):
+        return len(self.assets())
+    def variable_by_id(self, variable_id):
+        for sprite in self.sprites:
+            r = sprite.variable_by_id(variable_id)
+            if r is not None:
+                return r
+    def list_by_id(self, list_id):
+        for sprite in self.sprites:
+            r = sprite.list_by_id(list_id)
+            if r is not None:
+                return r
+    def sprite_by_name(self, sprite_name):
+        matching = list(filter(lambda x: x.name == sprite_name, self.sprites))
+        if matching == []:
+            return None
+        return matching[0]
+    def user_agent(self):
+        return self.meta["agent"]
+    def save(self, *, filename=None, dir=""):
+        """
+        Saves the project body to the given directory.
+        Args:
+            filename (str): The name that will be given to the downloaded file.
+            dir (str): The path of the directory the file will be saved in.
+        """
+        if not (dir.endswith("/") or dir.endswith("\\")):
+            dir = dir + "/"
+        if filename is None:
+            filename = "project"
+        filename = filename.replace(".sb3", "")
+        with open(f"{dir}{filename}.sb3", "w") as d:
+            json.dump(self.to_json(), d, indent=4)
+def get_empty_project_pb():
+    pb = ProjectBody()
+    pb.from_json(empty_project_json)
+    return pb
+def get_pb_from_dict(project_json: dict):
+    pb = ProjectBody()
+    pb.from_json(project_json)
+    return pb
+def _load_sb3_file(path_to_file):
+    try:
+        with open(path_to_file, "r") as r:
+            return json.loads(r.read())
+    except Exception as e:
+        with zipfile.ZipFile(path_to_file, 'r') as zip_ref:
+            # Check if the file exists in the zip
+            if "project.json" in zip_ref.namelist():
+                # Read the file as bytes
+                with zip_ref.open("project.json") as file:
+                    return json.loads(file.read())
+            else:
+                raise ValueError("specified sb3 archive doesn't contain project.json")
+def read_sb3_file(path_to_file):
+    pb = ProjectBody()
+    pb.from_json(_load_sb3_file(path_to_file))
+    return pb
+def download_asset(asset_id_with_file_ext, *, filename=None, dir=""):
+    if not (dir.endswith("/") or dir.endswith("\\")):
+        dir = dir + "/"
+    try:
+        if filename is None:
+            filename = str(asset_id_with_file_ext)
+        response = requests.get(
+            "https://assets.scratch.mit.edu/" + str(asset_id_with_file_ext),
+            timeout=10,
+        )
+        open(f"{dir}{filename}", "wb").write(response.content)
+    except Exception:
+        raise (
+            exceptions.FetchError(
+                "Failed to download asset"
+            )
+        )
+
+# The method for uploading an asset by id requires authentication and can be found in the site.session.Session class

{scratchattach-3.0.0b0.dist-info → scratchattach-3.0.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scratchattach
-Version: 3.0.0b0
+Version: 3.0.0b1
 Summary: A Scratch API Wrapper
 Author: TimMcCool
 License-Expression: MIT

scratchattach-3.0.0b1.dist-info/RECORD

@@ -0,0 +1,79 @@
+cli/__about__.py,sha256=rWWgBXhOQakEGEip4jZgZsmGHkIU08m01PRgPUfmHdg,17
+cli/__init__.py,sha256=WAJmqnZi5RoJGlx3fngQAi9APNf84QlicncbsPRwhkg,700
+cli/context.py,sha256=7m9i-J2j36MN8uPJm8ydjMFKWZjJQAyu5NBluL8eQUE,4950
+cli/db.py,sha256=sV-AwyYc8WeHalpadAV1vD0HXkEmZrcvhLGJA0q0TD0,1920
+cli/namespace.py,sha256=qWH1QI9ot-5Y1ahpY9JHw8HTGnlFwHRKLoKxvxFqk5A,445
+cli/cmd/__init__.py,sha256=KiNP3GVwCf-NE_yzYgDvza3hR3Sr1B0-wqu5Xaxi_g4,110
+cli/cmd/group.py,sha256=j8jqy2N4KEChe6cUus5MczoqGKDzjOIgG2mBmxVmb-A,4144
+cli/cmd/login.py,sha256=BnPUCUDG58gNly76OZdBT22oxaZY50b_VHnQWx2p40I,1914
+cli/cmd/profile.py,sha256=jT-JoJhFCtzbyskdQpi8_ckVzrVqDghlh-zEEEchFDI,172
+cli/cmd/sessions.py,sha256=JzBx6BTjddqU-UGZz4CtYpBKb9CC7lbpXLk19Pz7Zoo,116
+cloud/__init__.py,sha256=MN7s4grQcciqUO7TiFjTbU2sC69m6XXlwOHNRbN3FKo,41
+cloud/_base.py,sha256=tXVWPsL9Ybvu2H0zQ5R9GexgeHAarEv4GS16foD3_qw,19251
+cloud/cloud.py,sha256=zq0Z-N2EF2uUxpJ0uZlITY2DeKkjb3TxwK_etci-xCM,8470
+editor/__init__.py,sha256=pdq-dg7fa4cj6eksu5yzUe27DGY6CLKVUtCSrbYCsM8,807
+editor/asset.py,sha256=Ut_Em2rzlzswi2aDTvyRZWvF5JKLY8IAmoLMOQLBpjQ,8148
+editor/backpack_json.py,sha256=zhNRKDmlA9Oz-IixjLRnSwVG6JfKURs31KhQPjJu_bs,3880
+editor/base.py,sha256=MUQ4zqw-IaFZDH9o_F9k7F3mptymR67E8ITkaMfnD5M,5311
+editor/block.py,sha256=2UKKQbrDdsI6dbswo2swvIr7jXiXA114TCtXDO9DSFw,19085
+editor/blockshape.py,sha256=Q8CAWsBc2O5VqcGhUxbJoW1RRfy7kBxz1AporkExBi8,25318
+editor/build_defaulting.py,sha256=rRDSXpIugWENYs6X50A_a3BJfWJuzEtwW1bv9IAyo-M,1421
+editor/comment.py,sha256=G_eFxeaC_vKbCFpDfw4oZxIReUBoBUaCA5q35O-AW6Y,2403
+editor/commons.py,sha256=0mm30KjAenl_V2BXbkdirFN62SraYfGUariXB-TXNlU,3583
+editor/extension.py,sha256=PFVl5SrS66M4Md98I_dsfeL9BLeWwvyWezmhnTRseIQ,1541
+editor/field.py,sha256=_AmBwrb5TeG_CRm312I69T2xXlzuKYeudpygPyA4698,2994
+editor/inputs.py,sha256=bmCLsxgGimkESbKEnhsnw_ZSRpBDsWRIcEoYPFMx9Zs,4505
+editor/meta.py,sha256=QCHk5DKvYAw7F5Gg4OIJNcB7PhK8u5YgfDmGQPWobTs,3330
+editor/monitor.py,sha256=A30XadTjw_G0KsTnwo3YEI31nkplc1DnO8AirjmB3zc,5921
+editor/mutation.py,sha256=o2msH-s6UxFZ-LuYF1BlR4CBm-ulKTVpStux54cxnDk,12246
+editor/pallete.py,sha256=OY76grzJLUWsAKi2x-mipEXv5f-9I-s9UjoLZ3FmtBM,2299
+editor/prim.py,sha256=v74mkdLwsXAKPy_KPesugv-xCxA6YcGU6_v7Zvc2YEY,5919
+editor/project.py,sha256=tWf9kULlJjMCV1t5AofIDFqGylBYQ31vpjDMJ3jM3_Q,12884
+editor/sprite.py,sha256=M_rrkErJswH9stKvrywrkaoNEwgRBbF7-Si17W-0vTs,21205
+editor/twconfig.py,sha256=iE6ylAsZzniAfhL09GkZSFn1XacYtCQPzRCUSPIBzDA,3324
+editor/vlb.py,sha256=Fl2gGwZyYh54uOhQ7XITfCgCpJTQB2P8wy47PKY3Qyk,4151
+editor/code_translation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+editor/code_translation/parse.py,sha256=FjuHVg_tNzkGcGSNwgH6MzAHcf5YCvaEUSYukyJkwbk,4932
+eventhandlers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eventhandlers/_base.py,sha256=97vFbuhSoJeYb-jrEWDdbZWQ7e_54CY3ktrq8d_-w8g,3142
+eventhandlers/cloud_events.py,sha256=LDENLVopVwKDVrcfkR1spKzT45ET-EKqBdtCzXoaS5g,5228
+eventhandlers/cloud_recorder.py,sha256=dvob4-aKLxE9WFqvCNv28M_r3r3OEkET6rwmu5yl4jk,795
+eventhandlers/cloud_requests.py,sha256=CQsA6wzW6C0xJYtw6g0X8x5DY5EHkDE1tAOMVigzhzA,25113
+eventhandlers/cloud_server.py,sha256=j2Iiuxsp9xOLeZ6S7iT7Yto8u599O57kRUZLMMIxjQ0,12431
+eventhandlers/cloud_storage.py,sha256=YYcvRjhIuOboWVemMKFEtUhrd6UeUFO_BlbAIH7oaeQ,4609
+eventhandlers/combine.py,sha256=YiWI6WI1BySioXpfYaMv8noBM14EjZa7dtsJsMTshEU,894
+eventhandlers/filterbot.py,sha256=V5dQErz_yFpSioh5VxUDaBW8L9ny1uMviTt7x-KFC1k,7612
+eventhandlers/message_events.py,sha256=KvznXAeNGk1WWCxd7PI95yovX-58TyCBNDdXbrYgb8Q,1776
+other/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+other/other_apis.py,sha256=yZ06rCZmJLSZZdfv1V_VgRBq5dUxS31YHkpsdOxAezw,17509
+other/project_json_capabilities.py,sha256=07t1iMgWm4Qd06jHyQ3vK7tROguvc2RQCo78enrdSlA,22646
+scratchattach-3.0.0b1.dist-info/licenses/LICENSE,sha256=1PRKLhZU4wYt5M-C9f7q0W3go3u_ojnZMNOdR3g3J-E,1080
+site/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+site/_base.py,sha256=D2SOp2aFiDP0hG7-xP8kK1pmoAz5TOi7_iWt6Ulpsbg,3283
+site/activity.py,sha256=g5fg97xHUAKOkaZ4VzKl3hVpICZhv1mpDCO6LlmkoTU,17871
+site/alert.py,sha256=V6asmcWy4tcQgWhG95rpqXP0KeUy7VQU9wD9AMhCqds,9324
+site/backpack_asset.py,sha256=__VZomGDJkbgWj2ridQQArMMLWoSMv8dpO7PPpvPgBU,3322
+site/browser_cookie3_stub.py,sha256=codk0knOP5C0YThaRazvqsqX7X7WnrD2UwFd1nFG7mg,1422
+site/browser_cookies.py,sha256=uQyjJJ4HCu46R4tPWCcTUqDMXSXhQ4KQUobqCSxScSA,1864
+site/classroom.py,sha256=lpHh2OkHeFzGUaFbf9PWIrosYOBo2cRrfc6fsex2w44,18139
+site/cloud_activity.py,sha256=vMQy2k3jzPbOa3_TiH23B9dTk4BQA_z0q_Ab6TFkeV8,5397
+site/comment.py,sha256=kUZxbjChs8K66vShz-Q1y1s72yJ44hFXJUYLsSb9rUs,9449
+site/forum.py,sha256=-XLi3UJOwDt0Ye8CqP4c-sSxOkPSe5fPVa9b7MOm64k,16553
+site/placeholder.py,sha256=BTOroGKA3lpgKPJXFeveEuMdcNkOIddpbNTrV-48s-o,5446
+site/project.py,sha256=Zc5TN4PEGC1fTze_rkU7_-Y1YDuSXrkHaJGD3eeLgqU,34750
+site/session.py,sha256=kd4IKaMXmtWGJJnFV3wOoLAF2S_012zHkdGcMZgUFxs,54451
+site/studio.py,sha256=sAqFJDjhxf-9NynLB7mrCgzxq8td1oqa1zTW9MP1yTM,26195
+site/typed_dicts.py,sha256=Hq65u56OSLdcoQ0F0A_CxZ8WBY5d_0VuJmUEMd8KmpU,3611
+site/user.py,sha256=P2nsSGo-Z1QlXzAQxstOOq-E4QGN9HVA4dIQaJd1YFY,47404
+utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+utils/commons.py,sha256=DpBTxRC2XeKURW5YJwAT6teAfYG7221GxClTaZ0-yQE,8465
+utils/encoder.py,sha256=1lOXBbqo2JGMdns6Q5WGhAB9p7Q8trduBk-SZgmcEKw,2559
+utils/enums.py,sha256=5HhXidczUYYVwHf6jfJcMA80jK4V0imaltLEu5epIF8,11127
+utils/exceptions.py,sha256=T1nBbbkTZVkZU7uNaqBqSbNTGtOaOnTVLRRqUTatTis,7556
+utils/optional_async.py,sha256=zTCFt6tpSvlcwns1RgAACKplA1SSFyVWAcDRS8kLLjE,4721
+utils/requests.py,sha256=Brl94PCyblaQopanXyyQZ8ZoaWuFrK3NqUTZWW22gpY,9608
+scratchattach-3.0.0b1.dist-info/METADATA,sha256=JnNVUZxbXAuGUH0mn9nE4Cuu17ko-wNNy1OLdPMPSWU,5633
+scratchattach-3.0.0b1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+scratchattach-3.0.0b1.dist-info/entry_points.txt,sha256=vNXuP05TQKEoIzmzmUzS7zbtSZx0p3JmeUW3QhNdYfg,56
+scratchattach-3.0.0b1.dist-info/top_level.txt,sha256=PFfH9Sb4fMOY99H0Xiuuc8nEGjAT_-anhTaORDZBd7A,48
+scratchattach-3.0.0b1.dist-info/RECORD,,

scratchattach-3.0.0b1.dist-info/top_level.txt

@@ -0,0 +1,7 @@
+cli
+cloud
+editor
+eventhandlers
+other
+site
+utils

site/_base.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import TypeVar, Optional, Self, Union, Any, Generic
+import json
+
+import requests
+
+from scratchattach.utils import exceptions, commons, optional_async
+from scratchattach.utils import requests as m_requests
+from . import session
+
+D = TypeVar("D")
+C = TypeVar("C", bound="BaseSiteComponent")
+class BaseSiteComponent(ABC, Generic[D]):
+    _session: Optional[session.Session]
+    update_api: str
+    _headers: dict[str, str]
+    _cookies: dict[str, str]
+    oa_http_session: Optional[m_requests.OAHTTPSession] = None
+
+    # @abstractmethod
+    # def __init__(self):  # dataclasses do not implement __init__ directly
+    #     pass
+
+    def update(self):
+        """
+        Updates the attributes of the object by performing an API response. Returns True if the update was successful.
+        """
+        response = self.update_function(
+            self.update_api,
+            headers=self._headers,
+            cookies=self._cookies, timeout=10
+        )
+        # Check for 429 error:
+        # Note, this is a bit naïve
+        if "429" in str(response):
+            return "429"
+
+        if json.loads(response.text) == {"response": "Too many requests"}:
+            return "429"
+
+        # If no error: Parse JSON:
+        response = response.json()
+        if "code" in response:
+            return False
+
+        return self._update_from_dict(response)
+    
+    def updated(self) -> Self:
+        self.update()
+        return self
+
+    @abstractmethod
+    def _update_from_dict(self, data: D) -> bool:
+        """
+        Parses the API response that is fetched in the update-method. Class specific, must be overridden in classes inheriting from this one.
+        """
+
+    def _assert_auth(self):
+        if self._session is None:
+            raise exceptions.Unauthenticated(
+                "You need to use session.connect_xyz (NOT get_xyz) in order to perform this operation.")
+
+    def _make_linked_object(self, identificator_id, identificator, Class: type[C], NotFoundException) -> C:
+        """
+        Internal function for making a linked object (authentication kept) based on an identificator (like a project id or username)
+        Class must inherit from BaseSiteComponent
+        """
+        return commons._get_object(identificator_id, identificator, Class, NotFoundException, self._session)
+    
+    def supply_data_dict(self, data: D) -> bool:
+        return self._update_from_dict(data)
+
+    update_function = requests.get
+    """
+    Internal function run on update. Function is a method of the 'requests' module/class
+    """
+    
+    def _make_request(
+        self,
+        method: Union[m_requests.HTTPMethod, str],
+        url: str,
+        *,
+        cookies: Optional[dict[str, str]] = None,
+        headers: Optional[dict[str, str]] = None,
+        params: Optional[dict[str, str]] = None,
+        data: Optional[Union[dict[str, str], str]] = None,
+        json: Optional[Any] = None
+    ) -> optional_async.CARequest:
+        if self.oa_http_session is None:
+            raise ValueError("This BaseSiteComponent has no oa_http_session.")
+        return self.oa_http_session.request(method, url, cookies=cookies, headers=headers, params=params, data=data, json=json)