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

scratchattach/eventhandlers/cloud_server.py

@@ -1,246 +0,0 @@
-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
-
-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)
-
-            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)
-
-    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):
-            super().__init__(hostname, port=port, websocketclass=websocketclass)
-            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)

scratchattach/eventhandlers/cloud_storage.py

@@ -1,136 +0,0 @@
-"""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):
-        print(db_name, key, value, self._databases)
-        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()

scratchattach/eventhandlers/combine.py

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

scratchattach/eventhandlers/filterbot.py

@@ -1,161 +0,0 @@
-"""FilterBot class"""
-from __future__ import annotations
-
-from .message_events import MessageEvents
-import time
-
-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):
-        if not self.case_sensitive:
-            content = content.lower()
-        if self.equals is not None:
-            if self.case_sensitive:
-                if self.equals == content:
-                    return True
-            else:
-                if self.equals.lower() == content:
-                    return True
-        if self.contains is not None:
-            if self.case_sensitive:
-                if self.contains.lower() in content:
-                    return True
-            else:
-                if self.contains in content:
-                    return True
-        if self.author_name == author_name:
-            return True
-        if self.project_id == source_id or 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):
-        self.memory = []
-        super().__init__(filter_name, equals=equals, contains=contains, author_name=author_name, project_id=project_id, profile=profile, case_sensitive=case_sensitive)
-
-    def apply(self, content, author_name, source_id):
-        applies = super().apply(content, author_name, source_id)
-        if not applies:
-            return False
-        self.memory.insert(0, {"content":content, "time":time.time()})
-        print(content, self.memory)
-        for comment in list(self.memory)[1:]:
-            if comment["time"] < time.time() -300:
-                self.memory.remove(comment)
-            if comment["content"].lower() == content.lower():
-                return True
-        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, SoftFilter):
-            self.soft_filters.append(filter_obj)
-        elif isinstance(filter_obj, SpamFilter): # careful: SpamFilter is also HardFilter due to inheritence
-            self.spam_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":
-            delete = False
-            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
-            if message.comment_type == 1: # profile comment
-                source_id = message.comment_obj_title
-                if message.comment_obj_title != self.user.username:
-                    return # no permission to delete
-            if message.comment_type == 2: # studio comment
-                return # studio comments aren't handled
-
-            # Apply hard filters
-            for hard_filter in self.hard_filters:
-                if hard_filter.apply(content, message.actor_username, source_id):
-                    delete=True
-                    if self.log_deletions:
-                        print(f"DETECTED: #{message.comment_id} violates hard filter: {hard_filter.filter_name}")
-                    break
-
-            # Apply spam filters
-            if delete is False:
-                for spam_filter in self.spam_filters:
-                    if spam_filter.apply(content, message.actor_username, source_id):
-                        delete=True
-                        if self.log_deletions:
-                            print(f"DETECTED: #{message.comment_id} violates spam filter: {spam_filter.filter_name}")
-                        break
-
-            # Apply soft filters
-            if delete is False:
-                score = 0
-                violated_filers = []
-                for soft_filter in self.soft_filters:
-                    if soft_filter.apply(content, message.actor_username, source_id):
-                        score += soft_filter.score
-                        violated_filers.append(soft_filter.name)
-                if score >= 1:
-                    print(f"DETECTED: #{message.comment_id} violates too many soft filters: {violated_filers}")
-                    delete = True
-            
-            if delete is True:
-                try:
-                    message.target().delete()
-                    if self.log_deletions:
-                        print(f"DELETED: #{message.comment_id} by f{message.actor_username}: '{content}'")
-                except Exception as e:
-                    if self.log_deletions:
-                        print(f"DELETION FAILED: #{message.comment_id} by f{message.actor_username}: '{content}'")
-
-        

scratchattach/eventhandlers/message_events.py

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