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

eventhandlers/cloud_server.py

@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+from SimpleWebSocketServer import SimpleWebSocketServer, WebSocket
+from threading import Thread
+from scratchattach.utils import exceptions
+import json
+import time
+from scratchattach.site import cloud_activity
+from scratchattach.site.user import User
+from ._base import BaseEventHandler
+import traceback
+class TwCloudSocket(WebSocket):
+
+    def handleMessage(self):
+        if not self.server.running:
+            return
+        try:
+            if self.server.check_for_ip_ban(self):
+                return
+            
+            data = json.loads(self.data)
+            print(data)
+
+            if data["method"] == "set":
+                # cloud variable set received
+                # check if project_id is in whitelisted projects (if there's a list of whitelisted projects)
+                if self.server.whitelisted_projects is not None:
+                    if data["project_id"] not in self.server.whitelisted_projects:
+                        self.close(4002)
+                        if self.server.log_var_sets:
+                            print(self.address[0]+":"+str(self.address[1]), "tried to set a var on non-whitelisted project and was disconnected, project:", data["project_id"], "user:",data["user"])
+                        return
+                # check if value is valid
+                if not self.server._check_value(data["value"]):
+                    if self.server.log_var_sets:
+                        print(self.address[0]+":"+str(self.address[1]), "sent an invalid var value")
+                    return
+                # perform cloud var and forward to other players
+                if self.server.log_var_sets:
+                    print(self.address[0]+":"+str(self.address[1]), f"set {data['name']} to {data['value']}, project:", str(data["project_id"]), "user:",data["user"])
+                self.server.set_var(data["project_id"], data["name"], data["value"], user=data["user"], skip_forward=self)                
+                send_to_clients = {
+                    "method" : "set", "user" : data["user"], "project_id" : data["project_id"], "name" : data["name"],
+                    "value" : data["value"], "timestamp" : round(time.time() * 1000), "server" : "scratchattach/2.0.0",
+                }
+                # raise event
+                _a = cloud_activity.CloudActivity(timestamp=time.time()*1000)
+                data["name"] = data["name"].replace("☁ ", "")
+                _a._update_from_dict(send_to_clients)
+                self.server.call_event("on_set", [_a, self])
+
+            elif data["method"] == "handshake":
+                data = json.loads(self.data)
+                # check if handshake is valid
+                if not "user" in data:
+                    print(self.address[0]+":"+str(self.address[1]), "tried to handshake without providing a username")
+                    self.close(4002)
+                    return
+                if not "project_id" in data:
+                    print(self.address[0]+":"+str(self.address[1]), "tried to handshake without providing a project_id")
+                    self.close(4002)
+                    return
+                # check if project_id is in username is allowed
+                if self.server.allow_nonscratch_names is False:
+                    if not User(username=data["user"]).does_exist():
+                        print(self.address[0]+":"+str(self.address[1]), "tried to handshake using a username not existing on Scratch, project:", data["project_id"], "user:",data["user"])
+                        self.close(4002) 
+                        return
+                # check if project_id is in whitelisted projects (if there's a list of whitelisted projects)
+                if self.server.whitelisted_projects is not None:
+                    if str(data["project_id"]) not in self.server.whitelisted_projects:
+                        self.close(4002)
+                        print(self.address[0]+":"+str(self.address[1]), "tried to handshake on a non-whitelisted project:", data["project_id"], "user:",data["user"])
+                        return
+                # register handshake in users list (save username and project_id)
+                print(self.address[0]+":"+str(self.address[1]), "handshaked, project:", data["project_id"], "user:",data["user"])
+                self.server.tw_clients[self.address]["username"] = data["user"]
+                self.server.tw_clients[self.address]["project_id"] = data["project_id"]
+                # send current cloud variable values to the user who handshaked
+                self.sendMessage("\n".join([
+                    json.dumps({
+                        "method" : "set", "project_id" : data["project_id"], "name" : "☁ "+varname,
+                        "value" : self.server.tw_variables[str(data["project_id"])][varname], "server" : "scratchattach/2.0.0",
+                    }) for varname in self.server.get_project_vars(str(data["project_id"]))])
+                )
+                self.sendMessage("This server uses @TimMcCool's scratchattach 2.0.0")
+                # raise event
+                self.server.call_event("on_handshake", [data["user"], data["project_id"], self])
+
+            else:
+                print("Error:", self.address[0]+":"+str(self.address[1]), "sent a message without providing a valid method (set, handshake)")
+
+        except Exception as e:
+            print("Internal error in handleMessage:", e, traceback.format_exc())
+
+    def handleConnected(self):
+        if not self.server.running:
+            return
+        try:
+            if self.server.check_for_ip_ban(self):
+                return
+
+            print(self.address[0]+":"+str(self.address[1]), "connected")
+            self.server.tw_clients[self.address] = {"client":self, "username":None, "project_id":None}
+            # raise event
+            self.server.call_event("on_connect", [self])
+        except Exception as e:
+            print("Internal error in handleConntected:", e)
+
+    def handleClose(self):
+        if not self.server.running:
+            return
+        try:
+            if self.address in self.server.tw_clients:
+                # raise event
+                self.server.call_event("on_disconnect", [self.server.tw_clients[self.address]["username"], self.server.tw_clients[self.address]["project_id"], self])
+                print(self.address[0]+":"+str(self.address[1]), "disconnected")
+        except Exception as e:
+            print("Internal error in handleClose:", e)
+
+def init_cloud_server(hostname='127.0.0.1', port=8080, *, thread=True, length_limit=None, allow_non_numeric=True, whitelisted_projects=None, allow_nonscratch_names=True, blocked_ips=[], sync_players=True, log_var_sets=True):
+    """
+    Inits a websocket server which can be used with TurboWarp's ?cloud_host URL parameter.
+    
+    Prints out the websocket address in the console.
+    """
+    class TwCloudServer(SimpleWebSocketServer, BaseEventHandler):
+        def __init__(self, hostname, *, port, websocketclass):
+            SimpleWebSocketServer.__init__(self, hostname, port=port, websocketclass=websocketclass)
+            BaseEventHandler.__init__(self)
+
+            self.running = False
+            self._events = {} # saves event functions called on cloud updates
+
+            self.tw_clients = {} # saves connected clients
+            self.tw_variables = {}  # holds cloud variable states
+
+            # server config
+            self.allow_non_numeric = allow_non_numeric
+            self.whitelisted_projects = whitelisted_projects
+            self.length_limit = length_limit
+            self.allow_nonscratch_names = allow_nonscratch_names
+            self.blocked_ips = blocked_ips
+            self.sync_players = sync_players
+            self.log_var_sets = log_var_sets
+
+        def check_for_ip_ban(self, client):
+            if client.address[0] in self.blocked_ips or client.address[0]+":"+str(client.address[1]) in self.blocked_ips or client.address in self.blocked_ips:
+                client.sendMessage("You have been banned from this server")
+                client.close(4002)
+                print(client.address[0]+":"+str(client.address[1]), "(IP-banned) was disconnected")
+                return True
+            return False
+                            
+        def active_projects(self):
+            only_active = {}
+            for project_id in self.tw_variables:
+                if self.active_user_ips(project_id) != []:
+                    only_active[project_id] = self.tw_variables[project_id]
+            return only_active
+
+        def active_user_names(self, project_id):
+            return [self.tw_clients[user]["username"] for user in self.active_user_ips(project_id)]
+
+        def active_user_ips(self, project_id):
+            return list(filter(lambda user : str(self.tw_clients[user]["project_id"]) == str(project_id), self.tw_clients))
+
+        def get_global_vars(self):
+            return self.tw_variables
+
+        def get_project_vars(self, project_id):
+            project_id = str(project_id)
+            if project_id in self.tw_variables:
+                return self.tw_variables[project_id]
+            else: return {}
+        
+        def get_var(self, project_id, var_name):
+            project_id = str(project_id)
+            var_name = var_name.replace("☁ ", "")
+            if project_id in self.tw_variables:
+                if var_name in self.tw_variables[project_id]:
+                    return self.tw_variables[project_id][var_name]
+                else: return None
+            else: return None
+        
+        def set_global_vars(self, data):
+            for project_id in data:
+                self.set_project_vars(project_id, data[project_id])
+
+        def set_project_vars(self, project_id, data, *, user="@server"):
+            project_id = str(project_id)
+            self.tw_variables[project_id] = data
+            for client in [self.tw_clients[ip]["client"] for ip in self.active_user_ips(project_id)]:
+                client.sendMessage("\n".join([
+                    json.dumps({
+                        "method" : "set", "project_id" : project_id, "name" : "☁ "+varname,
+                        "value" : data[varname], "server" : "scratchattach/2.0.0", "timestamp" : time.time()*1000, "user" : user
+                    }) for varname in data])
+                )
+
+        def set_var(self, project_id, var_name, value, *, user="@server", skip_forward=None):
+            var_name = var_name.replace("☁ ", "")
+            project_id = str(project_id)
+            if project_id not in self.tw_variables:
+                self.tw_variables[project_id] = {}               
+            self.tw_variables[project_id][var_name] = value
+
+            if self.sync_players is True:
+                for client in [self.tw_clients[ip]["client"] for ip in self.active_user_ips(project_id)]:
+                    if client == skip_forward:
+                        continue
+                    client.sendMessage(
+                        json.dumps({
+                            "method" : "set", "project_id" : project_id, "name" : "☁ "+var_name,
+                            "value" : value, "timestamp" : time.time()*1000, "user" : user
+                        })
+                    )
+
+        def _check_value(self, value):
+            # Checks if a received cloud value satisfies the server's constraints
+            if self.length_limit is not None:
+                if len(str(value)) > self.length_limit:
+                    return False
+            if self.allow_non_numeric is False:
+                x = value.replace(".", "")
+                x = x.replace("-", "")
+                if not (x.isnumeric() or x == ""):
+                    return False
+            return True
+        
+        def _updater(self):
+            try:
+                # Function called when .start() is executed (.start is inherited from BaseEventHandler)
+                print(f"Serving websocket server: ws://{hostname}:{port}")
+                self.serveforever()
+            except Exception as e:
+                raise exceptions.WebsocketServerError(str(e))
+
+        def pause(self):
+            self.running = False
+
+        def resume(self):
+            self.running = True
+
+        def stop(self):
+            self.running = False
+            self.close()
+
+    return TwCloudServer(hostname, port=port, websocketclass=TwCloudSocket)

