def generate(t: Any) -> None: print("") class_name = short_name(t) base_class = t.__bases__[0].__name__ base_sync_class = ("SyncBase" if base_class == "ChannelOwner" or base_class == "object" else base_class) print(f"class {class_name}({base_sync_class}):") print("") print(f" def __init__(self, obj: {class_name}Impl):") print(" super().__init__(obj)") for [name, type] in get_type_hints(t, api_globals).items(): print("") print(" @property") print(f" def {name}(self) -> {process_type(type)}:") documentation_provider.print_entry(class_name, name, {"return": type}) [prefix, suffix] = return_value(type) prefix = " return " + prefix + f"self._impl_obj.{name}" print(f"{prefix}{suffix}") for [name, value] in t.__dict__.items(): if name.startswith("_"): continue if not name.startswith("_") and str(value).startswith("<property"): value = value.fget print("") print(" @property") print( f" def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:" ) documentation_provider.print_entry( class_name, name, get_type_hints(value, api_globals)) [prefix, suffix ] = return_value(get_type_hints(value, api_globals)["return"]) prefix = " return " + prefix + f"self._impl_obj.{name}" print(f"{prefix}{arguments(value, len(prefix))}{suffix}") for [name, value] in t.__dict__.items(): if (not name.startswith("_") and isinstance(value, FunctionType) and "expect_" not in name): print("") print( f" def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:" ) documentation_provider.print_entry( class_name, name, get_type_hints(value, api_globals)) [prefix, suffix ] = return_value(get_type_hints(value, api_globals)["return"]) if inspect.iscoroutinefunction(value): prefix = (" return " + prefix + f"self._sync(self._impl_obj.{name}(") suffix = "))" + suffix else: prefix = " return " + prefix + f"self._impl_obj.{name}(" suffix = ")" + suffix print(f"{prefix}{arguments(value, len(prefix))}{suffix}") if "expect_" in name: print("") return_type_value = return_type(value) return_type_value = re.sub(r"\"([^\"]+)Impl\"", r"\1", return_type_value) event_name = re.sub(r"expect_(.*)", r"\1", name) event_name = re.sub(r"_", "", event_name) event_name = re.sub(r"consolemessage", "console", event_name) print( f" def {name}({signature(value, len(name) + 9)}) -> {return_type_value}:" ) wait_for_method = "waitForEvent(event, predicate, timeout)" if event_name == "request": wait_for_method = "waitForRequest(url, predicate, timeout)" elif event_name == "response": wait_for_method = "waitForResponse(url, predicate, timeout)" elif event_name == "loadstate": wait_for_method = "waitForLoadState(state, timeout)" elif event_name == "navigation": wait_for_method = "waitForNavigation(url, waitUntil, timeout)" elif event_name != "event": print(f' event = "{event_name}"') print( f" return EventContextManager(self._loop, self._impl_obj.{wait_for_method})" ) print("") print(f"mapping.register({class_name}Impl, {class_name})")
def generate(t: Any) -> None: print("") class_name = short_name(t) base_class = t.__bases__[0].__name__ base_sync_class = ("SyncBase" if base_class == "ChannelOwner" or base_class == "object" else base_class) print(f"class {class_name}({base_sync_class}):") print("") print(f" def __init__(self, obj: {class_name}Impl):") print(" super().__init__(obj)") for [name, type] in get_type_hints(t, api_globals).items(): print("") print(" @property") print(f" def {name}(self) -> {process_type(type)}:") documentation_provider.print_entry(class_name, name, {"return": type}) [prefix, suffix] = return_value(type) prefix = " return " + prefix + f"self._impl_obj.{name}" print(f"{prefix}{suffix}") for [name, value] in t.__dict__.items(): if name.startswith("_"): continue if not name.startswith("_") and str(value).startswith("<property"): value = value.fget print("") print(" @property") print( f" def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:" ) documentation_provider.print_entry( class_name, name, get_type_hints(value, api_globals)) [prefix, suffix ] = return_value(get_type_hints(value, api_globals)["return"]) prefix = " return " + prefix + f"self._impl_obj.{name}" print(f"{prefix}{arguments(value, len(prefix))}{suffix}") for [name, value] in t.__dict__.items(): if name in ["expect_dialog"]: continue if (not name.startswith("_") and isinstance(value, FunctionType) and "expect_" not in name and "remove_listener" != name): is_async = inspect.iscoroutinefunction(value) print("") print( f" def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:" ) documentation_provider.print_entry( class_name, name, get_type_hints(value, api_globals)) [prefix, suffix ] = return_value(get_type_hints(value, api_globals)["return"]) if is_async: prefix = prefix + f"self._sync(self._impl_obj.{name}(" suffix = "))" + suffix else: prefix = prefix + f"self._impl_obj.{name}(" suffix = ")" + suffix print(f""" try: log_api("=> {to_snake_case(class_name)}.{name} started") result = {prefix}{arguments(value, len(prefix))}{suffix} log_api("<= {to_snake_case(class_name)}.{name} succeded") return result except Exception as e: log_api("<= {to_snake_case(class_name)}.{name} failed") raise e""") if "expect_" in name: print("") return_type_value = return_type(value) return_type_value = re.sub(r"\"([^\"]+)Impl\"", r"\1", return_type_value) event_name = re.sub(r"expect_(.*)", r"\1", name) event_name = re.sub(r"_", "", event_name) event_name = re.sub(r"consolemessage", "console", event_name) print( f""" def {name}({signature(value, len(name) + 9)}) -> {return_type_value}: \"\"\"{class_name}.{name} Returns context manager that waits for ``event`` to fire upon exit. It passes event's value into the ``predicate`` function and waits for the predicate to return a truthy value. Will throw an error if the page is closed before the ``event`` is fired. with page.expect_{event_name}() as event_info: page.click("button") value = event_info.value Parameters ---------- predicate : Optional[typing.Callable[[Any], bool]] Predicate receiving event data. timeout : Optional[int] Maximum wait time in milliseconds, defaults to 30 seconds, pass `0` to disable the timeout. The default value can be changed by using the browserContext.set_default_timeout(timeout) or page.set_default_timeout(timeout) methods. \"\"\"""") wait_for_method = "wait_for_event(event, predicate, timeout)" if event_name == "request": wait_for_method = "wait_for_request(url_or_predicate, timeout)" elif event_name == "response": wait_for_method = "wait_for_response(url_or_predicate, timeout)" elif event_name == "loadstate": wait_for_method = "wait_for_load_state(state, timeout)" elif event_name == "navigation": wait_for_method = "wait_for_navigation(url, wait_until, timeout)" elif event_name != "event": print(f' event = "{event_name}"') print( f" return EventContextManager(self, self._impl_obj.{wait_for_method})" ) print("") print(f"mapping.register({class_name}Impl, {class_name})")
def generate(t: Any) -> None: print("") class_name = short_name(t) base_class = t.__bases__[0].__name__ base_sync_class = ("AsyncBase" if base_class == "ChannelOwner" or base_class == "object" else base_class) print(f"class {class_name}({base_sync_class}):") print("") print(f" def __init__(self, obj: {class_name}Impl):") print(" super().__init__(obj)") for [name, type] in get_type_hints(t, api_globals).items(): print("") print(" @property") print(f" def {name}(self) -> {process_type(type)}:") documentation_provider.print_entry(class_name, name, {"return": type}, True) [prefix, suffix] = return_value(type) prefix = " return " + prefix + f"self._impl_obj.{name}" print(f"{prefix}{suffix}") for [name, value] in t.__dict__.items(): if name.startswith("_"): continue if not name.startswith("_") and str(value).startswith("<property"): value = value.fget print("") print(" @property") print( f" def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:" ) documentation_provider.print_entry( class_name, name, get_type_hints(value, api_globals), True) [prefix, suffix ] = return_value(get_type_hints(value, api_globals)["return"]) prefix = " return " + prefix + f"self._impl_obj.{name}" print(f"{prefix}{arguments(value, len(prefix))}{suffix}") for [name, value] in t.__dict__.items(): if (not name.startswith("_") and isinstance(value, FunctionType) and "remove_listener" != name): is_async = inspect.iscoroutinefunction(value) return_type_value = return_type(value) return_type_value = re.sub(r"\"([^\"]+)Impl\"", r"\1", return_type_value) return_type_value = return_type_value.replace( "EventContextManager", "AsyncEventContextManager") print("") async_prefix = "async " if is_async else "" await_prefix = "await " if is_async else "" print( f" {async_prefix}def {name}({signature(value, len(name) + 9)}) -> {return_type_value}:" ) documentation_provider.print_entry( class_name, name, get_type_hints(value, api_globals)) if "expect_" in name: print("") print( f" return AsyncEventContextManager(self._impl_obj.{name}({arguments(value, 12)}).future)" ) else: [prefix, suffix] = return_value( get_type_hints(value, api_globals)["return"]) prefix = prefix + f"{await_prefix}self._impl_obj.{name}(" suffix = ")" + suffix print(f""" try: log_api("=> {to_snake_case(class_name)}.{name} started") result = {prefix}{arguments(value, len(prefix))}{suffix} log_api("<= {to_snake_case(class_name)}.{name} succeded") return result except Exception as e: log_api("<= {to_snake_case(class_name)}.{name} failed") raise e""") print("") print(f"mapping.register({class_name}Impl, {class_name})")
def generate(t: Any) -> None: print("") class_name = short_name(t) base_class = t.__bases__[0].__name__ if class_name in ["Page", "BrowserContext", "Browser"]: base_sync_class = "AsyncContextManager" elif base_class in ["ChannelOwner", "object", "AssertionsBase"]: base_sync_class = "AsyncBase" else: base_sync_class = base_class print(f"class {class_name}({base_sync_class}):") print("") documentation_provider.print_events(class_name) for [name, type] in get_type_hints(t, api_globals).items(): print("") print(" @property") print(f" def {name}(self) -> {process_type(type)}:") documentation_provider.print_entry(class_name, name, {"return": type}, True) [prefix, suffix] = return_value(type) prefix = " return " + prefix + f"self._impl_obj.{name}" print(f"{prefix}{suffix}") for [name, value] in t.__dict__.items(): if name.startswith("_"): continue if str(value).startswith("<property"): value = value.fget print("") print(" @property") print( f" def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:" ) documentation_provider.print_entry( class_name, name, get_type_hints(value, api_globals), True) [prefix, suffix ] = return_value(get_type_hints(value, api_globals)["return"]) prefix = " return " + prefix + f"self._impl_obj.{name}" print(f"{prefix}{arguments(value, len(prefix))}{suffix}") for [name, value] in t.__dict__.items(): if isinstance(value, FunctionType) and "remove_listener" != name: # List of dunder methods to allow without docs allow_without_docs_methods = [ "__getitem__", ] if name.startswith("_") and name not in allow_without_docs_methods: continue is_async = inspect.iscoroutinefunction(value) return_type_value = return_type(value) return_type_value = re.sub(r"\"([^\"]+)Impl\"", r"\1", return_type_value) return_type_value = return_type_value.replace( "EventContextManager", "AsyncEventContextManager") print("") async_prefix = "async " if is_async else "" print( f" {async_prefix}def {name}({signature(value, len(name) + 9)}) -> {return_type_value}:" ) # Allow dunder methods without docs if name not in allow_without_docs_methods: documentation_provider.print_entry( class_name, name, get_type_hints(value, api_globals)) if class_name in [ "LocatorAssertions", "PageAssertions", "APIResponseAssertions", ]: print(" __tracebackhide__ = True") if "expect_" in name: print("") print( f" return AsyncEventContextManager(self._impl_obj.{name}({arguments(value, 12)}).future)" ) else: [prefix, suffix] = return_value( get_type_hints(value, api_globals)["return"]) if is_async: prefix += "await " prefix = prefix + f"self._impl_obj.{name}(" suffix = ")" + suffix print(f""" return {prefix}{arguments(value, len(prefix))}{suffix}""") print("") print(f"mapping.register({class_name}Impl, {class_name})")
def generate(t: Any) -> None: print("") class_name = short_name(t) base_class = t.__bases__[0].__name__ if class_name in ["Page", "BrowserContext", "Browser"]: base_sync_class = "AsyncContextManager" elif base_class in ["ChannelOwner", "object"]: base_sync_class = "AsyncBase" else: base_sync_class = base_class print(f"class {class_name}({base_sync_class}):") print("") print(f" def __init__(self, obj: {class_name}Impl):") print(" super().__init__(obj)") for [name, type] in get_type_hints(t, api_globals).items(): print("") print(" @property") print(f" def {name}(self) -> {process_type(type)}:") documentation_provider.print_entry(class_name, name, {"return": type}, True) [prefix, suffix] = return_value(type) prefix = " return " + prefix + f"self._impl_obj.{name}" print(f"{prefix}{suffix}") for [name, value] in t.__dict__.items(): if name.startswith("_"): continue if str(value).startswith("<property"): value = value.fget print("") print(" @property") print( f" def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:" ) documentation_provider.print_entry( class_name, name, get_type_hints(value, api_globals), True ) [prefix, suffix] = return_value( get_type_hints(value, api_globals)["return"] ) prefix = " return " + prefix + f"self._impl_obj.{name}" print(f"{prefix}{arguments(value, len(prefix))}{suffix}") for [name, value] in t.__dict__.items(): if ( not name.startswith("_") and isinstance(value, FunctionType) and "remove_listener" != name ): is_async = inspect.iscoroutinefunction(value) return_type_value = return_type(value) return_type_value = re.sub(r"\"([^\"]+)Impl\"", r"\1", return_type_value) return_type_value = return_type_value.replace( "EventContextManager", "AsyncEventContextManager" ) print("") async_prefix = "async " if is_async else "" print( f" {async_prefix}def {name}({signature(value, len(name) + 9)}) -> {return_type_value}:" ) documentation_provider.print_entry( class_name, name, get_type_hints(value, api_globals) ) if "expect_" in name: print("") print( f" return AsyncEventContextManager(self._impl_obj.{name}({arguments(value, 12)}).future)" ) else: [prefix, suffix] = return_value( get_type_hints(value, api_globals)["return"] ) if is_async: prefix += ( f'await self._async("{to_snake_case(class_name)}.{name}", ' ) suffix += ")" prefix = prefix + f"self._impl_obj.{name}(" suffix = ")" + suffix print( f""" return {prefix}{arguments(value, len(prefix))}{suffix}""" ) if class_name == "Playwright": print( """ def __getitem__(self, value: str) -> "BrowserType": if value == "chromium": return self.chromium elif value == "firefox": return self.firefox elif value == "webkit": return self.webkit raise ValueError("Invalid browser "+value) """ ) print("") print(f"mapping.register({class_name}Impl, {class_name})")
def generate(t: Any) -> None: print("") class_name = short_name(t) base_class = t.__bases__[0].__name__ base_sync_class = ("AsyncBase" if base_class == "ChannelOwner" or base_class == "object" else base_class) print(f"class {class_name}({base_sync_class}):") print("") print(f" def __init__(self, obj: {class_name}Impl):") print(" super().__init__(obj)") for [name, type] in get_type_hints(t, api_globals).items(): print("") print(" @property") print(f" def {name}(self) -> {process_type(type)}:") documentation_provider.print_entry(class_name, name) [prefix, suffix] = return_value(type) prefix = " return " + prefix + f"self._impl_obj.{name}" print(f"{prefix}{suffix}") for [name, value] in t.__dict__.items(): if name.startswith("_"): continue if not name.startswith("_") and str(value).startswith("<property"): value = value.fget print("") print(" @property") print( f" def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:" ) documentation_provider.print_entry(class_name, name) [prefix, suffix ] = return_value(get_type_hints(value, api_globals)["return"]) prefix = " return " + prefix + f"self._impl_obj.{name}" print(f"{prefix}{arguments(value, len(prefix))}{suffix}") for [name, value] in t.__dict__.items(): if (not name.startswith("_") and isinstance(value, FunctionType) and "expect_" not in name): print("") if inspect.iscoroutinefunction(value): print( f" async def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:" ) documentation_provider.print_entry( class_name, name, get_type_hints(value, api_globals)) [prefix, suffix] = return_value( get_type_hints(value, api_globals)["return"]) prefix = " return " + prefix + f"await self._impl_obj.{name}(" suffix = ")" + suffix print(f"{prefix}{arguments(value, len(prefix))}{suffix}") else: print( f" def {name}({signature(value, len(name) + 9)}) -> {return_type(value)}:" ) documentation_provider.print_entry(class_name, name) [prefix, suffix] = return_value( get_type_hints(value, api_globals)["return"]) prefix = " return " + prefix + f"self._impl_obj.{name}(" suffix = ")" + suffix print(f"{prefix}{arguments(value, len(prefix))}{suffix}") if "expect_" in name and "expect_event" not in name: print("") return_type_value = return_type(value) return_type_value = re.sub(r"\"([^\"]+)Impl\"", r"\1", return_type_value) event_name = re.sub(r"expect_(.*)", r"\1", name) event_name = re.sub(r"_", "", event_name) event_name = re.sub(r"consolemessage", "console", event_name) print( f" def {name}({signature(value, len(name) + 9)}) -> Async{return_type_value}:" ) print( f' return AsyncEventContextManager(self, "{event_name}", predicate, timeout)' ) print("") print(f"mapping.register({class_name}Impl, {class_name})")