fixed stub_gen.py

Author: Snooz82

Browser/__init__.py

@@ -1,6 +1,5 @@
-import re
 import os
-
+import re
 from concurrent.futures import ThreadPoolExecutor, Future
 from typing import Set
 
@@ -19,6 +18,18 @@
 )
 from .playwright import Playwright
 from .utils import logger
+from .utils.data_types import (
+    TypedDict,
+    AssertionOperator,
+    ElementState,
+    ColorScheme,
+    ViewportDimensions,
+    SupportedBrowsers,
+    SelectAttribute,
+    KeyboardModifier,
+    MouseButton,
+    RequestMethod,
+)
 from .version import VERSION
 
 __version__ = VERSION

Browser/assertion_engine.py

@@ -1,49 +1,20 @@
-from enum import Enum
+import re
 from typing import (
     Any,
+    cast,
+    Callable,
     Dict,
+    List,
+    Optional,
     Tuple,
-    Callable,
     TypeVar,
-    cast,
-    Optional,
-    List,
 )
-import re
 
 from robot.libraries.BuiltIn import BuiltIn  # type: ignore
 
+from .utils.data_types import AssertionOperator
 from .utils.robot_booleans import is_truthy
 
-AssertionOperator = Enum(
-    "AssertionOperator",
-    {
-        "equal": "==",
-        "==": "==",
-        "shouldbe": "==",
-        "inequal": "!=",
-        "!=": "!=",
-        "shouldnotbe": "!=",
-        "lessthan": "<",
-        "<": "<",
-        "greaterthan": ">",
-        ">": ">",
-        "<=": "<=",
-        ">=": ">=",
-        "contains": "*=",
-        "*=": "*=",
-        "starts": "^=",
-        "^=": "^=",
-        "shouldstartwith": "^=",
-        "ends": "$=",
-        "$=": "$=",
-        "matches": "$",
-        "validate": "validate",
-        "then": "then",
-        "evaluate": "then",
-    },
-)
-
 NumericalOperators = [
     AssertionOperator["=="],
     AssertionOperator["!="],
@@ -83,7 +54,6 @@
     ),
 }
 
-
 T = TypeVar("T")
 
 

Browser/gen_stub.py

@@ -2,73 +2,93 @@
 import inspect
 from typing import Any
 
-br: Any = Browser.Browser()
-keywords = br.get_keyword_names()
-function_list = list()
-for keyword in keywords:
-    keyword_name = keyword
-    if " " in keyword:
+
+def is_named_method(keyword_name: str) -> bool:
+    keyword_attribute = br.attributes[keyword_name]
+    return (
+        keyword_attribute.robot_name is not None
+        and keyword_attribute.robot_name == keyword_name
+    )
+
+
+def get_method_name_for_keyword(keyword_name: str) -> str:
+    if is_named_method(keyword_name):
         for key in br.attributes.keys():
-            if keyword == br.attributes[key].robot_name and " " not in key:
-                keyword_name = key
-                break
-    args = br.get_keyword_arguments(keyword)
-    types = br.get_keyword_types(keyword)
-    args_str = ""
-    for arg in args:
-        if isinstance(arg, tuple):
-            arg_name = arg[0]
-            if arg_name[0] == "*":
-                tpe = types[arg_name[1:]]
-            else:
-                tpe = types[arg_name]
-            if hasattr(tpe, "__name__"):
-                arg_type = tpe.__name__
-            else:
-                arg_type = str(tpe.__repr__()).lstrip("typing.")
-            if arg[1] is None:
-                arg_type_str = f"Optional[{arg_type}]"
-            else:
-                arg_type_str = arg_type
-            if arg_type == "str":
-                arg_str = f"{arg_name}: {arg_type_str} = '{arg[1]}'"
-            else:
-                arg_str = f"{arg_name}: {arg_type_str} = {arg[1]}"
-        else:
-            if arg[0] == "*":
-                arg_name = arg[1:]
-            else:
-                arg_name = arg
-            if arg_name in types:
-                tpe = types[arg_name]
-                if hasattr(tpe, "__name__"):
-                    arg_type = tpe.__name__
-                else:
-                    arg_type = str(tpe.__repr__()).lstrip("typing.")
-                arg_str = f"{arg}: {arg_type}"
+            if key != keyword_name and keyword_name == br.attributes[key].robot_name:
+                return key
+    return keyword_name
+
+
+def get_type_string_from_type(argument_type: type) -> str:
+    if hasattr(argument_type, "__name__"):
+        return argument_type.__name__
+    else:
+        return str(argument_type.__repr__()).lstrip("typing.")
+
+
+def get_type_sting_from_argument(argument_string: str, argument_types: dict) -> str:
+    agrument_name = argument_string.lstrip("*")
+    if agrument_name in argument_types:
+        return get_type_string_from_type(argument_types[agrument_name])
+    return ""
+
+
+def get_function_list_from_keywords(keywords):
+    functions = list()
+    for keyword in keywords:
+        method_name = get_method_name_for_keyword(keyword)
+        keyword_arguments = br.get_keyword_arguments(keyword)
+        keyword_types = br.get_keyword_types(keyword)
+        arguments_list = list()
+        for argument in keyword_arguments:
+            if isinstance(argument, tuple):
+                arg_str = argument[0]
+                default_value = argument[1]
+                arg_type_str = get_type_sting_from_argument(arg_str, keyword_types)
+                if arg_type_str:
+                    if default_value is None:
+                        arg_type_str = f"Optional[{arg_type_str}]"
+                    if arg_type_str == "str":
+                        default_value = f"'{default_value}'"
+                    arg_str = arg_str + f": {arg_type_str}"
+                elif isinstance(default_value, str):
+                    default_value = f"'{default_value}'"
+                arg_str = arg_str + f" = {default_value}"
             else:
