chore: noqa for mccabe complexity in sa.editor

I plan on a rewrite, not a refactor here

#596 (comment)

Author: faretek1

scratchattach/editor/block.py

@@ -12,13 +12,27 @@ class Block(base.SpriteSubComponent):
     """
     Represents a block in the scratch editor, as a subcomponent of a sprite.
     """
+
     _id: Optional[str] = None
-    def __init__(self, _opcode: str, _shadow: bool = False, _top_level: Optional[bool] = None,
-                 _mutation: Optional[mutation.Mutation] = None, _fields: Optional[dict[str, field.Field]] = None,
-                 _inputs: Optional[dict[str, inputs.Input]] = None, x: int = 0, y: int = 0, pos: Optional[tuple[int, int]] = None,
 
-                 _next: Optional[Block] = None, _parent: Optional[Block] = None,
-                 *, _next_id: Optional[str] = None, _parent_id: Optional[str] = None, _sprite: commons.SpriteInput = build_defaulting.SPRITE_DEFAULT):
+    def __init__(
+        self,
+        _opcode: str,
+        _shadow: bool = False,
+        _top_level: Optional[bool] = None,
+        _mutation: Optional[mutation.Mutation] = None,
+        _fields: Optional[dict[str, field.Field]] = None,
+        _inputs: Optional[dict[str, inputs.Input]] = None,
+        x: int = 0,
+        y: int = 0,
+        pos: Optional[tuple[int, int]] = None,
+        _next: Optional[Block] = None,
+        _parent: Optional[Block] = None,
+        *,
+        _next_id: Optional[str] = None,
+        _parent_id: Optional[str] = None,
+        _sprite: commons.SpriteInput = build_defaulting.SPRITE_DEFAULT,
+    ):
         # Defaulting for args
         if _fields is None:
             _fields = {}
@@ -166,7 +180,7 @@ def id(self) -> str:
         # Let's just automatically assign ourselves an id
         self.sprite.add_block(self)
         return self._id
-    
+
     @id.setter
     def id(self, value: str) -> None:
         self._id = value
@@ -229,7 +243,7 @@ def previous_chain(self):
         Recursive getter method to get all previous blocks in the blockchain (until hitting a top-level block)
         """
         # TODO: check if this hits the recursion limit
-        if self.parent is None: # TODO: use is_top_level?
+        if self.parent is None:  # TODO: use is_top_level?
             return [self]
 
         return [self] + self.parent.previous_chain
@@ -289,7 +303,7 @@ def category(self):
         """
         Works out what category of block this is as a string, using the opcode. Does not perform validation
         """
-        return self.opcode.split('_')[0]
+        return self.opcode.split("_")[0]
 
     @property
     def is_input(self):
@@ -333,7 +347,7 @@ def comment(self) -> comment.Comment | None:
         return None
 
     @property
-    def turbowarp_block_opcode(self):
+    def turbowarp_block_opcode(self):  # noqa: C901
         """
         :return: The 'opcode' if this is a turbowarp block: e.g.
         - log
@@ -349,13 +363,13 @@ def turbowarp_block_opcode(self):
             if self.mutation:
                 if self.mutation.proc_code:
                     # \u200B is a zero-width space
-                    if self.mutation.proc_code == "\u200B\u200Bbreakpoint\u200B\u200B":
+                    if self.mutation.proc_code == "\u200b\u200bbreakpoint\u200b\u200b":
                         return "breakpoint"
-                    elif self.mutation.proc_code == "\u200B\u200Blog\u200B\u200B %s":
+                    elif self.mutation.proc_code == "\u200b\u200blog\u200b\u200b %s":
                         return "log"
-                    elif self.mutation.proc_code == "\u200B\u200Berror\u200B\u200B %s":
+                    elif self.mutation.proc_code == "\u200b\u200berror\u200b\u200b %s":
                         return "error"
