atomicshop 2.11.47__py3-none-any.whl → 3.10.5__py3-none-any.whl

atomicshop/wrappers/netshw.py

@@ -0,0 +1,271 @@
+import subprocess
+import re
+from typing import List, Dict, Any, Optional
+
+# ── regex helpers ─────────────────────────────────────────────────────────
+IP_PATTERN        = r'(?:\d{1,3}\.){3}\d{1,3}'
+RE_ADAPTER_HEADER = re.compile(r'Configuration for interface +"([^"]+)"', re.I)
+RE_NUMERIC        = re.compile(r'\d+')
+RE_SUBNET         = re.compile(rf'(?P<prefix>{IP_PATTERN}/\d+)\s+\(mask\s+(?P<mask>{IP_PATTERN})', re.I)
+RE_IP             = re.compile(IP_PATTERN)
+
+
+def get_netsh_show_config() -> str:
+    """Run `netsh interface ipv4 show config` and return the raw text."""
+    return subprocess.check_output(
+        ["netsh", "interface", "ipv4", "show", "config"],
+        text=True, encoding="utf-8", errors="ignore"
+    )
+
+
+# noinspection PyUnresolvedReferences
+def get_netsh_ipv4() -> List[Dict[str, Any]]:
+    """
+    Parse *all* data from `netsh interface ipv4 show config`.
+
+    Returns a list of dicts – one per adapter – with keys:
+        interface, dhcp_enabled, ip_addresses, subnet_prefixes, subnet_masks,
+        default_gateways, gateway_metric, interface_metric,
+        dns_mode, dns_servers, wins_mode, wins_servers
+    """
+    config_text = get_netsh_show_config()
+
+    adapters: List[Dict[str, Any]] = []
+    adapter: Dict[str, Any] | None = None
+
+    # Track whether we’re in continuation lines of DNS / WINS lists
+    dns_list_type: str | None  = None   # 'static' | 'dynamic' | None
+    wins_list_type: str | None = None
+
+    for raw_line in config_text.splitlines():
+        line = raw_line.strip()
+
+        # 1) New adapter block ------------------------------------------------
+        header_match = RE_ADAPTER_HEADER.search(line)
+        if header_match:
+            # Flush the previous adapter, if any
+            if adapter:
+                adapters.append(adapter)
+
+            iface_name = header_match.group(1)
+            adapter = {
+                'interface_name'   : iface_name,
+                'dhcp_enabled'     : None,
+                'gateway_metric'   : None,
+                'interface_metric' : None,
+                'dns_mode'         : 'unknown',
+                'wins_mode'        : 'unknown',
+                'dns_servers'      : [],
+                'wins_servers'     : [],
+                'ip_addresses'     : [],
+                'subnet_prefixes'  : [],
+                'subnet_masks'     : [],
+                'default_gateways' : [],
+            }
+            dns_list_type = wins_list_type = None
+            continue
+
+        if adapter is None:                 # skip prologue lines
+            continue
+
+        # 2) DHCP flag -------------------------------------------------------
+        if line.startswith("DHCP enabled"):
+            adapter['dhcp_enabled'] = "yes" in line.lower()
+            continue
+
+        # 3) IP addresses ----------------------------------------------------
+        if line.startswith("IP Address"):
+            adapter['ip_addresses'].extend(RE_IP.findall(line))
+            continue
+
+        # 4) Subnet prefix & mask -------------------------------------------
+        if line.startswith("Subnet Prefix"):
+            subnet_match = RE_SUBNET.search(line)
+            if subnet_match:
+                adapter['subnet_prefixes'].append(subnet_match.group('prefix'))
+                adapter['subnet_masks'].append(subnet_match.group('mask'))
+            continue
+
+        # 5) Gateway & metrics ----------------------------------------------
+        if line.startswith("Default Gateway"):
+            adapter['default_gateways'].extend(RE_IP.findall(line))
+            continue
+        if line.startswith("Gateway Metric"):
+            metric = RE_NUMERIC.search(line)
+            if metric:
+                adapter['gateway_metric'] = int(metric.group())
+            continue
+        if line.startswith("InterfaceMetric"):
+            metric = RE_NUMERIC.search(line)
+            if metric:
+                adapter['interface_metric'] = int(metric.group())
+            continue
+
+        # 6) DNS header lines -----------------------------------------------
+        if "DNS servers configured through DHCP" in line:
+            adapter['dns_mode'] = 'dynamic'
+            adapter['dns_servers'].extend(RE_IP.findall(line))
+            dns_list_type = 'dynamic'
+            continue
+        if "Statically Configured DNS Servers" in line:
+            adapter['dns_mode'] = 'static'
+            adapter['dns_servers'].extend(RE_IP.findall(line))
+            dns_list_type = 'static'
+            continue
+
+        # 7) WINS header lines ----------------------------------------------
+        if "WINS servers configured through DHCP" in line:
+            adapter['wins_mode'] = 'dynamic'
+            adapter['wins_servers'].extend(RE_IP.findall(line))
+            wins_list_type = 'dynamic'
+            continue
+        if line.startswith(("Primary WINS Server", "Secondary WINS Server")):
+            adapter['wins_mode'] = 'static'
+            adapter['wins_servers'].extend(RE_IP.findall(line))
+            wins_list_type = 'static'
+            continue
+
+        # 8) Continuation lines for DNS / WINS -------------------------------
+        if dns_list_type and RE_IP.search(line):
+            adapter['dns_servers'].extend(RE_IP.findall(line))
+            continue
+        if wins_list_type and RE_IP.search(line):
+            adapter['wins_servers'].extend(RE_IP.findall(line))
+            continue
+
+    # Flush the final adapter block
+    if adapter:
+        adapters.append(adapter)
+
+    # # ── post-process: detect “mixed” modes ----------------------------------
+    # NOT SURE THIS PART WORKS AS INTENDED!!!
+    # for ad in adapters:
+    #     if ad['dns_mode'] == 'dynamic' and ad['dns_servers']:
+    #         # If both headers appeared the last one wins; treat that as mixed
+    #         if any(k in ad['dns_servers'] for k in ad['default_gateways']):
+    #             ad['dns_mode'] = 'mixed'
+    #     if ad['wins_mode'] == 'dynamic' and ad['wins_servers']:
+    #         if any(ip not in ad['wins_servers'] for ip in ad['wins_servers']):
+    #             ad['wins_mode'] = 'mixed'
+
+    return adapters
+
+
+def run_netsh(*args: str) -> subprocess.CompletedProcess:
+    """
+    Run a netsh command and return stdout as text.
+
+    Example:
+        run_netsh("interface", "ipv4", "show", "interfaces")
+    """
+    cmd = ["netsh"] + list(args)
+    result = subprocess.run(
+        cmd,
+        capture_output=True,
+        text=True,
+        check=False
+    )
+    return result
+
+
+def enable_dhcp_static_coexistence(interface_name: str) -> subprocess.CompletedProcess:
+    """
+    Enable DHCP + static IP coexistence on an interface.
+
+    Equivalent to:
+        netsh interface ipv4 set interface "Ethernet0" dhcpstaticipcoexistence=enabled
+    """
+    return run_netsh(
+        "interface", "ipv4", "set", "interface",
+        interface_name,
+        "dhcpstaticipcoexistence=enabled"
+    )
+
+
+def disable_dhcp_static_coexistence(interface_name: str) -> subprocess.CompletedProcess:
+    """
+    Disable DHCP + static IP coexistence on an interface (optional).
+
+    Equivalent to:
+        netsh interface ipv4 set interface "Ethernet0" dhcpstaticipcoexistence=disabled
+    """
+    return run_netsh(
+        "interface", "ipv4", "set", "interface",
+        interface_name,
+        "dhcpstaticipcoexistence=disabled"
+    )
+
+
+def add_virtual_ip(
+        interface_name: str,
+        ip: str,
+        mask: str,
+        skip_as_source: bool = True
+) -> subprocess.CompletedProcess:
+    """
+    Add a static 'virtual' IP to a DHCP interface, keeping DHCP intact.
+
+    Equivalent to:
+        netsh interface ipv4 add address "Ethernet0" 192.168.1.201 255.255.255.0 skipassource=true
+
+    Args:
+        interface_name: Interface name, e.g. "Ethernet0"
+        ip:     IP to add, e.g. "192.168.1.201"
+        mask:   Subnet mask, e.g. "255.255.255.0"
+        skip_as_source: If True, adds 'skipassource=true' so Windows does
+                        not prefer this IP as the outbound source address.
+    """
+    args = [
+        "interface", "ipv4", "add", "address",
+        interface_name,
+        ip,
+        mask,
+    ]
+    if skip_as_source:
+        args.append("skipassource=true")
+
+    return run_netsh(*args)
+
+
+def remove_virtual_ip(
+        interface_name: str,
+        ip: str
+) -> subprocess.CompletedProcess:
+    """
+    Remove a previously added virtual IP from the interface.
+
+    Equivalent to:
+        netsh interface ipv4 delete address "Ethernet0" addr=192.168.1.201
+    """
+    return run_netsh(
+        "interface", "ipv4", "delete", "address",
+        interface_name,
+        f"addr={ip}"
+    )
+
+
+def show_interface_config(
+        interface_name: Optional[str] = None
+) -> subprocess.CompletedProcess:
+    """
+    Show IPv4 configuration for all interfaces or a specific one.
+
+    Equivalent to:
+        netsh interface ipv4 show config
+    or:
+        netsh interface ipv4 show config "Ethernet0"
+    """
+    if interface_name:
+        return run_netsh("interface", "ipv4", "show", "config", interface_name)
+    else:
+        return run_netsh("interface", "ipv4", "show", "config")
+
+
+def list_ipv4_interfaces() -> subprocess.CompletedProcess:
+    """
+    List IPv4 interfaces.
+
+    Equivalent to:
+        netsh interface ipv4 show interfaces
+    """
+    return run_netsh("interface", "ipv4", "show", "interfaces")