-                arg_str = f"{arg}"
+                arg_str = argument
+                arg_type_str = get_type_sting_from_argument(arg_str, keyword_types)
+                if arg_type_str:
+                    arg_str = arg_str + f": {arg_type_str}"
+            arguments_list.append(arg_str)
+        arguments_string = (
+            f", {', '.join(arguments_list)}" if len(arguments_list) > 0 else ""
+        )
+        functions.append(f"    def {method_name}(self{arguments_string}): ...\n")
+    functions.sort()
+    return functions
 
-        args_str = f"{args_str}, {arg_str}"
-    function_list.append(f"    def {keyword_name}(self{args_str}): ...\n")
 
-function_list.sort()
+br: Any = Browser.Browser()
+function_list = get_function_list_from_keywords(br.get_keyword_names())
+
 
 pyi_boilerplate = f"""from concurrent.futures import Future
-from typing import Union, Any, Dict, List, Optional
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+    Union,
+)
 
-from .assertion_engine import AssertionOperator
-from .keywords.input import SelectAttribute, MouseButton, KeyboardModifier
-from .keywords.playwright_state import SupportedBrowsers, ViewportDimensions, ColorScheme
-from .keywords.waiter import ElementState
-from .keywords.evaluation import RequestMethod
+from .utils.data_types import *
 
 
 class Browser:
 
     def __init__(self, {str(inspect.signature(br.__init__))[1:]}: ...\n
 """
 
-with open("Browser/__init__.pyi", "w") as stub_file:
+with open("__init__.pyi", "w") as stub_file:
     stub_file.write(pyi_boilerplate)
     stub_file.writelines(function_list)

Browser/keywords/evaluation.py

@@ -1,31 +1,22 @@
-from enum import Enum, auto
 import json
-from typing import Any, Optional
 
 from robotlibcore import keyword  # type: ignore
+from typing import Optional, Any
 
 from ..base import LibraryComponent
 from ..generated.playwright_pb2 import Request
 from ..utils import logger
-
-
-class RequestMethod(Enum):
-    HEAD = auto()
-    GET = auto()
-    POST = auto()
-    PUT = auto()
-    PATCH = auto()
-    DELETE = auto()
+from ..utils.data_types import RequestMethod
 
 
 class Evaluation(LibraryComponent):
     @keyword(tags=["HTTP", "BrowserControl"])
     def http(
         self,
-        url,
+        url: str,
         method: RequestMethod = RequestMethod.GET,
         body: Optional[str] = None,
-        headers: dict = {},
+        headers: Optional[dict] = None,
     ):
         """Performs an HTTP request in the current browser context
 
@@ -52,6 +43,8 @@ def http(
         | Should Be Equal  |  ${res.body.some_field}  |  some value  |
 
         """
+        if headers is None:
+            headers = {}
         body = body if body else ""
         with self.playwright.grpc_channel() as stub:
             response = stub.HttpRequest(
@@ -65,14 +58,14 @@ def http(
             logger.debug(response.log)
             return self._format_response(json.loads(response.body))
 
-    def _get_headers(self, body, headers):
+    def _get_headers(self, body: str, headers: dict):
         try:
             json.loads(body)
             return {"Content-Type": "application/json", **headers}
         except json.decoder.JSONDecodeError:
             return headers
 
-    def _format_response(self, response):
+    def _format_response(self, response: dict):
         headers = json.loads(response["headers"])
         response["headers"] = headers
         if "content-type" in headers and "application/json" in headers["content-type"]:

Browser/keywords/getters.py

@@ -1,21 +1,26 @@
 import json
-from typing import Any, Dict, Optional, Union, List
+from typing import (
+    Any,
+    Dict,
+    List,
+    Optional,
+    Union,
+)
 
 from robotlibcore import keyword  # type: ignore
 
-from ..base import LibraryComponent
-from ..generated.playwright_pb2 import Request
 from ..assertion_engine import (
     bool_verify_assertion,
     verify_assertion,
     list_verify_assertion,
     dict_verify_assertion,
     int_dict_verify_assertion,
     int_str_verify_assertion,
-    AssertionOperator,
 )
-from .input import SelectAttribute
-from Browser.utils import logger
+from ..base import LibraryComponent
+from ..generated.playwright_pb2 import Request
+from ..utils import logger
+from ..utils.data_types import AssertionOperator, SelectAttribute
 
 
 class Getters(LibraryComponent):

Browser/keywords/input.py

@@ -1,33 +1,16 @@
 import json
-from enum import Enum, auto
+from typing import (
+    Dict,
+    Optional,
+)
 
 from robotlibcore import keyword  # type: ignore
-from typing import Optional, Dict
 
 from ..base import LibraryComponent
 from ..generated.playwright_pb2 import Request
-from ..utils.time_conversion import timestr_to_millisecs
 from ..utils import logger
-
-
-class MouseButton(Enum):
-    left = auto()
-    middle = auto()
-    right = auto()
-
-
-class KeyboardModifier(Enum):
-    Alt = auto()
-    Control = auto()
-    Meta = auto()
-    Shift = auto()
-
-
-class SelectAttribute(Enum):
-    value = auto()
-    label = auto()
-    text = label
-    index = auto()
+from ..utils.data_types import MouseButton, KeyboardModifier, SelectAttribute
+from ..utils.time_conversion import timestr_to_millisecs
 
 
 class Input(LibraryComponent):