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

{scratchattach/eventhandlers → eventhandlers}/cloud_requests.py

@@ -1,14 +1,36 @@
 """CloudRequests class (threading.Event version)"""
 from __future__ import annotations
 
-from .cloud_events import CloudEvents
-from scratchattach.site import project
-from threading import Thread, Event, current_thread
+from threading import Thread, Event, local
 import time
 import random
 import traceback
+import warnings
+from dataclasses import dataclass, field
+from typing import Protocol, Any, runtime_checkable, TypedDict, Union, Optional
+from enum import Enum, auto
+
 from scratchattach.utils.encoder import Encoding
 from scratchattach.utils import exceptions
+from scratchattach.site import project, cloud_activity
+from scratchattach.cloud import _base
+from .cloud_events import CloudEvents
+
+class RequestHandlerThreadInfo(local):
+    request_id: str = ""
+
+request_handler_thread_info = RequestHandlerThreadInfo()
+
+class ErrorInRequest(RuntimeWarning):
+    pass
+
+class ErrorWithMessage(Exception):
+    pass
+
+@runtime_checkable
+class RequestHandler(Protocol):
+    def __call__(self, *args: str) -> Any:
+        pass
 
 class Request:
 
@@ -16,7 +38,17 @@ class Request:
     Saves a request added to the request handler
     """
 
-    def __init__(self, request_name, *, on_call, cloud_requests, thread=True, enabled=True, response_priority=0, debug=False):
+    def __init__(
+        self,
+        request_name: str,
+        *,
+        on_call: RequestHandler,
+        cloud_requests: CloudRequests,
+        thread: bool = True,
+        enabled: bool = True,
+        response_priority: int = 0,
+        debug: bool = False
+    ):
         self.name = request_name
         self.on_call = on_call
         self.thread = thread
@@ -25,45 +57,93 @@ class Request:
         self.cloud_requests = cloud_requests # the corresponding CloudRequests object
         self.debug = debug or self.cloud_requests.debug
         
-    def __call__(self, received_request):
+    def __call__(self, received_request: ReceivedRequest):
         if not self.enabled:
             self.cloud_requests.call_event("on_disabled_request", [received_request])
+            return
         try:
-            current_thread().setName(received_request.request_id)
+            request_handler_thread_info.request_id = received_request.request_id # Used by .get_requester() / .get_timestamp() as lookup key
             output = self.on_call(*received_request.arguments)
-            self.cloud_requests.request_outputs.append({"receive":received_request.timestamp, "request_id":received_request.request_id, "output":output, "priority":self.response_priority})
+            self.cloud_requests.request_outputs.append({"receive":received_request.timestamp, "request_id": received_request.request_id, "output":output, "priority":self.response_priority})
+        except ErrorWithMessage as e:
+            self.cloud_requests.call_event("on_error", [received_request, e])
+            output = [i for arg in e.args for i in str(arg).splitlines()]
+            self.cloud_requests.request_outputs.append({"receive": received_request.timestamp, "request_id": received_request.request_id, "output": output, "priority": self.response_priority})
         except Exception as e:
             self.cloud_requests.call_event("on_error", [received_request, e])
             if self.cloud_requests.ignore_exceptions:
-                print(
-                    f"Warning: Caught error in request '{self.name}' - Full error below"
+                warnings.warn(
+                    f"Warning: Caught error in request {self.name!r} - Full error below\n{traceback.format_exc()}",
+                    ErrorInRequest
                 )
-                try:
-                    traceback.print_exc()
-                except Exception:
-                    print(e)
             else:
-                print(f"Exception in request '{self.name}':")
+                print(f"Exception in request {self.name!r}:")
                 raise(e)
             if self.debug:
                 traceback_full = traceback.format_exc().splitlines()
                 output = [f"Error in request {self.name}", "Traceback: "]
                 output.extend(traceback_full)
-                self.cloud_requests.request_outputs.append({"receive":received_request.timestamp, "request_id":received_request.request_id, "output":output, "priority":self.response_priority})
+                self.cloud_requests.request_outputs.append({"receive": received_request.timestamp, "request_id": received_request.request_id, "output": output, "priority": self.response_priority})
             else:
-                self.cloud_requests.request_outputs.append({"receive":received_request.timestamp, "request_id":received_request.request_id, "output":[f"Error in request {self.name}","Check the Python console"], "priority":self.response_priority})
+                self.cloud_requests.request_outputs.append({"receive": received_request.timestamp, "request_id": received_request.request_id, "output": [f"Error in request {self.name}", "Check the Python console"], "priority": self.response_priority})
         self.cloud_requests.responder_event.set() # Activate the .cloud_requests._responder process so it sends back the data to Scratch
 
-class ReceivedRequest:
+class EmptyRequest(Request):
+    def __init__(self):
+        pass
+    
+    def __call__(self, received_request):
+        raise TypeError("Empty request can not be called.")
 
-    def __init__(self, **entries):
-        self.__dict__.update(entries)
+@dataclass
+class ReceivedRequest:
+    request: Request = field(kw_only=True, default_factory=EmptyRequest)
+    request_name: str = field(kw_only=True, default="")
+    requester: str = field(kw_only=True, default="")
+    timestamp: float = field(kw_only=True, default=0.0)
+    arguments: list[str] = field(kw_only=True, default_factory=list)
+    request_id: str = field(kw_only=True, default="0")
+    activity: cloud_activity.CloudActivity = field(kw_only=True)
+
+class RespondOrder(Enum):
+    FINISH = auto() # {"receive":time.time()*1000, "request_id":"100000000"+str(random.randint(1000, 9999)), "output":data, "priority":priority}
+    RECEIVE = auto()
+    REQUEST_ID = auto()
+    OUTPUT = auto()
+    PRIORITY = auto()
+
+class RequestOutput(TypedDict):
+    receive: float
+    request_id: str
+    output: Union[str, list[str]]
+    priority: int
+
+class ResponseMemory(TypedDict):
+    rid: str
+    packets: dict[int, str]
 
 class CloudRequests(CloudEvents):
 
     # The CloudRequests class is built upon CloudEvents, similar to how Filterbot is built upon MessageEvents
 
-    def __init__(self, cloud, used_cloud_vars=["1", "2", "3", "4", "5", "6", "7", "8", "9"], no_packet_loss=False, respond_order="receive", debug=False):
+    _requests: dict[str, Request]
+    request_parts: dict[str, list[str]]
+    received_requests: list[ReceivedRequest]
+    executed_requests: dict[str, ReceivedRequest]
+    request_outputs: list[RequestOutput]
+    responded_request_ids: list[str]
+    packet_memory: list[ResponseMemory]
+    _packets_to_resend: list[str]
+
+    def __init__(
+        self,
+        cloud: _base.AnyCloud,
+        used_cloud_vars: Optional[list[str]] = None,
+        no_packet_loss: bool = False,
+        respond_order: RespondOrder = RespondOrder.RECEIVE,
+        debug = False
+    ):
+        used_cloud_vars = used_cloud_vars or ["1", "2", "3", "4", "5", "6", "7", "8", "9"]
         super().__init__(cloud)
         # Setup
         self._requests = {}
@@ -95,7 +175,7 @@ class CloudRequests(CloudEvents):
 
         self.current_var = 0 # ID of the last set FROM_HOST_ variable (when a response is sent back to Scratch, these are set cyclically)
         self.credit_check()
-        self.hard_stop = False # When set to True, all processes will halt immediately without finishing safely (can result in not fully received / responded requests etc.)
+        self.hard_stopped = False # When set to True, all processes will halt immediately without finishing safely (can result in not fully received / responded requests etc.)
 
     # -- Adding and removing requests --
 
@@ -103,24 +183,26 @@ class CloudRequests(CloudEvents):
         """
         Decorator function. Adds a request to the request handler.
         """
-        def inner(function):
+        def inner(_function):
+            _name = _function.__name__ if name is None else name
             # called if the decorator provides arguments
-            self._requests[function.__name__ if name is None else name] = Request(
-                function.__name__ if name is None else name,
-                enabled = enabled,
+            self._requests[_name] = Request(
+                _name,
+                enabled=enabled,
                 thread=thread,
                 response_priority=response_priority,
-                on_call=function,
+                on_call=_function,
                 cloud_requests=self,
                 debug=debug
             )
+            return _function
 
         if function is None:
             # => the decorator provides arguments
             return inner
         else:
             # => the decorator doesn't provide arguments
-            inner(function)
+            return inner(function)
 
     def add_request(self, function, *, enabled=True, name=None):
         self.request(enabled=enabled, name=name)(function)
@@ -128,10 +210,10 @@ class CloudRequests(CloudEvents):
     def remove_request(self, name):
         try:
             self._requests.pop(name)
-        except Exception:
-            raise ValueError(
+        except KeyError as e:
+            raise KeyError(
                 f"No request with name {name} found to remove"
-            )
+            ) from e
 
     # -- Parse and send back the request output --
 
@@ -191,7 +273,7 @@ class CloudRequests(CloudEvents):
             ) or self.no_packet_loss:
             self.cloud.reconnect()
 
-        memory = {"rid":request_id}
+        memory = ResponseMemory(rid=request_id, packets={})#{"rid":request_id}
         remaining_response = str(response)
         length_limit = self.cloud.length_limit - (len(str(request_id))+6) # the subtrahend is the worst-case length of the "."+numbers after the "."
         
@@ -210,7 +292,7 @@ class CloudRequests(CloudEvents):
                     iteration_string = "00" + str(i)
 
                 value_to_send = f"{response_part}.{request_id}{iteration_string}1"
-                memory[i] = value_to_send
+                memory["packets"][i] = value_to_send
                 
                 self._set_FROM_HOST_var(value_to_send)
 
@@ -221,26 +303,27 @@ class CloudRequests(CloudEvents):
                     self.packet_memory.pop(0)
                 remaining_response = ""
 
-            if self.hard_stop: # stop immediately without exiting safely
+            if self.hard_stopped: # stop immediately without exiting safely
                 break
 
-    def _request_packet_from_memory(self, request_id, packet_id):
+    def _request_packet_from_memory(self, request_id: str, packet_id: Union[str, int]):
         memory = list(filter(lambda x : x["rid"] == request_id, self.packet_memory))
         if len(memory) > 0:
-            self._packets_to_resend.append(memory[0][int(packet_id)])
+            self._packets_to_resend.append(memory[0]["packets"][int(packet_id)])
             self.responder_event.set() # activate _responder process
 
     # -- Register and handle incoming requests --
 
-    def on_set(self, activity):
+    def on_set(self, activity: cloud_activity.CloudActivity):
         """
         This function is automatically called on cloud activites by the underlying cloud events that this CloudRequests class inherits from
         It registers incoming cloud activity and (if request.thread is True) runs them directly or (else) adds detected request to the .received_requests list
         """
         # Note for contributors: All functions called in this on_set function MUST be executed in threads because this function blocks the cloud events receiver, which is usually not a problem (because of the websocket buffer) but can cause problems in rare cases
-        if activity.var == "TO_HOST" and "." in activity.value:
+        activity_value = str(activity.value)
+        if activity.var == "TO_HOST" and "." in activity_value:
             # Parsing the received request
-            raw_request, request_id = activity.value.split(".")
+            raw_request, request_id = activity_value.split(".")
 
             if len(request_id) == 8 and request_id[-1] == "9":
                 # A lost packet was re-requested
@@ -251,7 +334,7 @@ class CloudRequests(CloudEvents):
                 # => The received request has already been answered, meaning this activity has already been received
                 return
 
-            if activity.value[0] == "-":
+            if activity_value[0] == "-":
                 # => The received request is actually part of a bigger request
                 if not request_id in self.request_parts:
                     self.request_parts[request_id] = []
@@ -273,15 +356,16 @@ class CloudRequests(CloudEvents):
             # Decode request and parse arguemtns:
             request = Encoding.decode(raw_request)
             arguments = request.split("&")
-            request_name = arguments.pop(0)#
+            request_name = arguments.pop(0)
             
             # Check if the request is unknown:
             if request_name not in self._requests:
                 print(
-                    f"Warning: Client received an unknown request called '{request_name}'"
+                    f"Warning: Client received an unknown request called {request_name!r}"
                 )
                 self.call_event("on_unknown_request", [
-                    ReceivedRequest(request_name=request,
+                    ReceivedRequest(
+                        request_name=request,
                         requester=activity.user,
                         timestamp=activity.timestamp,
                         arguments=arguments,
@@ -293,6 +377,7 @@ class CloudRequests(CloudEvents):
             
             received_request = ReceivedRequest(
                 request = self._requests[request_name],
+                request_name=request_name,
                 requester=activity.user,
                 timestamp=activity.timestamp,
                 arguments=arguments,
@@ -328,7 +413,7 @@ class CloudRequests(CloudEvents):
 
                 if use_extra_data:
                     Thread(target=self.on_reconnect).start()
-                if self.hard_stop: # stop immediately without exiting safely
+                if self.hard_stopped: # stop immediately without exiting safely
                     break
 
             self.executer_event.wait(timeout = 2.5 if use_extra_data else None) # Wait for requests to be received
@@ -343,21 +428,21 @@ class CloudRequests(CloudEvents):
             
             while self._packets_to_resend != []:
                 self._set_FROM_HOST_var(self._packets_to_resend.pop(0))
-                if self.hard_stop: # stop immediately without exiting safely
+                if self.hard_stopped: # stop immediately without exiting safely
                     break
 
-            while self.request_outputs != []:
-                if self.respond_order == "finish":
+            while self.request_outputs:
+                if self.respond_order == RespondOrder.FINISH:
                     output_obj = self.request_outputs.pop(0)
                 else:
-                    output_obj = min(self.request_outputs, key=lambda x : x[self.respond_order])
+                    output_obj = min(self.request_outputs, key=lambda x : x[self.respond_order.name.lower()])
                     self.request_outputs.remove(output_obj)
                 if output_obj["request_id"] in self.executed_requests:
                     received_request = self.executed_requests.pop(output_obj["request_id"])
-                    self._parse_output(received_request, output_obj["output"], output_obj["request_id"])
+                    self._parse_output(received_request.request_name, output_obj["output"], output_obj["request_id"])
                 else:
                     self._parse_output("[sent from backend]", output_obj["output"], output_obj["request_id"])
-                if self.hard_stop: # stop immediately without exiting safely
+                if self.hard_stopped: # stop immediately without exiting safely
                     break
 
     def on_reconnect(self):
@@ -379,7 +464,7 @@ class CloudRequests(CloudEvents):
         """
         Can be used inside a request to get the username that performed the request.
         """
-        activity = self.executed_requests[current_thread().name].activity
+        activity = self.executed_requests[request_handler_thread_info.request_id].activity
         if activity.user is None:
             activity.load_log_data()
         return activity.user
@@ -388,14 +473,14 @@ class CloudRequests(CloudEvents):
         """
         Can be used inside a request to get the timestamp of when the request was received.
         """
-        activity = self.executed_requests[current_thread().name].activity
+        activity = self.executed_requests[request_handler_thread_info.request_id].activity
         return activity.timestamp
 
     def get_exact_timestamp(self):
         """
         Can be used inside a request to get the exact timestamp of when the request was performed.
         """
-        activity = self.executed_requests[current_thread().name].activity
+        activity = self.executed_requests[request_handler_thread_info.request_id].activity
         activity.load_log_data()
         return activity.timestamp
 
@@ -434,10 +519,10 @@ class CloudRequests(CloudEvents):
         """
         Stops the request handler and all associated threads forever. Stops running response sending processes immediately.
         """
-        self.hard_stop = True
+        self.hard_stopped = True
         self.stop()
         time.sleep(0.5)
-        self.hard_stop = False
+        self.hard_stopped = False
 
     def credit_check(self):
         try:

{scratchattach/eventhandlers → eventhandlers}/cloud_server.py

@@ -8,7 +8,7 @@ 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):
@@ -19,6 +19,7 @@ class TwCloudSocket(WebSocket):
                 return
             
             data = json.loads(self.data)
+            print(data)
 
             if data["method"] == "set":
                 # cloud variable set received
@@ -90,7 +91,7 @@ class TwCloudSocket(WebSocket):
                 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)
+            print("Internal error in handleMessage:", e, traceback.format_exc())
 
     def handleConnected(self):
         if not self.server.running:
@@ -125,7 +126,9 @@ def init_cloud_server(hostname='127.0.0.1', port=8080, *, thread=True, length_li
     """
     class TwCloudServer(SimpleWebSocketServer, BaseEventHandler):
         def __init__(self, hostname, *, port, websocketclass):
-            super().__init__(hostname, port=port, websocketclass=websocketclass)
+            SimpleWebSocketServer.__init__(self, hostname, port=port, websocketclass=websocketclass)
+            BaseEventHandler.__init__(self)
+
             self.running = False
             self._events = {} # saves event functions called on cloud updates
 

{scratchattach/eventhandlers → eventhandlers}/cloud_storage.py

@@ -105,7 +105,6 @@ class CloudStorage(CloudRequests):
                 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:
@@ -133,4 +132,4 @@ class CloudStorage(CloudRequests):
         Saves the data in the JSON files for all databases in self._databases
         """
         for dbname in self._databases:
-            self._databases[dbname].save_to_json()
+            self._databases[dbname].save_to_json()

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}")