atomicshop/wrappers/playwrightw/engine.py

@@ -5,14 +5,15 @@ import random
 import getpass
 from tempfile import gettempdir
 
-from ...print_api import print_api
+# noinspection PyPackageRequirements
+from playwright.sync_api import sync_playwright, Error
+# Stealth options for playwright. External.
+# from playwright_stealth import stealth_sync
+
 from ...keyboard_press import send_alt_tab
-from ... import filesystem
+from ... import filesystem, print_api
 
-# Web automation library.
-from playwright.sync_api import sync_playwright
-# Stealth options for playwright. External.
-from playwright_stealth import stealth_sync
+from . import infra
 
 
 class PlaywrightEngine:
@@ -22,8 +23,11 @@ class PlaywrightEngine:
 
     def __init__(
             self,
-            browser: str = 'chromium', headless: bool = False, incognito_mode: bool = True,
-            browser_content_working_directory: str = None):
+            browser: str = 'chromium',
+            headless: bool = False,
+            incognito_mode: bool = True,
+            browser_content_working_directory: str = None
+    ):
         """
         :param browser: string, specifies which browser will be executed. Playwright default is 'chromium'.
         :param headless: boolean, specifies if browser will be executed in headless mode. Default is 'False'.
@@ -70,7 +74,15 @@ class PlaywrightEngine:
         # Also, 'sync_playwright()' has 'start()' function that executes the '__enter__()' function.
         # So, we can execute only that.
         self.playwright = sync_playwright().start()
-        self.execute_browser()
+
+        try:
+            self.execute_browser()
+        except Error as e:
+            if "BrowserType.launch: Executable doesn't exist" in e.message:
+                infra.install_playwright()
+                self.execute_browser()
+            else:
+                raise e
 
     def stop(self):
         # Close browser objects. You can only close browser without stopping playwright.
@@ -80,8 +92,7 @@ class PlaywrightEngine:
         # creates '.stop' attribute for 'playwright' object, which gets the '__exit__' function reference name.
         # playwright.stop = self.__exit__
         # So, we can call 'playwright.stop()' in order to close the object without 'with' statement.
-        # noinspection PyStatementEffect,PyUnresolvedReferences
-        self.playwright.stop
+        self.playwright.stop()
 
     def execute_browser(self) -> None:
         """ Execute browser based on mode """
@@ -139,7 +150,7 @@ class PlaywrightEngine:
             self.page = self.browser.new_page()
 
         # Making playwright stealthier with less footprint of automation.
-        stealth_sync(self.page)
+        # stealth_sync(self.page)
 
     def close_browser(self) -> None:
         self.page.close()
@@ -170,9 +181,13 @@ class PlaywrightEngine:
         self.page.wait_for_selector(f'{element}[{attribute}="{value}"]')
 
     def login(
-            self, url_login: str,
-            user_box_text: str = str(), pass_box_text: str = str(), submit_button_text: str = str(),
-            username: str = str(), password: str = str(),
+            self,
+            url_login: str,
+            user_box_text: str = str(),
+            pass_box_text: str = str(),
+            submit_button_text: str = str(),
+            username: str = str(),
+            password: str = str(),
             credential_single_usage: bool = False
               ) -> None:
         """
