refactor: fix some flake8-return warnings

Author: d-biehl

pyproject.toml

@@ -272,7 +272,9 @@ select = [
   #"INP",
   "PIE",
   # "T20",
-  "PT"
+  "PT",
+  "Q",
+  "RET"
 ]
 
 

robotcode/debugger/debugger.py

@@ -440,8 +440,8 @@ def set_breakpoints(
                 Breakpoint(id=id(v), source=Source(path=str(path)), verified=True, line=v.line)
                 for v in result.breakpoints
             ]
-        else:
-            self._logger.error("not supported breakpoint")
+
+        self._logger.error("not supported breakpoint")
 
         return []
 
@@ -452,7 +452,7 @@ def process_start_state(self, source: str, line_no: int, type: str, status: str)
         if self.state == State.Stopped:
             return
 
-        elif self.requested_state == RequestedState.Pause:
+        if self.requested_state == RequestedState.Pause:
             self.state = State.Paused
             self.send_event(
                 self,
@@ -555,18 +555,18 @@ def process_start_state(self, source: str, line_no: int, type: str, status: str)
                                 ),
                             )
                             return
-                        else:
-                            self.state = State.Paused
-                            self.send_event(
-                                self,
-                                StoppedEvent(
-                                    body=StoppedEventBody(
-                                        reason=StoppedReason.BREAKPOINT,
-                                        thread_id=threading.current_thread().ident,
-                                        hit_breakpoint_ids=[id(v) for v in breakpoints],
-                                    )
-                                ),
-                            )
+
+                        self.state = State.Paused
+                        self.send_event(
+                            self,
+                            StoppedEvent(
+                                body=StoppedEventBody(
+                                    reason=StoppedReason.BREAKPOINT,
+                                    thread_id=threading.current_thread().ident,
+                                    hit_breakpoint_ids=[id(v) for v in breakpoints],
+                                )
+                            ),
+                        )
 
     def process_end_state(self, status: str, filter_id: Set[str], description: str, text: Optional[str]) -> None:
         if (
@@ -940,8 +940,8 @@ def map_path_to_client(self, path: Union[os.PathLike[str], str]) -> pathlib.Pure
             ):
                 if self.is_windows_path(mapping.local_root):
                     return pathlib.PureWindowsPath(mapping.local_root, relative_path)
-                else:
-                    return pathlib.PurePath(mapping.local_root, relative_path)
+
+                return pathlib.PurePath(mapping.local_root, relative_path)
 
         return path
 
