some more code cleanup, simplifications, refactorings

Author: d-biehl

robotcode/language_server/robotframework/diagnostics/library_doc.py

@@ -312,18 +312,7 @@ def get_full_doc(self, add_signature: bool = True, header_level: int = 0) -> str
             result = ""
 
             if add_signature:
-                result += (
-                    f"\n\n={'='*header_level} "
-                    f"{'Library' if self.is_initializer else 'Keyword'} *{self.name}* "
-                    f"={'='*header_level}\n"
-                )
-                if self.args:
-                    result += f"\n=={'='*header_level} Arguments: =={'='*header_level}\n"
-                    for a in self.args:
-                        result += f"\n| {str(a)}"
-
-            else:
-                result = ""
+                result += self._get_signature(header_level)
 
             if self.doc:
                 if result:
@@ -337,6 +326,19 @@ def get_full_doc(self, add_signature: bool = True, header_level: int = 0) -> str
 
         return self.doc
 
+    def _get_signature(self, header_level: int) -> str:
+        result = (
+            f"\n\n={'='*header_level} "
+            f"{'Library' if self.is_initializer else 'Keyword'} *{self.name}* "
+            f"={'='*header_level}\n"
+        )
+        if self.args:
+            result += f"\n=={'='*header_level} Arguments: =={'='*header_level}\n"
+            for a in self.args:
+                result += f"\n| {str(a)}"
+
+        return result
+
     @property
     def signature(self) -> str:
         return f"({self.type}) \"{self.name}\": ({', '.join(str(a) for a in self.args)})"
@@ -539,42 +541,45 @@ def get_full_doc(self, only_doc: bool = True) -> str:
             else:
                 doc = self.doc
 
-            if self.doc:
-                result += "\n== Introduction ==\n\n"
-
             if doc:
+                result += "\n== Introduction ==\n\n"
                 result += doc
 
             if not only_doc:
-                if any(v for v in self.inits.values() if v.args):
-                    result += "\n---\n\n"
-                    result += "\n== Importing == \n\n"
+                result += self._get_doc_for_keywords()
 
-                    first = True
+            return self._process_inline_links(result)
 
-                    for kw in self.inits.values():
-                        if not first:
-                            result += "\n---\n"
-                        first = False
+        return self.doc
 
-                        result += "\n" + kw.get_full_doc()
+    def _get_doc_for_keywords(self) -> str:
+        result = ""
+        if any(v for v in self.inits.values() if v.args):
+            result += "\n---\n\n"
+            result += "\n== Importing == \n\n"
 
-                if self.keywords:
-                    result += "\n---\n\n"
-                    result += "\n== Keywords == \n\n"
+            first = True
 
-                    first = True
+            for kw in self.inits.values():
+                if not first:
+                    result += "\n---\n"
+                first = False
 
-                    for kw in self.keywords.values():
-                        if not first:
-                            result += "\n---\n"
-                        first = False
+                result += "\n" + kw.get_full_doc()
 
-                        result += "\n" + kw.get_full_doc(header_level=2)
+        if self.keywords:
+            result += "\n---\n\n"
+            result += "\n== Keywords == \n\n"
 
-            return self._process_inline_links(result)
+            first = True
 
-        return self.doc
+            for kw in self.keywords.values():
+                if not first:
+                    result += "\n---\n"
+                first = False
+
+                result += "\n" + kw.get_full_doc(header_level=2)
+        return result
 
     def _add_toc(self, doc: str, only_doc: bool = True) -> str:
         toc = self._create_toc(doc, only_doc)
@@ -606,23 +611,7 @@ def _update_env(
 ) -> None:
     import gc
 
-    global __PRELOADED_MODULES
-
-    if __PRELOADED_MODULES is None:
-        try:
-            __import__("robot.libraries.BuiltIn")
-        except ImportError:
-            pass
-
-        __PRELOADED_MODULES = set(sys.modules.values())
-    else:
-        for m in (f for f in set(sys.modules.values()) - __PRELOADED_MODULES if not f.__name__.startswith("robot.")):
-            try:
-                importlib.reload(m)
-            except (SystemExit, KeyboardInterrupt):
-                raise
-            except BaseException:
-                pass
+    unload_preloaded_modules()
 
     file = Path(__file__).resolve()
     top = file.parents[3]