-                    elif self.mutation.proc_code == "\u200B\u200Bwarn\u200B\u200B %s":
+                    elif self.mutation.proc_code == "\u200b\u200bwarn\u200b\u200b %s":
                         return "warn"
 
         elif self.opcode == "argument_reporter_boolean":
@@ -414,8 +428,9 @@ def from_json(data: dict) -> Block:
         else:
             _mutation = None
 
-        return Block(_opcode, _shadow, _top_level, _mutation, _fields, _inputs, _x, _y, _next_id=_next_id,
-                     _parent_id=_parent_id)
+        return Block(
+            _opcode, _shadow, _top_level, _mutation, _fields, _inputs, _x, _y, _next_id=_next_id, _parent_id=_parent_id
+        )
 
     def to_json(self) -> dict:
         """
@@ -434,24 +449,28 @@ def to_json(self) -> dict:
         }
         _comment = self.comment
         if _comment:
-            commons.noneless_update(_json, {
-                "comment": _comment.id
-            })
+            commons.noneless_update(_json, {"comment": _comment.id})
 
         if self.is_top_level:
-            commons.noneless_update(_json, {
-                "x": self.x,
-                "y": self.y,
-            })
+            commons.noneless_update(
+                _json,
+                {
+                    "x": self.x,
+                    "y": self.y,
+                },
+            )
 
         if self.mutation is not None:
-            commons.noneless_update(_json, {
-                "mutation": self.mutation.to_json(),
-            })
+            commons.noneless_update(
+                _json,
+                {
+                    "mutation": self.mutation.to_json(),
+                },
+            )
 
         return _json
 
-    def link_using_sprite(self, link_subs: bool = True):
+    def link_using_sprite(self, link_subs: bool = True):  # noqa: C901
         """
         Link this block to various other blocks once the sprite has been assigned
         """
@@ -483,20 +502,18 @@ def link_using_sprite(self, link_subs: bool = True):
 
                     if _type == field.Types.VARIABLE:
                         # Create a new variable
-                        new_value = vlb.Variable(commons.gen_id(),
-                                                 _field.value)
+                        new_value = vlb.Variable(commons.gen_id(), _field.value)
                     elif _type == field.Types.LIST:
                         # Create a list
-                        new_value = vlb.List(commons.gen_id(),
-                                             _field.value)
+                        new_value = vlb.List(commons.gen_id(), _field.value)
                     elif _type == field.Types.BROADCAST:
                         # Create a broadcast
-                        new_value = vlb.Broadcast(commons.gen_id(),
-                                                  _field.value)
+                        new_value = vlb.Broadcast(commons.gen_id(), _field.value)
                     else:
                         # Something probably went wrong
                         warnings.warn(
-                            f"Could not find {_field.id!r} in {self.sprite}. Can't create a new {_type} so we gave a warning")
+                            f"Could not find {_field.id!r} in {self.sprite}. Can't create a new {_type} so we gave a warning"
+                        )
 
                     if new_value is not None:
                         self.sprite.add_local_global(new_value)
@@ -540,9 +557,7 @@ def attach_chain(self, *chain: Block) -> Block:
         return attaching_block
 
     def duplicate_chain(self) -> Block:
-        return self.bottom_level_block.attach_chain(
-            *map(Block.dcopy, self.attached_chain)
-        )
+        return self.bottom_level_block.attach_chain(*map(Block.dcopy, self.attached_chain))
 
     def slot_above(self, new: Block) -> Block:
         """

scratchattach/editor/mutation.py

@@ -38,7 +38,7 @@ def default(self) -> str | None:
         if self.proc_str == "%b":
             return "false"
         elif self.proc_str == "%s":
-            return ''
+            return ""
         else:
             return None
 
@@ -48,19 +48,16 @@ class ArgSettings(base.Base):
     """
     Contains whether the ids, names, and defaults of arguments in a mutation are None or not - i.e. the configuration of the arguments
     """
+
     ids: bool
     names: bool
     defaults: bool
 
     def __int__(self):
