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

scratchattach/editor/commons.py

@@ -1,273 +0,0 @@
-"""
-Shared functions used by the editor module
-"""
-from __future__ import annotations
-
-import json
-import random
-import string
-from typing import Optional, Final, Any, TYPE_CHECKING, Union
-from enum import Enum, EnumMeta
-
-if TYPE_CHECKING:
-    from . import sprite, build_defaulting
-
-    SpriteInput = Union[sprite.Sprite, build_defaulting._SetSprite]
-else:
-    SpriteInput = Any
-
-from scratchattach.utils import exceptions
-
-DIGITS: Final[tuple[str, ...]] = tuple("0123456789")
-
-ID_CHARS: Final[str] = string.ascii_letters + string.digits  # + string.punctuation
-
-
-# Strangely enough, it seems like something in string.punctuation causes issues. Not sure why
-
-
-def _read_json_number(_str: str) -> float | int:
-    ret = ''
-
-    minus = _str[0] == '-'
-    if minus:
-        ret += '-'
-        _str = _str[1:]
-
-    def read_fraction(sub: str):
-        sub_ret = ''
-        if sub[0] == '.':
-            sub_ret += '.'
-            sub = sub[1:]
-            while sub[0] in DIGITS:
-                sub_ret += sub[0]
-                sub = sub[1:]
-
-        return sub_ret, sub
-
-    def read_exponent(sub: str):
-        sub_ret = ''
-        if sub[0].lower() == 'e':
-            sub_ret += sub[0]
-            sub = sub[1:]
-
-            if sub[0] in "-+":
-                sub_ret += sub[0]
-                sub = sub[1:]
-
-            if sub[0] not in DIGITS:
-                raise exceptions.UnclosedJSONError(f"Invalid exponent {sub}")
-
-            while sub[0] in DIGITS:
-                sub_ret += sub[0]
-                sub = sub[1:]
-
-        return sub_ret
-
-    if _str[0] == '0':
-        ret += '0'
-        _str = _str[1:]
-
-    elif _str[0] in DIGITS[1:9]:
-        while _str[0] in DIGITS:
-            ret += _str[0]
-            _str = _str[1:]
-
-    frac, _str = read_fraction(_str)
-    ret += frac
-
-    ret += read_exponent(_str)
-
-    return json.loads(ret)
-
-# todo: consider if this should be moved to util.commons instead of editor.commons
-# note: this is currently unused code
-def consume_json(_str: str, i: int = 0) -> str | float | int | dict | list | bool | None:
-    """
-    *'gobble up some JSON until we hit something not quite so tasty'*
-
-    Reads a JSON string and stops at the natural end (i.e. when brackets close, or when quotes end, etc.)
-    """
-    # Named by ChatGPT
-    section = ''.join(_str[i:])
-    if section.startswith("true"):
-        return True
-    elif section.startswith("false"):
-        return False
-    elif section.startswith("null"):
-        return None
-    elif section[0] in "0123456789.-":
-        return _read_json_number(section)
-
-    depth = 0
-    json_text = ''
-    out_string = True
-
-    for char in section:
-        json_text += char
-
-        if char == '"':
-            if len(json_text) > 1:
-                unescaped = json_text[-2] != '\\'
-            else:
-                unescaped = True
-            if unescaped:
-                out_string ^= True
-                if out_string:
-                    depth -= 1
-                else:
-                    depth += 1
-
-        if out_string:
-            if char in "[{":
-                depth += 1
-            elif char in "}]":
-                depth -= 1
-
-        if depth == 0 and json_text.strip():
-            return json.loads(json_text.strip())
-
-    raise exceptions.UnclosedJSONError(f"Unclosed JSON string, read {json_text}")
-
-
-def is_partial_json(_str: str, i: int = 0) -> bool:
-    try:
-        consume_json(_str, i)
-        return True
-
-    except exceptions.UnclosedJSONError:
-        return False
-
-    except ValueError:
-        return False
-
-
-def is_valid_json(_str: Any) -> bool:
-    """
-    Try to load a json string, if it fails, return False, else return true.
-    """
-    try:
-        json.loads(_str)
-        return True
-    except (ValueError, TypeError):
-        return False
-
-
-def noneless_update(obj: dict, update: dict) -> None:
-    """
-    equivalent to dict.update, except and values of None are not assigned
-    """
-    for key, value in update.items():
-        if value is not None:
-            obj[key] = value
-
-
-def remove_nones(obj: dict) -> None:
-    """
-    Removes all None values from a dict.
-    :param obj: Dictionary to remove all None values.
-    """
-    nones = []
-    for key, value in obj.items():
-        if value is None:
-            nones.append(key)
-    for key in nones:
-        del obj[key]
-
-
-def safe_get(lst: list | tuple, _i: int, default: Optional[Any] = None) -> Any:
-    """
-    Like dict.get() but for lists
-    """
-    if len(lst) <= _i:
-        return default
-    else:
-        return lst[_i]
-
-
-def trim_final_nones(lst: list) -> list:
-    """
-    Removes the last None values from a list until a non-None value is hit.
-    :param lst: list which will **not** be modified.
-    """
-    i = len(lst)
-    for item in lst[::-1]:
-        if item is not None:
-            break
-        i -= 1
-    return lst[:i]
-
-
-def dumps_ifnn(obj: Any) -> Optional[str]:
-    """
-    Return json.dumps(obj) if the object is not None
-    """
-    if obj is None:
-        return None
-    else:
-        return json.dumps(obj)
-
-
-def gen_id() -> str:
-    """
-    Generate an id for scratch blocks/variables/lists/broadcasts
-
-    The old 'naïve' method but that chances of a repeat are so miniscule
-    Have to check if whitespace chars break it
-    May later add checking within sprites so that we don't need such long ids (we can save space this way)
-    """
-    return ''.join(random.choices(ID_CHARS, k=20))
-
-
-def sanitize_fn(filename: str):
-    """
-    Removes illegal chars from a filename
-    :return: Sanitized filename
-    """
-    # Maybe could import a slugify module, but it's a bit overkill
-    ret = ''
-    for char in filename:
-        if char in string.ascii_letters + string.digits + "-_":
-            ret += char
-        else:
-            ret += '_'
-    return ret
-
-
-def get_folder_name(name: str) -> str | None:
-    """
-    Get the name of the folder if this is a turbowarp-style costume name
-    """
-    if name.startswith('//'):
-        return None
-
-    if '//' in name:
-        return name.split('//')[0]
-    else:
-        return None
-
-
-def get_name_nofldr(name: str) -> str:
-    """
-    Get the sprite/asset name without the folder name
-    """
-    fldr = get_folder_name(name)
-    if fldr is None:
-        return name
-    else:
-        return name[len(fldr) + 2:]
-
-# Parent enum class
-class SingletonMeta(EnumMeta):
-
-    def __call__(self, value=0, *args, **kwds):
-        if value != 0:
-            raise ValueError("Value must be 0.")
-        old_bases = self.__bases__
-        self.__bases__ = old_bases + (Enum,)
-        result = super().__call__(value, *args, **kwds)
-        self.__bases__ = old_bases
-        return result
-
-Singleton = Enum
-

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