@@ -242,7 +257,7 @@ class PlaywrightEngine:
         for i in range(element_count):
             string_current = string_current + element.nth(i).text_content()
 
-        print_api(f'Current element text of [{locator_string}]: {string_current}', rtl=True)
+        print_api.print_api(f'Current element text of [{locator_string}]: {string_current}', rtl=True)
 
         # If text from previous cycle isn't the same as text from current cycle, then put the new value to the
         # previous one and return 'True' since the text really changed.
@@ -312,7 +327,7 @@ class PlaywrightEngine:
         # Nullifying 'string_previous', so new loop will not have the same one as previous loop in case of error.
         self.string_previous = str()
 
-        print_api('Finished execution Time: ' + str(datetime.datetime.now()), **kwargs)
-        print_api('Waiting minutes: ' + str(time_to_sleep_minutes), **kwargs)
+        print_api.print_api('Finished execution Time: ' + str(datetime.datetime.now()), **kwargs)
+        print_api.print_api('Waiting minutes: ' + str(time_to_sleep_minutes), **kwargs)
         time.sleep(time_to_sleep_minutes * 60)
-        print_api('-----------------------------------------', **kwargs)
+        print_api.print_api('-----------------------------------------', **kwargs)

atomicshop/wrappers/playwrightw/infra.py