-        return (int(self.ids) +
-                int(self.names) +
-                int(self.defaults))
+        return int(self.ids) + int(self.names) + int(self.defaults)
 
     def __eq__(self, other):
-        return (self.ids == other.ids and
-                self.names == other.names and
-                self.defaults == other.defaults)
+        return self.ids == other.ids and self.names == other.names and self.defaults == other.defaults
 
     def __gt__(self, other):
         return int(self) > int(other)
@@ -72,7 +69,7 @@ def __lt__(self, other):
 @dataclass
 class Argument(base.MutationSubComponent):
     name: str
-    default: str = ''
+    default: str = ""
     _type: Optional[ArgumentType] = None
 
     _id: str = None
@@ -91,8 +88,9 @@ def index(self):
     def type(self) -> Optional[ArgumentType]:
         if not self._type:
             if not self.mutation:
-                raise ValueError(f"Cannot infer 'type' of {self} when there is no mutation attached. "
-                                 f"Consider providing a type manually.")
+                raise ValueError(
+                    f"Cannot infer 'type' of {self} when there is no mutation attached. Consider providing a type manually."
+                )
 
             i = 0
             goal = self.index
@@ -130,22 +128,22 @@ def parse_proc_code(_proc_code: str) -> Optional[list[str | ArgumentType]]:
 
     if _proc_code is None:
         return None
-    token = ''
+    token = ""
     tokens = []
 
-    last_char = ''
+    last_char = ""
     for char in _proc_code:
-        if last_char == '%':
+        if last_char == "%":
             if char in "sb":
                 # If we've hit an %s or %b
                 token = token[:-1]
                 # Clip the % sign off the token
 
-                if token.endswith(' '):
+                if token.endswith(" "):
                     # A space is required before params, but this should not be part of the parsed output
                     token = token[:-1]
 
-                if token != '':
+                if token != "":
                     # Make sure not to append an empty token
                     tokens.append(token)
 
@@ -156,17 +154,18 @@ def parse_proc_code(_proc_code: str) -> Optional[list[str | ArgumentType]]:
                 elif token == "%s":
                     tokens.append(ArgTypes.NUMBER_OR_TEXT.value.dcopy())
 
-                token = ''
+                token = ""
                 continue
 
         token += char
         last_char = char
 
-    if token != '':
+    if token != "":
         tokens.append(token)
 
     return tokens
 
+
 def construct_proccode(*components: ArgumentType | ArgTypes | Argument | str) -> str:
     """
     Create a proccode from strings/ArgumentType enum members/Argument instances
@@ -194,16 +193,24 @@ def construct_proccode(*components: ArgumentType | ArgTypes | Argument | str) ->
         else:
             raise TypeError(f"Unsupported component type: {type(comp)}")
 
-        result += ' '
+        result += " "
 
     return result
 
 
 class Mutation(base.BlockSubComponent):
-    def __init__(self, _tag_name: str = "mutation", _children: Optional[list] = None, _proc_code: Optional[str] = None,
-                 _is_warp: Optional[bool] = None, _arguments: Optional[list[Argument]] = None, _has_next: Optional[bool] = None,
-                 _argument_settings: Optional[ArgSettings] = None, *,
-                 _block: Optional[block.Block] = None):
+    def __init__(
+        self,
+        _tag_name: str = "mutation",
+        _children: Optional[list] = None,
+        _proc_code: Optional[str] = None,
+        _is_warp: Optional[bool] = None,
+        _arguments: Optional[list[Argument]] = None,
+        _has_next: Optional[bool] = None,
+        _argument_settings: Optional[ArgSettings] = None,
+        *,
+        _block: Optional[block.Block] = None,
+    ):
         """
         Mutation for Control:stop block and procedures
         https://en.scratch-wiki.info/wiki/Scratch_File_Format#Mutations