eventhandlers/cloud_storage.py

@@ -0,0 +1,135 @@
+"""CloudStorage class"""
+from __future__ import annotations
+
+from .cloud_requests import CloudRequests
+import json
+import time
+from threading import Thread
+
+class Database:
+
+    """
+    A Database is a simple key-value storage that stores data in a JSON file saved locally (other database services like MongoDB can be implemented)
+    """
+
+    def __init__(self, name, *, json_file_path, save_interval=30):
+        self.save_event_function = None
+        self.set_event_function = None
+        self.name = name
+
+        # Import from JSON file
+        if not json_file_path.endswith(".json"):
+            json_file_path = json_file_path+".json"
+        self.json_file_path = json_file_path
+
+        try:
+            with open(json_file_path, 'r') as json_file:
+                self.data = json.load(json_file)
+        except FileNotFoundError:
+            print(f"Creating file {json_file_path}. Your database {name} will be stored there.")
+            self.data = {}
+            self.save_to_json()
+        
+        if isinstance(self.data , list):
+            raise ValueError(
+                "Invalid JSON file content: Top-level object must be a dict, not a list"
+            )
+        
+        # Start autosaving
+        self.save_interval = save_interval
+        if self.save_interval is not None:
+            Thread(target=self._autosaver).start()
+
+    def save_to_json(self):
+        with open(self.json_file_path, 'w') as json_file:
+            json.dump(self.data, json_file, indent=4)
+        
+        if self.save_event_function is not None:
+            self.save_event_function()
+    
+    def keys(self) -> list:
+        return list(self.data.keys())
+
+    def get(self, key) -> str:
+        if not key in self.data:
+            return None
+        return self.data[key]
+    
+    def set(self, key, value):
+        self.data[key] = value
+
+        if self.set_event_function is not None:
+            self.set_event_function(key, value)
+
+    def event(self, event_function):
+        # Decorator function for adding the on_save event that is called when a save is performed
+        if event_function.__name__ == "on_save":
+            self.save_event_function = event_function
+        if event_function.__name__ == "on_set":
+            self.set_event_function = event_function
+        
+    def _autosaver(self):
+        # Task autosaving the db. save interval specified in .save_interval attribute
+        while True:
+            time.sleep(self.save_interval)
+            self.save_to_json()
+
+class CloudStorage(CloudRequests):
+    
+    """
+    A CloudStorage object saves multiple databases and allows the connected Scratch project to access and modify the data of these databases through cloud requests
+
+    The CloudStorage class is built upon CloudRequests
+    """
+
+    def __init__(self, cloud, used_cloud_vars=["1", "2", "3", "4", "5", "6", "7", "8", "9"], no_packet_loss=False):
+        super().__init__(cloud, used_cloud_vars=used_cloud_vars, no_packet_loss=no_packet_loss)
+        # Setup
+        self._databases = {}
+        self.request(self.get, thread=False)
+        self.request(self.set, thread=False)
+        self.request(self.keys, thread=False)
+        self.request(self.database_names, thread=False)
+        self.request(self.ping, thread=False)
+
+    def ping(self):
+        return "Database backend is running"
+    
+    def get(self, db_name, key) -> str:
+        try:
+            return self.get_database(db_name).get(key)
+        except Exception:
+            if self.get_database(db_name) is None:
+                return f"Error: Database {db_name} doesn't exist"
+            else:
+                return f"Error: Key {key} doesn't exist in database {db_name}"
+
+    def set(self, db_name, key, value):
+        return self.get_database(db_name).set(key, value)
+
+    def keys(self, db_name) -> list:
+        try:
+            return self.get_database(db_name).keys()
+        except Exception:
+            return f"Error: Database {db_name} doesn't exist"
+
+    def databases(self) -> list:
+        return list(self._databases.values())
+
+    def database_names(self) -> list:
+        return list(self._databases.keys())
+    
+    def add_database(self, database:Database):
+        self._databases[database.name] = database
+
+    def get_database(self, name) -> Database:
+        if name in self._databases:
+            return self._databases[name]
+        return None
+
+    def save(self):
+        """
+        Saves the data in the JSON files for all databases in self._databases
+        """
+        for dbname in self._databases:
+            self._databases[dbname].save_to_json()

