from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service as ChromeService
from webdriver_manager.chrome import ChromeDriverManager


def pytest_runtest_makereport(item, call):
    """
    Pytest hook for saving html page on test failure

    :param item: pytest item
    :param call: pytest call
    """
    if "driver" in item.fixturenames:
        web_driver = item.funcargs["driver"]
        if call.when == "call" and call.excinfo is not None:
            with open(f"{item.nodeid.split('::')[1]}.html", "w", encoding="utf-8") as file:
                file.write(web_driver.page_source)


@pytest.fixture
def driver():
    """
    Pytest fixture for selenium webdriver

    :return: webdriver
    """
    options = Options()
    options.add_argument("--headless")
    options.headless = True
    path = ChromeDriverManager().install()
    _driver = webdriver.Chrome(service=ChromeService(executable_path=path, options=options), options=options)

    yield _driver

    _driver.close()
    _driver.quit()

1) You may obtain page code by calling "get_page_code" function. It will return you:
 raw HTML document, what needs to be tested. And you need to respond with json in following format:
{
"page_objects": [
"@property\\n
    def calculate_button(self):\\n
        return WebDriverWait(self.driver, 10).until(\\n
            EC.presence_of_element_located((By.XPATH, '//button[.='''Calculate''']'))\\n
        )", <...>
],
"tests": ["def test_division_by_zero(page):\\n
    page.numbers_input.send_keys(1024)\\n
    page.divide_button.click()\\n
    page.calculator_input.send_keys('0')\\n
    page.calculate_button.click()\\n
    assert page.error.text() == 'Error: divide by zero'", <...>],
}
This means you need to create page objects for each object on the page using laconic and stable XPATH locators (as short and stables as you can, use only By.XPATH locators, not By.ID, not By.CSS_SELECTOR or By.CLASS name), and then create all possible test cases for them. It might be some filed filling tests (errors, border checks, positive and negative cases), clicking, content changing, etc. Please respect to use 'page' fixture for every test, it's predefined in code and opens page under test before it.
2) Then I may ask you to execute some tests. You can run demanded test via "get_tests_results" function, based on gathered content, you need to respond with json in following format:
results = {
    "passed": [],
    "failed": [],
    "error": [],
    "failure details": {}
}
where "failure details" - is dict with keys equal to test names (which you generated) and possible failures details. If you got an failures and errors, you need to respond as in 1 with fixed code (page objects and/or tests).
Answer only with JSON in format I mentioned in 1. Never add anything more than that (no explanations, no extra text, only json).
3) In addition to 1 and 2 i may pass you extra info what kind of test data might be used (i.e. for form filling), but in general you need to generate all possible scenarios (valid/invalid/border cases, always add what's not listed by user, but should be for best quality of testing coverage).

from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service as ChromeService
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
from webdriver_manager.chrome import ChromeDriverManager


class PageRetriever:
    """The PageRetriever class is for managing an instance of the PageRetriever."""

    def __init__(self, url=""):
        """
        General init.

        :param url: (str) URL of the page.
        """
        options = Options()
        options.add_argument("--headless")
        options.headless = True
        path = ChromeDriverManager().install()
        self.driver = webdriver.Chrome(service=ChromeService(executable_path=path), options=options)
        self.url = url

    def set_url(self, url):
        """
        Set the url.

        :param url: (str) URL of the page.
        """
        self.url = url

    def get_page(self, url=None):
        """
        Get the page content from the url.

        :param url: (str) URL of the page.
        :return: (str) HTML content of the page.
        """
        if url:
            self.set_url(url)
        return self.get_page_content(self.url)

    def get_body(self, url=None):
        """
        Get the body content of the page.

        :param url: (str) URL of the page.
        :return: (str) Body content of the page.
        """
        if url:
            self.set_url(url)
        return self.extract_body_content(self.get_page())

    def get_body_without_scripts(self, url=None):
        """
        Get the body content of the page without <script>...</script> tags.

        :param url: (str) URL of the page.
        :return: (str) Body content of the page without <script>...</script> tags.
        """
        if url:
            self.set_url(url)
        return self.remove_script_tags(self.get_body())

    def get_page_content(self, url):
        """
        Get the page content from the url.

        :param url: (str) URL of the page.
        :return: (str) HTML content of the page.
        """
        self.driver.get(url)

        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.TAG_NAME, "body")))

        start_time = time.time()
        while True:
            network_activity = self.driver.execute_script(
                "return window.performance.getEntriesByType('resource').filter(item => "
                "item.initiatorType == 'xmlhttprequest' && item.duration == 0)"
            )
            if not network_activity or time.time() - start_time > 30:
                break

        content = self.driver.page_source
        self.driver.close()
        self.driver.quit()

        return content

    @staticmethod
    def extract_body_content(html_content):
        """
        Extract the body content from the html_content.

        :param html_content: (str) HTML content of the page.
        :return: (str) Body content of the page.
        """
        soup = BeautifulSoup(html_content, "html.parser")
        body_content = soup.body

        return str(body_content)

    @staticmethod
    def remove_script_tags(input_content):
        """
        Remove all <script>...</script> tags from the input_content.

        :param input_content: (str) HTML content of the page.
        :return: (str) Body content of the page without <script>...</script> tags.
        """
        pattern_1 = re.compile(r"<script.*?>.*?</script>", re.DOTALL)
        pattern_2 = re.compile(r"<path.*?>.*?</path>", re.DOTALL)
        output = re.sub(pattern_1, "", input_content)
        output = re.sub

Обратите внимание, что некоторые сервисы уже предоставляют возможности доступа к web для LLM. В том числе, эта функция уже анонсирована и включена для ChatGPT для коропоративных и plus аккаунтов. Но, в конце концов, вам никто не мешает использовать свой код в целях экономии или оптимизации.

import io
import json
from os import remove

import pytest

from utils.page_retriever import PageRetriever


def run_tests(test_files, add_failed_html=True, add_failure_reasons=True, count_of_htmls=1):
    """
    Run tests and return results in JSON format.

    :param test_files: (list) list with test files.
    :param add_failed_html: (bool) boolean to add html report.
    :param add_failure_reasons: (bool) boolean to add failure reasons.
    :param count_of_htmls: (int) count of htmls to add. Doesn't recommend to use more than 1.
    :return: JSON with results.
    """
    pytest.main(
        [
            "-q",
            "--json-report",
            "--json-report-file=test_report.json",
            #"-n=4",
            "-rfEx --tb=none -p no:warnings -p no:logging",
        ]
        + test_files
    )

    with open("test_report.json", encoding="utf-8") as json_file:
        data = json.load(json_file)

    results = {"passed": [], "failed": [], "error": [], "failure details": {}, "failed_pages": {}}

    for test in data["tests"]:
        node_name = test["nodeid"].split("::")[1]
        if test["outcome"] == "passed":
            results["passed"].append(node_name)
        elif test["outcome"] == "failed" or test["outcome"] == "error":
            results[test["outcome"]].append(node_name)
            if add_failure_reasons:
                results["failure details"][node_name] = {node_name: test["call"]["crash"]}
            if add_failed_html:
                if len(results["failed_pages"]) < count_of_htmls:
                    results["failed_pages"][node_name] = {node_name: parse_error_page(node_name)}

    json_results = json.dumps(results)

    return json_results


def parse_error_page(node_name):
    """
    Parse error page.

    :param node_name: (str) name of the node.
    :return: (str) formatted content of the page.
    """
    parser = PageRetriever()
    try:
        file_name = f"{node_name}.html"
        with open(file_name, "r", encoding="utf-8") as file:
            formatted_content = parser.remove_script_tags(parser.extract_body_content(file))
        remove(file_name)
        return formatted_content
    except io.UnsupportedOperation:
        return "No page available."

from examples.test_generator.pytest_runner import run_tests
from utils.page_retriever import PageRetriever

doc_engine = PageRetriever()
gpt_functions = [
    {
        "name": "get_page_code",
        "description": "Get page code to generate locators and tests",
        "parameters": {
            "type": "object",
            "properties": {"url": {"type": "string", "description": "The URL of the page to get the code from"}},
            "required": [],
        },
    },
    {
        "name": "get_tests_results",
        "description": "Get the results of the tests",
        "parameters": {
            "type": "object",
            "properties": {
                "test_files": {
                    "type": "array",
                    "items": {"type": "string"},
                    "description": "The list of test files to run",
                }
            },
            "required": [],
        },
    },
]

gpt_functions_dict = {
    "get_page_code": doc_engine.get_body_without_scripts,
    "get_tests_results": run_tests,
}

import os

from urllib.parse import urlparse, unquote


class PomTestCaseGenerator:
    """Class for generating test files and page objects from json data"""

    def __init__(self, url=""):
        """
        General init.

        :param url: (str) URL of the page.
        """
        self.url = url

    def set_url(self, url):
        """
        Set the url.

        :param url: (str) URL of the page.
        """
        self.url = url

    def ___create_pom_file(self, file_name, page_objects, url="", pom_folder="pom"):
        """
        Create page object model file.

        :param file_name: (str) Name of the file.
        :param page_objects: (list) List of page objects.
        :param url: (str) URL of the page.
        :param pom_folder: (str) Folder for page object model files.
        """
        if not url:
            url = self.url
        if not os.path.exists(pom_folder):
            os.makedirs(pom_folder)
        with open(f"{pom_folder}/page_{file_name}.py", "w", encoding="utf-8") as pom_file:
            pom_file.write("from selenium.webdriver.common.by import By\n")
            pom_file.write("from selenium.webdriver.support.ui import WebDriverWait\n")
            pom_file.write("from selenium.webdriver.support import expected_conditions as EC\n\n\n")
            pom_file.write(f'class Page{"".join(word.capitalize() for word in file_name.split("_"))}:\n')
            pom_file.write("    def __init__(self, driver):\n")
            pom_file.write(f'        self.url = "{url}"\n')
            pom_file.write("        self.driver = driver\n\n")
            for method in page_objects:
                pom_file.write(f"    {method}\n\n")

    @staticmethod
    def ___create_test_file(file_name, tests, pom_folder="pom", tests_folder="tests"):
        """
        Create test file.

        :param file_name: (str) Name of the file.
        :param tests: (list) List of tests.
        :param pom_folder: (str) Folder for page object model files.
        :param tests_folder: (str) Folder for test files.
        """
        with open(f"{tests_folder}/test_{file_name}.py", "w", encoding="utf-8") as test_file:
            test_file.write("import pytest\n\n")
            test_file.write(
                f'from {pom_folder}.{os.path.splitext(f"page_{file_name}")[0]} import Page'
                f'{"".join(word.capitalize() for word in file_name.split("_"))}\n\n\n'
            )
            test_file.write('@pytest.fixture(scope="function")\n')
            test_file.write("def page(driver):\n")
            test_file.write(
                f'    page_under_test = Page{"".join(word.capitalize() for word in file_name.split("_"))}(driver)\n'
            )
            test_file.write("    driver.get(page_under_test.url)\n")
            test_file.write("    return page_under_test\n\n\n")
            for test in tests:
                test_file.write(f"{test}\n\n\n")

    def create_files_from_json(self, json_data, url="", pom_folder="pom", tests_folder="tests"):
        """
        Create test and page object model files from json data.

        :param json_data: (str) JSON data.
        :param url: (str) URL of the page.
        :param pom_folder: (str) Folder for page object model files.
        :param tests_folder: (str) Folder for test files.
        """
        if not url:
            url = self.url
        parsed_url = urlparse(unquote(url))
        file_name = parsed_url.path.strip("/").replace("/", "_") or "index"
        self.___create_test_file(file_name, json_data["tests"], pom_folder="..pom", tests_folder=tests_folder)
        self.___create_pom_file(file_name, json_data["page_objects"], url, pom_folder=pom_folder)

import asyncio
import json
import logging

from examples.creds import oai_token, oai_organization
from examples.test_generator.gpt_functions import gpt_functions, gpt_functions_dict
from examples.test_generator.pom_case_generator import PomTestCaseGenerator
from openai_api.src.openai_api import ChatGPT
from openai_api.src.openai_api.logger_config import setup_logger

PAGE_UNDER_TEST = "https://www.saucedemo.com/"
generator = PomTestCaseGenerator(url=PAGE_UNDER_TEST)


def setup_gpt():
    """Setup GPT bot with appropriate functions and settings"""
    gpt = ChatGPT(auth_token=oai_token, organization=oai_organization, model="gpt-4-0613")
    gpt.function_dict = gpt_functions_dict
    gpt.function_call = "auto"
    gpt.functions = gpt_functions
    gpt.system_settings = """%instructions_inside%"""
    return gpt


async def main():
    """Main function for testing GPT bot"""
    print("===Setup GPT bot===")
    gpt = setup_gpt()
    
    print(f"===Get page code of {PAGE_UNDER_TEST} and generate PO and tests===")
    response = await anext(gpt.str_chat(f"Get page code of {PAGE_UNDER_TEST} and generate PO and tests"))
    print(response)  # print response as debug output
    response = response.replace("\n", "")  # need to proper json loading
    generator.create_files_from_json(
        json.loads(response), pom_folder="examples/test_generator/pom", tests_folder="examples/test_generator/tests"
    )
    print("===Get tests results for examples/test_generator/tests/test_index.py==")
    response = await anext(gpt.str_chat("Get tests results for examples/test_generator/tests/test_index.py"))
    print(response)  # print response as debug output
    print("===If there are failures in code, please fix it by fixing POM and tests===")
    response = await anext(gpt.str_chat("If there are failures in code, please fix it by fixing POM and tests"))
    print(response)  # print response as debug output
    generator.create_files_from_json(
        json.loads(response.replace("\n", "")), pom_folder="..pom", tests_folder="examples/test_generator/tests"
    )
    # repeat as many times as you wish or getting 100% passrate


asyncio.run(main())