Skip to content
TheChatArchiveThe Chat Archive
gpt-4-0314· openaiHugging Face Suzhen/CodeChat

Ассинхронно выводит информации о токенах, указанных в цикле Используется playwright…

  1. User

    Ассинхронно выводит информации о токенах, указанных в цикле

    Используется playwright

    import asyncio from bs4 import BeautifulSoup from playwright.async_api import async_playwright

    async def get_token_info(token_symbol): async with async_playwright() as p: browser = await p.chromium.launch(headless=True) context = await browser.new_context() page = await context.new_page()

        await page.goto("https://moonarch.app/")
    
        search_box_selector = 'input.form-control'
        await page.wait_for_selector(search_box_selector)
    
        search_box = await page.query_selector(search_box_selector)
        await search_box.type(token_symbol)
    
        await page.wait_for_selector('.token-info')
        await page.wait_for_selector('.infocard')
    
        soup = BeautifulSoup(await page.content(), "html.parser")
        token_info_element = soup.find("div", class_="token-info")
        infocard_element = soup.find("div", class_="infocard")
        check_alert_element = soup.find("div", class_="token-check-message check-alert")
        check_warning_element = soup.find("div", class_="token-check-message check-warning")
        check_info_element = soup.find("div", class_="token-check-message check-info")
        not_verified_element = soup.find("div", class_="not-verified")
    
        check_alert_status = "Yes" if check_alert_element else "None"
        check_warning_status = "Yes" if check_warning_element else "None"
        check_info_status = "Yes" if check_info_element else "None"
        not_verified_status = "Yes" if not_verified_element else "None"
    
        if token_info_element and infocard_element:
            token_name_element = token_info_element.find("span", class_="name")
            token_symbol_element = token_info_element.find("span", class_="symbol")
            info_items = infocard_element.find_all("li")
    
            if token_name_element and token_symbol_element and len(info_items) >= 7:
                token_name = token_name_element.text.strip()
                token_symbol = token_symbol_element.text.strip()
                price = info_items[0].find("span", class_="value").text.strip()
                max_supply = info_items[1].find("span", class_="value").text.strip()
                market_cap = info_items[2].find("span", class_="value").text.strip()
                liquidity = info_items[3].find("span", class_="value").text.strip()
                liq_mc = info_items[4].find("span", class_="value").text.strip()
                token_age = info_items[6].find("span", class_="value").text.strip()
    
                await browser.close()
    
                return {
                    "name": token_name,
                    "symbol": token_symbol,
                    "price": price,
                    "max_supply": max_supply,
                    "market_cap": market_cap,
                    "liquidity": liquidity,
                    "liq_mc": liq_mc,
                    "token_age": token_age,
                    "check_alert": check_alert_status,
                    "check_warning": check_warning_status,
                    "check_info": check_info_status,
                    "not_verified": not_verified_status
                }
    
            else:
                await browser.close()
                error_info = f"token_name_element: {token_name_element}, token_symbol_element: {token_symbol_element}, info_items count: {len(info_items)}"
                return {"error": f"Failed to find the required info items or name and.symbol. Error_info: {error_info}"}
    
        else:
            await browser.close()
            return {"error": f"Failed to find the required elements for token_info_element ({token_info_element}) and infocard_element ({infocard_element})."}
    

    token_symbols = [ "0x0E481Fa712201f61dAf97017138Efaa69e2A3df3", "0x2023aa62A7570fFd59F13fdE2Cac0527D45abF91", "0x2222222222222222222222222222222222222222", "0x0d4890ecEc59cd55D640d36f7acc6F7F512Fdb6e"]

    async def main(): while True: result_tasks = [get_token_info(token_symbol) for token_symbol in token_symbols] results = await asyncio.gather(*result_tasks) print(results)

        await asyncio.sleep(60)
    

    asyncio.run(main())

    Write detailed instructions on how to ensure that the above code sends requests from different ip addresses. This is necessary in order to avoid blocking

  2. Assistant

    To make the code send requests from different IP addresses, you can use proxy servers. You can set up a proxy server in the Playwright library with the following steps:

    1. Install some proxy libraries if you haven't already:
    pip install proxybroker
    
    1. You will need a list of proxy servers. You can obtain a list of proxy servers using the 'proxybroker' library. To find and collect a list of working proxies, use the following code snippet:
    import asyncio
    from proxybroker import Broker
    
    async def show(proxies):
        while True:
            proxy = await proxies.get()
            if proxy is None:
                break
            print('Found proxy: %s' % proxy)
    
    proxies = asyncio.Queue()
    broker = Broker(proxies)
    
    # Collect 10 working HTTP(S) proxies
    tasks = asyncio.gather(broker.find(types=['HTTP', 'HTTPS'], limit=10))
    
    if asyncio.run_until_complete(tasks):
        print('Done.')
    

    This will provide you with a list of working proxies, store them in a list for using in your playwright code.

    1. Update your main method to use the proxies while making requests with Playwright:
    from random import choice
    
    async def main():
        # Add the list of proxies collected with proxybroker
        proxy_list = [
            # Format: 'http://username:password@proxy_ip:proxy_port'
            'http://username:password@proxy_ip:proxy_port',
            'http://username:password@proxy_ip:proxy_port',
            # Add more proxies as needed
        ]
    
        while True:
            # Randomly choose a proxy for each token_symbol
            for token_symbol in token_symbols:
                proxy = choice(proxy_list)
                result = await get_token_info(token_symbol, proxy)
                print(result)
    
            await asyncio.sleep(60)
    
    # Modify your get_token_info function to accept a proxy parameter
    async def get_token_info(token_symbol, proxy):
        # Existing code ...
        async with async_playwright() as p:
            browser = await p.chromium.launch(headless=True, proxy={"server": proxy})
            # Rest of the existing code ...
    

    These steps will ensure that the requests are sent using different IP addresses. Note that using free or public proxies can be unreliable and might affect the performance of your script. It's recommended to use a reliable proxy service or your own proxy servers.

    In conclusion, here's the complete code with the integration of proxy:

    import asyncio
    from bs4 import BeautifulSoup
    from random import choice
    from playwright.async_api import async_playwright
    
    async def get_token_info(token_symbol, proxy):
        async with async_playwright() as p:
            browser = await p.chromium.launch(headless=True, proxy={"server": proxy})
            # Rest of the existing code...
    
    # Add the list of proxies collected with proxybroker
    proxy_list = [
        # Format: 'http://username:password@proxy_ip:proxy_port'
        'http://username:password@proxy_ip:proxy_port',
        'http://username:password@proxy_ip:proxy_port',
        # Add more proxies as needed
    ]
    
    async def main():
        while True:
            # Randomly choose a proxy for each token_symbol
            for token_symbol in token_symbols:
                proxy = choice(proxy_list)
                result = await get_token_info(token_symbol, proxy)
                print(result)
    
            await asyncio.sleep(60)
    
    token_symbols = [
        "0x0E481Fa712201f61dAf97017138Efaa69e2A3df3",
        "0x2023aa62A7570fFd59F13fdE2Cac0527D45abF91",
        "0x2222222222222222222222222222222222222222",
        "0x0d4890ecEc59cd55D640d36f7acc6F7F512Fdb6e"]
    
    asyncio.run(main())