do not refresh diagnoses so often

Author: d-biehl

robotcode/language_server/common/parts/diagnostics.py

@@ -132,6 +132,8 @@ def __init__(self, protocol: LanguageServerProtocol) -> None:
 
         self.in_get_workspace_diagnostics = Event(True)
 
+        self.refresh_task: Optional[asyncio.Task[Any]] = None
+
     async def initialized(self, sender: Any) -> None:
         self._ensure_diagnostics_thread_started()
 
@@ -490,7 +492,19 @@ async def get_diagnostics_mode(self, uri: Uri) -> DiagnosticsMode:
 
         return DiagnosticsMode.OPENFILESONLY
 
-    async def refresh(self) -> None:
+    async def __do_refresh(self, now: bool = False) -> None:
+        if not now:
+            await asyncio.sleep(1)
+
+        await self.__refresh()
+
+    async def refresh(self, now: bool = False) -> None:
+        if self.refresh_task is not None and not self.refresh_task.done():
+            self.refresh_task.get_loop().call_soon_threadsafe(self.refresh_task.cancel)
+
+        self.refresh_task = create_sub_task(self.__do_refresh(now), loop=self.diagnostics_loop)
+
+    async def __refresh(self) -> None:
         if (
             self.parent.client_capabilities
             and self.parent.client_capabilities.workspace

robotcode/language_server/robotframework/utils/version.py

@@ -26,7 +26,7 @@ def get_robot_version() -> Version:
     if _robot_version is None:
         import robot
 
-        return create_version_from_str(robot.get_version())
+        _robot_version = create_version_from_str(robot.get_version())
     return _robot_version
 
 

robotcode/utils/async_tools.py

@@ -322,7 +322,7 @@ async def create_inner_task(coro: Callable[..., Coroutine[Any, Any, _T]], *args:
         if ct is not None and result is not None:
             _running_tasks[result].children.add(ct)
 
-        inner_task = create_sub_task(coro(*args, **kwargs))
+        inner_task = create_sub_task(coro(*args, **kwargs), name=coro.__qualname__)
 
         if canceled:
             inner_task.cancel()
@@ -406,7 +406,8 @@ def set_result(w: asyncio.Future[Any], ev: threading.Event) -> None:
                                     check_canceled_sync()
 
                                     if time.monotonic() - start > 120:
-                                        raise TimeoutError("Can't set future result.")
+                                        warnings.warn("Can't set future result.")
+                                        break
 
                                     time.sleep(0.001)
 
@@ -479,6 +480,7 @@ async def acquire(self) -> bool:
             self._waiters.append(fut)
 
         try:
+            # await asyncio.wait_for(fut, 120)
             await fut
         finally:
             async with self.__inner_lock():
@@ -530,7 +532,8 @@ def set_result(w: asyncio.Future[Any], ev: threading.Event) -> None:
                     while not done.is_set():
 
                         if time.monotonic() - start > 120:
-                            raise TimeoutError("Can't set future result.")
+                            warnings.warn("Can't set future result.")
+                            break
 
                         await asyncio.sleep(0.001)
         else: