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})")