@@ -0,0 +1,5 @@
+import subprocess
+
+
+def install_playwright():
+    subprocess.run(["playwright", "install"])

atomicshop/wrappers/playwrightw/javascript.py

@@ -44,8 +44,12 @@ def get_page_text_content(page) -> str:
     :return: string, text content of the page.
     """
 
-    text_content: str = page.evaluate('''() => {
-        return document.body.innerText;
-    }''')
+    # Full javascript.
+    # text_content: str = page.evaluate('''() => {
+    #     return document.body.innerText;
+    # }''')
+
+    # Short javascript.
+    text_content: str = page.evaluate("document.body.innerText")
 
     return text_content

atomicshop/wrappers/playwrightw/keyboard.py

@@ -0,0 +1,14 @@
+def type_text(page, text):
+    # Directly type into the focused field (if the cursor is already there)
+    page.keyboard.type(text)
+
+
+def press_key(page, key: str):
+    """
+    Press a key on the keyboard.
+    :param page: playwright page
+    :param key: str, the key to press. Example: 'Enter'.
+    :return:
+    """
+    # Optionally, you can press Enter or other keys as needed
+    page.keyboard.press(key)

atomicshop/wrappers/playwrightw/scenarios.py

@@ -3,8 +3,16 @@ Scenarios file contains full execution scenarios of playwright wrapper.
 For example: run playwright, navigate to URL, get text from a locator.
 """
 
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Literal
+
+from playwright.sync_api import sync_playwright
+from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
+from bs4 import BeautifulSoup
+
 from . import engine, base, combos
 from ...basics import threads, multiprocesses
+from ... import web
 
 
 def get_text_from_html_tag(url: str, tag_name: str, attribute: str, value: str) -> str:
@@ -43,8 +51,12 @@ def get_text_from_html_tag(url: str, tag_name: str, attribute: str, value: str)
 
 
 def get_page_content(
-        url: str, page_format: str = 'html', path: str = None, print_kwargs: dict = None, pdf_format: str = 'A4',
-        html_txt_convert_to_bytes: bool = True
+        url: str,
+        page_format: str = 'html',
+        path: str = None,
+        pdf_format: str = 'A4',
+        html_txt_convert_to_bytes: bool = True,
+        print_kwargs: dict = None
 ) -> any:
     """
     The function receives playwright engine and page object, navigates to URL, gets page content in specified format,
@@ -57,10 +69,10 @@ def get_page_content(
         'png' - returns png binary.
         'jpeg' - returns jpeg binary.
     :param path: string of path to save the file to. Default is None.
-    :param print_kwargs: dict, that contains all the arguments for 'print_api' function.
     :param pdf_format: string of pdf format, applicable only if 'page_format=pdf'. Default is 'A4'.
     :param html_txt_convert_to_bytes: boolean, applicable only if 'page_format=html' or 'page_format=txt'.
         Default is True.
+    :param print_kwargs: dict, that contains all the arguments for 'print_api' function.
 
     :return: any page content in specified format.
     """