eventhandlers/combine.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+class MultiEventHandler:
+
+    def __init__(self, *handlers):
+        self.handlers = handlers
+
+    def request(self, function, *args, **kwargs):
+        for handler in self.handlers:
+            handler.request(function, *args, **kwargs)
+
+    def event(self, function, *args, **kwargs):
+        for handler in self.handlers:
+            handler.event(function, *args, **kwargs)
+
+    def start(self, *args, **kwargs):
+        for handler in self.handlers:
+            handler.start(*args, **kwargs)
+
+    def stop(self, *args, **kwargs):
+        for handler in self.handlers:
+            handler.stop(*args, **kwargs)
+
+    def pause(self, *args, **kwargs):
+        for handler in self.handlers:
+            handler.pause(*args, **kwargs)
+
+    def resume(self, *args, **kwargs):
+        for handler in self.handlers:
+            handler.resume(*args, **kwargs)

eventhandlers/filterbot.py

@@ -0,0 +1,163 @@
+"""FilterBot class"""
+from __future__ import annotations
+from .message_events import MessageEvents
+import time
+from collections import deque
+
+class HardFilter:
+    
+    def __init__(self, filter_name="UntitledFilter", *, equals=None, contains=None, author_name=None, project_id=None, profile=None, case_sensitive=False):
+        self.equals = equals
+        self.contains = contains
+        self.author_name = author_name
+        self.project_id = project_id
+        self.profile = profile
+        self.case_sensitive = case_sensitive
+        self.filter_name = filter_name
+    
+    def apply(self, content, author_name, source_id):
+        text_to_check = content if self.case_sensitive else content.lower()
+        if self.equals is not None:
+            comparison_equals = self.equals if self.case_sensitive else self.equals.lower()
+            if text_to_check == comparison_equals:
+                return True
+        if self.contains is not None:
+            comparison_contains = self.contains if self.case_sensitive else self.contains.lower()
+            if comparison_contains in text_to_check:
+                return True
+        if self.author_name is not None and self.author_name == author_name:
+            return True
+        if (self.project_id is not None and self.project_id == source_id) or \
+           (self.profile is not None and self.profile == source_id):
+            return True
+        return False
+
+class SoftFilter(HardFilter):
+    def __init__(self, score:float, filter_name="UntitledFilter", *, equals=None, contains=None, author_name=None, project_id=None, profile=None, case_sensitive=False):
+        self.score = score
+        super().__init__(filter_name, equals=equals, contains=contains, author_name=author_name, project_id=project_id, profile=profile, case_sensitive=case_sensitive)
+
+class SpamFilter(HardFilter):
+    def __init__(self, filter_name="UntitledFilter", *, equals=None, contains=None, author_name=None, project_id=None, profile=None, case_sensitive=False):
+        super().__init__(filter_name, equals=equals, contains=contains, author_name=author_name, project_id=project_id, profile=profile, case_sensitive=case_sensitive)
+        self.memory = deque()
+        self.retention_period = 300
+
+    def apply(self, content, author_name, source_id):
+        if not super().apply(content, author_name, source_id):
+            return False
+        current_time = time.time()
+        
+        # Prune old entries from memory
+        while self.memory and self.memory[-1]["time"] < current_time - self.retention_period:
+            self.memory.pop()
+
+        content_lower = content.lower()
+        # Check for duplicates
+        for comment in self.memory:
+            if comment["content"].lower() == content_lower:
+                return True
+
+        # Add new comment to memory
+        self.memory.appendleft({"content": content, "time": current_time})
+        return False
+
+class Filterbot(MessageEvents):
+
+    # The Filterbot class is built upon MessageEvents, similar to how CloudEvents is built upon CloudEvents
+
+    def __init__(self, user, *, log_deletions=True):
+        super().__init__(user)
+        self.hard_filters = []
+        self.soft_filters = []
+        self.spam_filters = []
+        self.log_deletions = log_deletions
+        self.event(self.on_message, thread=False)
+        self.update_interval = 2
+
+    def add_filter(self, filter_obj):
+        if isinstance(filter_obj, SpamFilter):
+            self.spam_filters.append(filter_obj)
+        elif isinstance(filter_obj, SoftFilter):
+            self.soft_filters.append(filter_obj)
+        elif isinstance(filter_obj, HardFilter):
+            self.hard_filters.append(filter_obj)
+
+    def add_f4f_filter(self):
+        self.add_filter(HardFilter("(f4f_filter) 'f4f'", contains="f4f"))
+        self.add_filter(HardFilter("(f4f_filter) 'follow me'", contains="follow me"))
+        self.add_filter(HardFilter("(f4f_filter) 'follow @'", contains="follow @"))
+        self.add_filter(HardFilter("(f4f_filter) f 4 f'", contains="f 4 f"))
+        self.add_filter(HardFilter("(f4f_filter) 'follow for'", contains="follow for"))
+
+    def add_ads_filter(self):
+        self.add_filter(SoftFilter(1, "(ads_filter) links", contains="scratch.mit.edu/projects/"))
+        self.add_filter(SoftFilter(-1, "(ads_filter) feedback", contains="feedback"))
+        self.add_filter(HardFilter("(ads_filter) 'check out my'", contains="check out my"))
+        self.add_filter(HardFilter("(ads_filter) 'play my'", contains="play my"))
+        self.add_filter(SoftFilter(1, "(ads_filter) 'advertis'", contains="advertis"))
+
+    def add_spam_filter(self):
+        self.add_filter(SpamFilter("(spam_filter)", contains=""))
+
+    def add_genalpha_nonsense_filter(self):
+        self.add_filter(HardFilter("(genalpha_nonsene_filter) 'skibidi'", contains="skibidi"))
+        self.add_filter(HardFilter("[genalpha_nonsene_filter) 'rizzler'", contains="rizzler"))
+        self.add_filter(HardFilter("(genalpha_nonsene_filter) 'fanum tax'", contains="fanum tax"))
+
+    def on_message(self, message):
+        if message.type != "addcomment":
+            return
+        source_id = None
+        content = message.comment_fragment
+        if message.comment_type == 0: # project comment
+            source_id = message.comment_obj_id
+            if self.user._session.connect_project(message.comment_obj_id).author_name != self.user.username:
+                return # no permission to delete comments that aren't on our own project
+        elif message.comment_type == 1: # profile comment
+            source_id = message.comment_obj_title
+            if source_id != self.user.username:
+                return # no permission to delete messages that are not on our profile
+        elif message.comment_type == 2: # studio comment
+            return # studio comments aren't handled
+        else:
+            return
+        delete = False
+        reason = ""
+
+        # Apply hard filters
+        for hard_filter in self.hard_filters:
+            if hard_filter.apply(content, message.actor_username, source_id):
+                delete = True
+                reason = f"hard filter: {hard_filter.filter_name}"
+                break
+
+        # Apply spam filters
+        if not delete:
+            for spam_filter in self.spam_filters:
+                if spam_filter.apply(content, message.actor_username, source_id):
+                    delete = True
+                    reason = f"spam filter: {spam_filter.filter_name}"
+                    break
+
+        # Apply soft filters
+        if not delete:
+            score = 0
+            violated_filters = []
+            for soft_filter in self.soft_filters:
+                if soft_filter.apply(content, message.actor_username, source_id):
+                    score += soft_filter.score
+                    violated_filters.append(soft_filter.filter_name)
+            if score >= 1:
+                delete = True
+                reason = f"too many soft filters: {violated_filters}"
+        if delete:
+            if self.log_deletions:
+                print(f"DETECTED: #{message.comment_id} violates {reason}")
+            try:
+                resp = message.target().delete()
+                if self.log_deletions:
+                    print(f"DELETED: #{message.comment_id} by {message.actor_username!r}: '{content}' with message {resp.content!r} & headers {resp.headers!r}")
+            except Exception as e:
+                if self.log_deletions:
+                    print(f"DELETION FAILED: #{message.comment_id} by {message.actor_username!r}: '{content}'; exception: {e}")