@@ -961,8 +961,8 @@ def get_stack_trace(
         def source_from_entry(entry: StackFrameEntry) -> Optional[Source]:
             if entry.source is not None and entry.is_file:
                 return Source(path=str(self.map_path_to_client(entry.source)))
-            else:
-                return None
+
+            return None
 
         def yield_stack() -> Iterator[StackFrame]:
             for i, v in enumerate(itertools.islice(self.stack_frames, start_frame, levels)):

robotcode/debugger/launcher/server.py

@@ -314,7 +314,7 @@ async def _disconnect(self, arguments: Optional[DisconnectArguments] = None, *ar
     @rpc_method(name="terminate", param_type=TerminateArguments)
     async def _terminate(self, arguments: Optional[TerminateArguments] = None, *args: Any, **kwargs: Any) -> None:
         if self.client.connected:
-            return await self.client.protocol.send_request_async(TerminateRequest(arguments=arguments))
+            await self.client.protocol.send_request_async(TerminateRequest(arguments=arguments))
         else:
             self.send_event(Event("terminateRequested"))
             await self.send_event_async(TerminatedEvent())

robotcode/debugger/protocol.py

@@ -123,7 +123,7 @@ def _generate_json_rpc_messages_from_dict(
         def inner(d: Dict[Any, Any]) -> ProtocolMessage:
             result = from_dict(d, (Request, Response, Event))
             if isinstance(result, Response) and not result.success:
-                result = from_dict(d, ErrorResponse)
+                return from_dict(d, ErrorResponse)
             return result
 
         if isinstance(data, list):
@@ -174,8 +174,8 @@ def _convert_params(
         if param_type is None:
             if isinstance(params, Mapping):
                 return [], dict(**params)
-            else:
-                return [params], {}
+
+            return [params], {}
 
         converted_params = from_dict(params, param_type)
 

robotcode/jsonrpc2/protocol.py

@@ -645,8 +645,8 @@ def _convert_params(
         if params_type is None:
             if isinstance(params, Mapping):
                 return [], dict(**params)
-            else:
-                return [params], {}
+
+            return [params], {}
 
         # try to convert the dict to correct type
         converted_params = from_dict(params, params_type)
@@ -701,7 +701,7 @@ async def handle_request(self, message: JsonRPCRequest) -> None:
                 f"Unknown method: {message.method}",
                 id=message.id,
             )
-            return None
+            return
 
         params = self._convert_params(e.method, e.param_type, message.params)
 

robotcode/language_server/common/parts/completion.py

@@ -116,12 +116,12 @@ async def _text_document_completion(
                 if len(result.items) == 0:
                     return None
                 return result
-            else:
-                result = list(chain(*[k for k in results if isinstance(k, list)]))
-                if len(result) == 0:
-                    return None
 
-                return result
+            result = list(chain(*[k for k in results if isinstance(k, list)]))
+            if len(result) == 0:
+                return None
+
+            return result
 
         return None
 

robotcode/language_server/common/parts/declaration.py

@@ -82,8 +82,8 @@ async def _text_document_declaration(
         if len(locations) > 0 and len(location_links) == 0:
             if len(locations) == 1:
                 return locations[0]
-            else:
-                return locations
+
+            return locations
 
         if len(locations) > 0 and len(location_links) > 0:
             self._logger.warning("can't mix Locations and LocationLinks")

robotcode/language_server/common/parts/definition.py

@@ -82,8 +82,8 @@ async def _text_document_definition(
         if len(locations) > 0 and len(location_links) == 0:
             if len(locations) == 1:
                 return locations[0]
-            else:
-                return locations
+
+            return locations
 
         if len(locations) > 0 and len(location_links) > 0:
             self._logger.warning("can't mix Locations and LocationLinks")

robotcode/language_server/common/parts/diagnostics.py

@@ -449,25 +449,26 @@ async def _get_diagnostics_for_document(
                 if isinstance(result_any, BaseException):
                     if not isinstance(result_any, asyncio.CancelledError):
                         self._logger.exception(result_any, exc_info=result_any)
-                elif result_any is None:
                     continue
-                else:
-                    result = cast(DiagnosticsResult, result_any)
-
-                    data.id = str(uuid.uuid4())
-                    data.entries[result.key] = result.diagnostics
-                    if result.diagnostics is not None:
-                        collected_keys.append(result.key)
-
-                    if data.entries and send_diagnostics:
-                        self.parent.send_notification(
-                            "textDocument/publishDiagnostics",
-                            PublishDiagnosticsParams(
-                                uri=document.document_uri,
-                                version=document._version,
-                                diagnostics=list(itertools.chain(*(i for i in data.entries.values() if i is not None))),
-                            ),
-                        )
+                if result_any is None:
+                    continue
+
+                result = cast(DiagnosticsResult, result_any)
+
+                data.id = str(uuid.uuid4())
+                data.entries[result.key] = result.diagnostics
+                if result.diagnostics is not None:
+                    collected_keys.append(result.key)
+
+                if data.entries and send_diagnostics:
+                    self.parent.send_notification(
+                        "textDocument/publishDiagnostics",
+                        PublishDiagnosticsParams(
+                            uri=document.document_uri,
+                            version=document._version,
+                            diagnostics=list(itertools.chain(*(i for i in data.entries.values() if i is not None))),
+                        ),
+                    )
 
         except asyncio.CancelledError:
             self._logger.debug(lambda: f"_get_diagnostics cancelled for {document}")

robotcode/language_server/common/parts/implementation.py

@@ -87,8 +87,8 @@ async def _text_document_implementation(
         if len(locations) > 0 and len(location_links) == 0:
             if len(locations) == 1:
                 return locations[0]
-            else:
-                return locations
+
+            return locations
 
         if len(locations) > 0 and len(location_links) > 0:
             self._logger.warning("can't mix Locations and LocationLinks")