@@ -95,8 +107,13 @@ def get_page_content(
 
 
 def get_page_content_in_thread(
-        url: str, page_format: str = 'html', path: str = None, print_kwargs: dict = None, pdf_format: str = 'A4',
-        html_txt_convert_to_bytes: bool = True):
+        url: str,
+        page_format: str = 'html',
+        path: str = None,
+        pdf_format: str = 'A4',
+        html_txt_convert_to_bytes: bool = True,
+        print_kwargs: dict = None
+):
     """
     The function uses 'threads.thread_wrap_var' function in order to wrap the function 'get_page_content' and
     execute it in a thread with arguments and return the result.
@@ -130,3 +147,153 @@ def _get_page_content_in_process(
             html_txt_convert_to_bytes=html_txt_convert_to_bytes,
             print_kwargs=print_kwargs
         )
+
+
+def fetch_urls_content_in_threads(
+        urls: list[str],
+        number_of_characters_per_link: int,
+        text_fetch_method: Literal[
+            'playwright_text',
+            'js_text',
+            'playwright_html',
+            'js_html',
+            'playwright_copypaste'
+        ]
+) -> list[str]:
+    """ The function to fetch all URLs concurrently using threads """
+    contents = []
+
+    # Use ThreadPoolExecutor to run multiple threads
+    with ThreadPoolExecutor() as executor:
+        # Submit tasks for each URL
+        future_to_url = {executor.submit(_fetch_content, url, number_of_characters_per_link, text_fetch_method): url for url in urls}
+
+        # Collect results as they complete
+        for future in as_completed(future_to_url):
+            url = future_to_url[future]
+            try:
+                data = future.result()
+                contents.append(data)
+            except Exception as exc:
+                print(f"An error occurred when fetching {url}: {exc}")
+
+    return contents
+
+
+def fetch_urls_content(
+        urls: list[str],
+        number_of_characters_per_link: int,
+        text_fetch_method: Literal[
+            'playwright_text',
+            'js_text',
+            'playwright_html',
+            'js_html',
+            'playwright_copypaste'
+        ],
+) -> list[str]:
+    """ The function to fetch all URLs not concurrently without using threads """
+    contents = []
+
+    for url in urls:
+        data = _fetch_content(url, number_of_characters_per_link, text_fetch_method)
+        contents.append(data)
+
+    return contents
+
+
+def _fetch_content(
+        url,
+        number_of_characters_per_link,
+        text_fetch_method: Literal[
+            'playwright_text',
+            'js_text',
+            'playwright_html',
+            'playwright_html_to_text',
+            'js_html',
+            'js_html_to_text',
+            'playwright_copypaste'
+        ],
+        headless: bool = True):
+    """ Function to fetch content from a single URL using the synchronous Playwright API """
+
+    with sync_playwright() as p:
+        browser = p.chromium.launch(headless=headless)  # Set headless=True if you don't want to see the browser
+
+        user_agent: str = web.USER_AGENTS['Chrome 142.0.0 Windows 10/11 x64']
+
+        if text_fetch_method == "playwright_copypaste":
+            context = browser.new_context(permissions=["clipboard-read", "clipboard-write"], user_agent=user_agent)
+        else:
+            context = browser.new_context(user_agent=user_agent)
+
+        page = context.new_page()
+
+        # from playwright_stealth import stealth_sync
+        # stealth_sync(page)
+
+        # # Block specific script by URL or partial URL match
+        # def block_script(route):
+        #     if "custom.js" in route.request.url:
+        #         print(f"Blocking: {route.request.url}")
+        #         route.abort()  # Block the request
+        #     else:
+        #         route.continue_()  # Allow other requests
+        #
+        # # Intercept and handle network requests
+        # page.route("**/*", block_script)
+
+        page.goto(url)
+
+        # Wait for the page to load using all possible methods, since there is no specific method
+        # that will work for all websites.
+        page.wait_for_load_state("load", timeout=5000)
+        page.wait_for_load_state("domcontentloaded", timeout=5000)
+        # The above is not enough, wait for network to stop loading files.
+        response_list: list = []
+        while True:
+            try:
+                # "**/*" is the wildcard for all URLs.
+                # 'page.expect_response' will wait for the response to be received, and then return the response object.
+                # When timeout is reached, it will raise a TimeoutError, which will break the while loop.
+                with page.expect_response("**/*", timeout=2000) as response_info:
+                    response_list.append(response_info.value)
+            except PlaywrightTimeoutError:
+                break
+
+        if text_fetch_method == "playwright_text":
+            text_content = page.inner_text('body')
+        elif text_fetch_method == "js_text":
+            # Use JavaScript to extract only the visible text from the page
+            text_content: str = page.evaluate("document.body.innerText")
+        elif "playwright_html" in text_fetch_method:
+            # Get the full HTML content of the page
+            text_content = page.content()
+        elif "js_html" in text_fetch_method:
+            # Use JavaScript to extract the full text from the page
+            text_content = page.evaluate('document.documentElement.outerHTML')
+        elif text_fetch_method == "playwright_copypaste":
+            # Focus the page and simulate Ctrl+A and Ctrl+C
+            page.keyboard.press("Control+a")  # Select all text
+            page.keyboard.press("Control+c")  # Copy text to clipboard
+            # Retrieve copied text from the clipboard
+            text_content = page.evaluate("navigator.clipboard.readText()")
+        else:
+            raise ValueError(f"Invalid text_fetch_method: {text_fetch_method}")
+
+        if "to_text" in text_fetch_method:
+            # Convert HTML to plain text using BeautifulSoup
+            soup = BeautifulSoup(text_content, "html.parser")
+            text_content = soup.get_text()
+
+        # text = page.evaluate('document.body.textContent')
+        # text = page.eval_on_selector('body', 'element => element.innerText')
+        # text = page.eval_on_selector('body', 'element => element.textContent')
+        # text = page.inner_text('body')
+        # text = page.text_content('body')
+
+        # text = page.evaluate('document.documentElement.innerText')
+        # text = page.inner_text(':root')
+
+        browser.close()
+    # Return only the first X characters of the text content to not overload the LLM.
+    return text_content[:number_of_characters_per_link]

atomicshop/wrappers/playwrightw/waits.py

@@ -1,7 +1,9 @@
-from atomicshop.print_api import print_api
+from ... import print_api
 
+# noinspection PyPackageRequirements
 from playwright.sync_api import expect
 # This is from official docs: https://playwright.dev/python/docs/api/class-timeouterror
+# noinspection PyPackageRequirements
 from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
 
 
@@ -124,7 +126,7 @@ def network_fully_idle(page, timeout: int = 2000, print_kwargs: dict = None) ->
             # 'page.expect_response' will wait for the response to be received, and then return the response object.
             # When timeout is reached, it will raise a TimeoutError, which will break the while loop.
             with page.expect_response("**/*", timeout=timeout) as response_info:
-                print_api(response_info.value, **print_kwargs)
+                print_api.print_api(response_info.value, **(print_kwargs or {}))
         except PlaywrightTimeoutError:
             break
 
@@ -151,13 +153,13 @@ def maximum_idle(page, print_kwargs: dict = None) -> None:
     :return: None
     """
 
-    print_api('Before wait_for_load', **print_kwargs)
+    print_api.print_api('Before wait_for_load', **(print_kwargs or {}))
     load(page)
-    print_api('After wait_for_load, Before wait_for_domcontentloaded', **print_kwargs)
+    print_api.print_api('After wait_for_load, Before wait_for_domcontentloaded', **(print_kwargs or {}))
     domcontentloaded(page)
-    print_api('After wait_for_domcontentloaded', **print_kwargs)
+    print_api.print_api('After wait_for_domcontentloaded', **(print_kwargs or {}))
     # For some reason 'networkidle' can result in timeout errors, so currently this is disabled.
     # networkidle(page)
-    print_api('Before wait_for_network_fully_idle', **print_kwargs)
+    print_api.print_api('Before wait_for_network_fully_idle', **(print_kwargs or {}))
     network_fully_idle(page, print_kwargs=print_kwargs)
-    print_api('After wait_for_network_fully_idle', **print_kwargs)
+    print_api.print_api('After wait_for_network_fully_idle', **(print_kwargs or {}))