@@ -647,6 +636,26 @@ def _update_env(
             os.environ[k] = v
 
 
+def unload_preloaded_modules() -> None:
+    global __PRELOADED_MODULES
+
+    if __PRELOADED_MODULES is None:
+        try:
+            __import__("robot.libraries.BuiltIn")
+        except ImportError:
+            pass
+
+        __PRELOADED_MODULES = set(sys.modules.values())
+    else:
+        for m in (f for f in set(sys.modules.values()) - __PRELOADED_MODULES if not f.__name__.startswith("robot.")):
+            try:
+                importlib.reload(m)
+            except (SystemExit, KeyboardInterrupt):
+                raise
+            except BaseException:
+                pass
+
+
 def get_module_spec(module_name: str) -> Optional[ModuleSpec]:
     import importlib.util
 

robotcode/language_server/robotframework/diagnostics/namespace.py

@@ -10,7 +10,7 @@
 from pathlib import Path
 from typing import (
     Any,
-    AsyncIterator,
+    AsyncGenerator,
     Callable,
     Dict,
     Iterable,
@@ -1216,7 +1216,7 @@ async def _get_keyword_from_self(self, name: str) -> Optional[KeywordDoc]:
             self.self_library_doc = await self.namespace.get_library_doc()
         return self.self_library_doc.keywords.get(name, None)
 
-    async def _yield_owner_and_kw_names(self, full_name: str) -> AsyncIterator[Tuple[str, ...]]:
+    async def _yield_owner_and_kw_names(self, full_name: str) -> AsyncGenerator[Tuple[str, ...], None]:
         tokens = full_name.split(".")
         for i in range(1, len(tokens)):
             yield ".".join(tokens[:i]), ".".join(tokens[i:])

robotcode/language_server/robotframework/parts/completion.py

@@ -9,6 +9,7 @@
 from typing import (
     TYPE_CHECKING,
     Any,
+    AsyncGenerator,
     AsyncIterator,
     Awaitable,
     Callable,
@@ -158,7 +159,7 @@ async def get_section_style(self) -> str:
 
         return self._section_style or DEFAULT_SECTIONS_STYLE
 
-    async def _find_methods(self, cls: Type[Any]) -> AsyncIterator[_CompleteMethod]:
+    async def _find_methods(self, cls: Type[Any]) -> AsyncGenerator[_CompleteMethod, None]:
         if cls is ast.AST:
             return
 

robotcode/language_server/robotframework/utils/ast.py

@@ -15,7 +15,7 @@
 )
 
 from ...common.lsp_types import Position, Range
-from .async_ast import walk
+from . import async_ast
 
 
 def iter_nodes(node: ast.AST) -> Generator[ast.AST, None, None]:
@@ -176,7 +176,11 @@ def get_tokens_at_position(node: HasTokens, position: Position) -> List[Token]:
 
 
 def iter_nodes_at_position(node: ast.AST, position: Position) -> AsyncIterator[ast.AST]:
-    return (n async for n in walk(node) if position.is_in_range(range := range_from_node(n)) or range.end == position)
+    return (
+        n
+        async for n in async_ast.iter_nodes(node)
+        if position.is_in_range(range := range_from_node(n)) or range.end == position
+    )
 
 
 async def get_nodes_at_position(node: ast.AST, position: Position) -> List[ast.AST]:

robotcode/utils/async_event.py

@@ -8,6 +8,7 @@
 from types import MethodType
 from typing import (
     Any,
+    AsyncGenerator,
     AsyncIterator,
     Awaitable,
     Callable,
@@ -94,10 +95,8 @@ def __iter__(self) -> Iterator[_TCallable]:
                 yield c
 
     async def __aiter__(self) -> AsyncIterator[_TCallable]:
-        for r in self._listeners:
-            c = r()
-            if c is not None:
-                yield c
+        for r in self.__iter__():
+            yield r
 
     async def _notify(
         self, *args: Any, callback_filter: Optional[Callable[[_TCallable], bool]] = None, **kwargs: Any
@@ -296,7 +295,7 @@ async def _notify(  # type: ignore
         return_exceptions: Optional[bool] = True,
         callback_filter: Optional[Callable[[_TCallable], bool]] = None,
         **kwargs: Any,
-    ) -> AsyncIterator[Union[_TResult, BaseException]]:
+    ) -> AsyncGenerator[Union[_TResult, BaseException], None]:
         def _done(f: asyncio.Future[_TResult]) -> None:
             if result_callback is not None:
                 try:

robotcode/utils/async_itertools.py

@@ -1,5 +1,6 @@
 import inspect
 from typing import (
+    AsyncGenerator,
     AsyncIterable,
     AsyncIterator,
     Awaitable,
@@ -10,13 +11,13 @@
     cast,
 )
 
-__all__ = ["async_chain", "async_chain_iterator"]
+__all__ = ["async_chain", "async_chain_iterator", "async_takewhile", "async_dropwhile"]
 
 _T = TypeVar("_T")
 AnyIterable = Union[Iterable[_T], AsyncIterable[_T]]
 
 
-async def async_chain(*iterables: AnyIterable[_T]) -> AsyncIterator[_T]:
+async def async_chain(*iterables: AnyIterable[_T]) -> AsyncGenerator[_T, None]:
     for iterable in iterables:
         if isinstance(iterable, AsyncIterable):
             async for v in iterable:
@@ -26,7 +27,9 @@ async def async_chain(*iterables: AnyIterable[_T]) -> AsyncIterator[_T]:
                 yield v
 
 
-async def async_chain_iterator(iterator: AsyncIterator[Union[Iterable[_T], AsyncIterable[_T]]]) -> AsyncIterator[_T]:
+async def async_chain_iterator(
+    iterator: AsyncIterator[Union[Iterable[_T], AsyncIterable[_T]]]
+) -> AsyncGenerator[_T, None]:
     async for e in iterator:
         async for v in async_chain(e):
             yield v
@@ -35,40 +38,42 @@ async def async_chain_iterator(iterator: AsyncIterator[Union[Iterable[_T], Async
 async def async_takewhile(
     predicate: Union[Callable[[_T], bool], Callable[[_T], Awaitable[bool]]],
     iterable: AnyIterable[_T],
-) -> AsyncIterator[_T]:
+) -> AsyncGenerator[_T, None]:
     if isinstance(iterable, AsyncIterable):
         async for e in iterable:
-            result = predicate(e)
-            if inspect.isawaitable(result):
-                result = await cast(Awaitable[bool], result)
+            result = await __call_predicate(predicate, e)
             if result:
                 yield e
             else:
                 break
     else:
         for e in iterable:
-            result = predicate(e)
-            if inspect.isawaitable(result):
-                result = await cast(Awaitable[bool], result)
+            result = await __call_predicate(predicate, e)
             if result:
                 yield e
             else:
                 break
 
 
+async def __call_predicate(predicate: Union[Callable[[_T], bool], Callable[[_T], Awaitable[bool]]], e: _T) -> bool:
+    result = predicate(e)
+    if inspect.isawaitable(result):
+        return await cast(Awaitable[bool], result)
+    return cast(bool, result)
+
+
 async def async_dropwhile(
     predicate: Union[Callable[[_T], bool], Callable[[_T], Awaitable[bool]]],
     iterable: AnyIterable[_T],
-) -> AsyncIterator[_T]:
+) -> AsyncGenerator[_T, None]:
     result: Union[bool, Awaitable[bool]] = True
+
     if isinstance(iterable, AsyncIterable):
         async for e in iterable:
             if not result:
                 yield e
             else:
-                result = predicate(e)
-                if inspect.isawaitable(result):
-                    result = await cast(Awaitable[bool], result)
+                result = await __call_predicate(predicate, e)
 
                 if not result:
                     yield e
@@ -77,9 +82,7 @@ async def async_dropwhile(
             if not result:
                 yield e
             else:
-                result = predicate(e)
-                if inspect.isawaitable(result):
-                    result = await cast(Awaitable[bool], result)
+                result = await __call_predicate(predicate, e)
 
                 if not result:
                     yield e