@@ -215,9 +222,7 @@ def __init__(self, _tag_name: str = "mutation", _children: Optional[list] = None
         if _argument_settings is None:
             if _arguments:
                 _argument_settings = ArgSettings(
-                    _arguments[0]._id is None,
-                    _arguments[0].name is None,
-                    _arguments[0].default is None
+                    _arguments[0]._id is None, _arguments[0].name is None, _arguments[0].default is None
                 )
             else:
                 _argument_settings = ArgSettings(False, False, False)
@@ -263,9 +268,11 @@ def argument_defaults(self):
 
     @property
     def argument_settings(self) -> ArgSettings:
-        return ArgSettings(bool(commons.safe_get(self.argument_ids, 0)),
-                           bool(commons.safe_get(self.argument_names, 0)),
-                           bool(commons.safe_get(self.argument_defaults, 0)))
+        return ArgSettings(
+            bool(commons.safe_get(self.argument_ids, 0)),
+            bool(commons.safe_get(self.argument_names, 0)),
+            bool(commons.safe_get(self.argument_defaults, 0)),
+        )
 
     @property
     def parsed_proc_code(self) -> list[str | ArgumentType] | None:
@@ -275,7 +282,7 @@ def parsed_proc_code(self) -> list[str | ArgumentType] | None:
         return parse_proc_code(self.proc_code)
 
     @staticmethod
-    def from_json(data: dict) -> Mutation:
+    def from_json(data: dict) -> Mutation:  # noqa: C901
         assert isinstance(data, dict)
 
         _tag_name = data.get("tagName", "mutation")
@@ -302,9 +309,9 @@ def from_json(data: dict) -> Mutation:
         if _argument_defaults is not None:
             assert isinstance(_argument_defaults, str)
             _argument_defaults = json.loads(_argument_defaults)
-        _argument_settings = ArgSettings(_argument_ids is not None,
-                                         _argument_names is not None,
-                                         _argument_defaults is not None)
+        _argument_settings = ArgSettings(
+            _argument_ids is not None, _argument_names is not None, _argument_defaults is not None
+        )
 
         # control_stop attrs
         _has_next = data.get("hasnext")
@@ -337,15 +344,17 @@ def to_json(self) -> dict | None:
             "tagName": self.tag_name,
             "children": self.children,
         }
-        commons.noneless_update(_json, {
-            "proccode": self.proc_code,
-            "warp": commons.dumps_ifnn(self.is_warp),
-            "argumentids": commons.dumps_ifnn(self.argument_ids),
-            "argumentnames": commons.dumps_ifnn(self.argument_names),
-            "argumentdefaults": commons.dumps_ifnn(self.argument_defaults),
-
-            "hasNext": commons.dumps_ifnn(self.has_next)
-        })
+        commons.noneless_update(
+            _json,
+            {
+                "proccode": self.proc_code,
+                "warp": commons.dumps_ifnn(self.is_warp),
+                "argumentids": commons.dumps_ifnn(self.argument_ids),
+                "argumentnames": commons.dumps_ifnn(self.argument_names),
+                "argumentdefaults": commons.dumps_ifnn(self.argument_defaults),
+                "hasNext": commons.dumps_ifnn(self.has_next),
+            },
+        )
 
         return _json
 
@@ -370,12 +379,10 @@ def link_arguments(self):
                 # We can still work out argument defaults from parsing the proc code
                 if self.arguments[0].default is None:
                     _parsed = self.parsed_proc_code
-                    _arg_phs: Iterable[ArgumentType] = filter(lambda tkn: isinstance(tkn, ArgumentType),
-                                                              _parsed)
+                    _arg_phs: Iterable[ArgumentType] = filter(lambda tkn: isinstance(tkn, ArgumentType), _parsed)
                     for i, _arg_ph in enumerate(_arg_phs):
                         self.arguments[i].default = _arg_ph.default
 
             for _argument in self.arguments:
                 _argument.mutation = self
                 _argument.link_using_mutation()
-