eventhandlers/message_events.py

@@ -0,0 +1,42 @@
+"""MessageEvents class"""
+from __future__ import annotations
+
+from scratchattach.site import user
+from ._base import BaseEventHandler
+import time
+
+class MessageEvents(BaseEventHandler):
+    """
+    Class that calls events when you receive messages on your Scratch account. Data fetched from Scratch's API.
+    """
+    def __init__(self, user, *, update_interval=2):
+        super().__init__()
+        self.user = user
+        self.current_message_count = 0
+        self.update_interval = update_interval
+
+    def _updater(self):
+        """
+        A process that listens for cloud activity and executes events on cloud activity
+        """
+        self.current_message_count = int(self.user.message_count())
+        
+        self.call_event("on_ready")
+
+        while True:
+            if self.running is False:
+                return
+            message_count = int(self.user.message_count())
+            if message_count != self.current_message_count:
+                self.call_event("on_count_change", [int(self.current_message_count), int(message_count)])
+                if message_count != 0:
+                    if message_count < self.current_message_count:
+                        self.current_message_count = 0
+                    if self.user._session is not None: # authentication check
+                        if self.user._session.username == self.user.username: # authorization check
+                            new_messages = self.user._session.messages(limit=message_count-self.current_message_count)
+                            for message in new_messages[::-1]:
+                                self.call_event("on_message", [message])
+                self.current_message_count = int(message_count)
+            time.sleep(self.update_interval)
+