parallelhtmlscraper 0.0.0__tar.gz → 0.2.0__tar.gz

parallelhtmlscraper-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Yukihiko Shinoda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

parallelhtmlscraper-0.2.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include docs *

parallelhtmlscraper-0.2.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.4
+Name: parallelhtmlscraper
+Version: 0.2.0
+Summary: This project helps you to web scrape html file.
+Author-email: Yukihiko Shinoda <yuk.hik.future@gmail.com>
+Maintainer-email: Yukihiko Shinoda <yuk.hik.future@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2019 Yukihiko Shinoda
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: homepage, https://github.com/yukihiko-shinoda/parallel-html-scraper
+Project-URL: repository, https://github.com/yukihiko-shinoda/parallel-html-scraper
+Keywords: parallel,HTML,web,scraping,scrape,aiohttp,beautifulsoup,beautifulsoup4
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: aiohttp
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: System :: Archiving
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Classifier: Typing :: Typed
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp
+Requires-Dist: beautifulsoup4
+Dynamic: license-file
+
+# Parallel HTML Scraper
+
+[![Test](https://github.com/yukihiko-shinoda/parallel-html-scraper/workflows/Test/badge.svg)](https://github.com/yukihiko-shinoda/parallel-html-scraper/actions?query=workflow%3ATest)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/5f07cb148a0770db4be4/test_coverage)](https://codeclimate.com/github/yukihiko-shinoda/parallel-html-scraper/test_coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/5f07cb148a0770db4be4/maintainability)](https://codeclimate.com/github/yukihiko-shinoda/parallel-html-scraper/maintainability)
+[![Code Climate technical debt](https://img.shields.io/codeclimate/tech-debt/yukihiko-shinoda/parallel-html-scraper)](https://codeclimate.com/github/yukihiko-shinoda/parallel-html-scraper)
+[![Updates](https://pyup.io/repos/github/yukihiko-shinoda/parallel-html-scraper/shield.svg)](https://pyup.io/repos/github/yukihiko-shinoda/parallel-html-scraper/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/parallelhtmlscraper)](https://pypi.org/project/parallelhtmlscraper/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/parallelhtmlscraper)](https://pypi.org/project/parallelhtmlscraper/)
+[![Twitter URL](https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Fgithub.com%2Fyukihiko-shinoda%2Fparallel-html-scraper)](http://twitter.com/share?text=Parallel%20HTML%20Scraper&url=https://pypi.org/project/parallelhtmlscraper/&hashtags=python)
+
+Helps you to web scrape html file in parallel without async / await syntax.
+
+## Feature
+
+This project helps you to web scrape html file in parallel without async / await syntax.
+
+## Installation
+
+```console
+pip install parallelhtmlscraper
+```
+
+## Usage
+
+Minimum example:
+
+```python
+from bs4 import BeautifulSoup
+
+from parallelhtmlscraper.html_analyzer import HtmlAnalyzer
+from parallelhtmlscraper.parallel_html_scraper import ParallelHtmlScraper
+
+class AnalyzerExample(HtmlAnalyzer):
+    async def execute(self, soup: BeautifulSoup) -> str:
+        return soup.find('title').text
+
+host_google = 'https://www.google.com'
+path_and_content = [
+    '',                                                           # Google Search
+    '/imghp?hl=EN',                                               # Google Images
+    '/shopping?hl=en',                                            # Google Shopping
+    '/save',                                                      # Collection
+    'https://www.google.com/maps?hl=en',                          # Google Maps
+    'https://www.google.com/drive/apps.html',                     # Google drive
+    'https://www.google.com/mail/help/intl/en/about.html?vm=r',   # GMail
+]
+
+list_response = ParallelHtmlScraper.execute(host_google, path_and_content, AnalyzerExample())
+print(list_response)
+```
+
+```console
+$ python test.py
+['\n      Gmail - Email from Google\n    ', 'Google Images', '  Google Maps  ', 'Using Google Drive - New Features, Benefits & Advantages of Google Cloud Storage', 'Google Shopping', 'Google', 'Collections']
+```
+
+## API
+
+### ParallelMediaDownloader.execute
+
+```python
+class ParallelHtmlScraper:
+    """API of parallel HTML scraping."""
+
+    @staticmethod
+    def execute(
+        base_url: str,
+        list_url: Iterable[str],
+        analyzer: HtmlAnalyzer[_T],
+        *,
+        limit: int = 5
+        interval: int = 1
+    ) -> List[_T]:
+```
+
+#### base_url: str
+
+Common part of request URL.
+This will be help to download URLs got from HTML.
+
+#### list_url: Iterable[str]
+
+List of URL. Method will download them in parallel.
+Absolute URL having same base URL as `base_url` also can be specified.
+
+#### analyzer: HtmlAnalyzer[_T]
+
+The instance extends `HtmlAnalyzer` to analyze HTML by using [BeautifulSoup](https://pypi.org/project/beautifulsoup4/).
+Following example will be help to understand its roll:
+
+```python
+class AnalyzerExample(HtmlAnalyzer):
+    async def execute(self, soup: BeautifulSoup) -> str:
+        return soup.find('title').text
+```
+
+#### limit: int = 5
+
+Limit number of parallel processes.
+
+#### interval: int = 1
+
+Interval between each request(second).

parallelhtmlscraper-0.2.0/README.md

@@ -0,0 +1,104 @@
+# Parallel HTML Scraper
+
+[![Test](https://github.com/yukihiko-shinoda/parallel-html-scraper/workflows/Test/badge.svg)](https://github.com/yukihiko-shinoda/parallel-html-scraper/actions?query=workflow%3ATest)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/5f07cb148a0770db4be4/test_coverage)](https://codeclimate.com/github/yukihiko-shinoda/parallel-html-scraper/test_coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/5f07cb148a0770db4be4/maintainability)](https://codeclimate.com/github/yukihiko-shinoda/parallel-html-scraper/maintainability)
+[![Code Climate technical debt](https://img.shields.io/codeclimate/tech-debt/yukihiko-shinoda/parallel-html-scraper)](https://codeclimate.com/github/yukihiko-shinoda/parallel-html-scraper)
+[![Updates](https://pyup.io/repos/github/yukihiko-shinoda/parallel-html-scraper/shield.svg)](https://pyup.io/repos/github/yukihiko-shinoda/parallel-html-scraper/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/parallelhtmlscraper)](https://pypi.org/project/parallelhtmlscraper/)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/parallelhtmlscraper)](https://pypi.org/project/parallelhtmlscraper/)
+[![Twitter URL](https://img.shields.io/twitter/url?style=social&url=https%3A%2F%2Fgithub.com%2Fyukihiko-shinoda%2Fparallel-html-scraper)](http://twitter.com/share?text=Parallel%20HTML%20Scraper&url=https://pypi.org/project/parallelhtmlscraper/&hashtags=python)
+
+Helps you to web scrape html file in parallel without async / await syntax.
+
+## Feature
+
+This project helps you to web scrape html file in parallel without async / await syntax.
+
+## Installation
+
+```console
+pip install parallelhtmlscraper
+```
+
+## Usage
+
+Minimum example:
+
+```python
+from bs4 import BeautifulSoup
+
+from parallelhtmlscraper.html_analyzer import HtmlAnalyzer
+from parallelhtmlscraper.parallel_html_scraper import ParallelHtmlScraper
+
+class AnalyzerExample(HtmlAnalyzer):
+    async def execute(self, soup: BeautifulSoup) -> str:
+        return soup.find('title').text
+
+host_google = 'https://www.google.com'
+path_and_content = [
+    '',                                                           # Google Search
+    '/imghp?hl=EN',                                               # Google Images
+    '/shopping?hl=en',                                            # Google Shopping
+    '/save',                                                      # Collection
+    'https://www.google.com/maps?hl=en',                          # Google Maps
+    'https://www.google.com/drive/apps.html',                     # Google drive
+    'https://www.google.com/mail/help/intl/en/about.html?vm=r',   # GMail
+]
+
+list_response = ParallelHtmlScraper.execute(host_google, path_and_content, AnalyzerExample())
+print(list_response)
+```
+
+```console
+$ python test.py
+['\n      Gmail - Email from Google\n    ', 'Google Images', '  Google Maps  ', 'Using Google Drive - New Features, Benefits & Advantages of Google Cloud Storage', 'Google Shopping', 'Google', 'Collections']
+```
+
+## API
+
+### ParallelMediaDownloader.execute
+
+```python
+class ParallelHtmlScraper:
+    """API of parallel HTML scraping."""
+
+    @staticmethod
+    def execute(
+        base_url: str,
+        list_url: Iterable[str],
+        analyzer: HtmlAnalyzer[_T],
+        *,
+        limit: int = 5
+        interval: int = 1
+    ) -> List[_T]:
+```
+
+#### base_url: str
+
+Common part of request URL.
+This will be help to download URLs got from HTML.
+
+#### list_url: Iterable[str]
+
+List of URL. Method will download them in parallel.
+Absolute URL having same base URL as `base_url` also can be specified.
+
+#### analyzer: HtmlAnalyzer[_T]
+
+The instance extends `HtmlAnalyzer` to analyze HTML by using [BeautifulSoup](https://pypi.org/project/beautifulsoup4/).
+Following example will be help to understand its roll:
+
+```python
+class AnalyzerExample(HtmlAnalyzer):
+    async def execute(self, soup: BeautifulSoup) -> str:
+        return soup.find('title').text
+```
+
+#### limit: int = 5
+
+Limit number of parallel processes.
+
+#### interval: int = 1
+
+Interval between each request(second).

parallelhtmlscraper-0.2.0/parallelhtmlscraper/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (C) 2019 Yukihiko Shinoda
+"""Helps to scrape html file."""
+
+from parallelhtmlscraper.exceptions import Error
+from parallelhtmlscraper.exceptions import HttpTimeoutError
+from parallelhtmlscraper.html_analyzer import HtmlAnalyzer
+from parallelhtmlscraper.parallel_html_scraper import ParallelHtmlScraper
+
+__version__ = "0.2.0"
+
+__all__ = ["Error", "HtmlAnalyzer", "HttpTimeoutError", "ParallelHtmlScraper"]

{parallelhtmlscraper-0.0.0 → parallelhtmlscraper-0.2.0}/parallelhtmlscraper/exceptions.py

@@ -1,18 +1,20 @@
-"""This module implements exceptions for this package."""
-__all__ = ['Error', 'HttpTimeoutError']
-
-
-class Error(Exception):
-    """
-    Base class for exceptions in this module.
-    @see https://docs.python.org/3/tutorial/errors.html#user-defined-exceptions
-    """
-
-
-class HttpTimeoutError(Error):
-    def __init__(self, *args, url: str):
-        super().__init__(*args)
-        self.url = url
-
-    def __str__(self) -> str:
-        return f'HttpTimeoutError. URL = {self.url}'
+# Copyright (C) 2019 Yukihiko Shinoda
+"""This module implements exceptions for this package."""
+
+__all__ = ["Error", "HttpTimeoutError"]
+
+
+class Error(Exception):
+    """Base class for exceptions in this module.
+
+    @see https://docs.python.org/3/tutorial/errors.html#user-defined-exceptions
+    """
+
+
+class HttpTimeoutError(Error):
+    def __init__(self, url: str) -> None:
+        super().__init__(url)
+        self.url = url
+
+    def __str__(self) -> str:
+        return f"HttpTimeoutError. URL = {self.url}"

parallelhtmlscraper-0.2.0/parallelhtmlscraper/html_analyzer.py

@@ -0,0 +1,22 @@
+# Copyright (C) 2019 Yukihiko Shinoda
+"""Base classes of HTML analyzer."""
+
+from __future__ import annotations
+
+from abc import ABC
+from typing import TYPE_CHECKING
+from typing import Generic
+from typing import TypeVar
+
+if TYPE_CHECKING:
+    from bs4 import BeautifulSoup
+
+__all__ = ["HtmlAnalyzer"]
+
+# noinspection PyShadowingBuiltins
+_T = TypeVar("_T")
+
+
+class HtmlAnalyzer(ABC, Generic[_T]):
+    async def execute(self, soup: BeautifulSoup) -> _T:
+        raise NotImplementedError

parallelhtmlscraper-0.2.0/parallelhtmlscraper/html_request_coroutine.py

@@ -0,0 +1,75 @@
+# Copyright (C) 2019 Yukihiko Shinoda
+"""Controlls traffic of parallel processes for HTML request."""
+
+from __future__ import annotations
+
+import asyncio
+from logging import getLogger
+from typing import TYPE_CHECKING
+from typing import TypeVar
+
+from aiohttp import ClientTimeout
+
+from parallelhtmlscraper.exceptions import HttpTimeoutError
+from parallelhtmlscraper.html_text_load_coroutine import HtmlTextLoadCoroutine
+
+if TYPE_CHECKING:
+    from aiohttp import ClientSession
+    from bs4 import BeautifulSoup
+
+    from parallelhtmlscraper.html_analyzer import HtmlAnalyzer
+
+# noinspection PyShadowingBuiltins
+_T = TypeVar("_T")
+
+
+class HtmlRequestCoroutine:
+    """Controlls traffic of parallel processes for HTML request."""
+
+    # ↓ Reason: Based on experience
+    SEMAPHORE_MAX_VALUE = 5
+    # ↓ Reason: Librahack incident @see https://www.google.com/search?q=Librahack%E4%BA%8B%E4%BB%B6
+    MINIMUM_INTERVAL_REQUEST = 1
+    # ↓ Reason: Based on experience
+    TIME_OUT = 30
+    # ↓ Reason: Based on experience
+    INTERVAL_ACCESS_TO_RESPONSE_BODY = 0.12
+
+    def __init__(self, *, semaphore: asyncio.Semaphore | None = None) -> None:
+        self.semaphore = asyncio.Semaphore(self.SEMAPHORE_MAX_VALUE) if semaphore is None else semaphore
+        self.semaphore_for_interval = asyncio.Semaphore(1)
+        self.logger = getLogger(__name__)
+
+    async def execute(
+        self,
+        client_session: ClientSession,
+        url: str,
+        analyzer: HtmlAnalyzer[_T],
+        *,
+        interval: int = MINIMUM_INTERVAL_REQUEST,
+    ) -> _T:
+        """Request the URL with limiting the number of parallel requests and the interval between them."""
+        await self._acquire_slot(interval)
+        try:
+            soup = await self._request(client_session, url)
+        finally:
+            self.semaphore.release()
+        return await analyzer.execute(soup)
+
+    async def _acquire_slot(self, interval: int) -> None:
+        async with self.semaphore_for_interval:
+            # Waits for a free slot while holding the interval lock
+            # so that the next request can't start until this one has started.
+            await asyncio.sleep(interval)
+            await self.semaphore.acquire()
+
+    async def _request(self, client_session: ClientSession, url: str) -> BeautifulSoup:
+        try:
+            response = await client_session.get(url, timeout=ClientTimeout(total=self.TIME_OUT))
+        except asyncio.TimeoutError as error:
+            raise HttpTimeoutError(url=url) from error
+        # ↓ Because response raises error when access to response body too fast
+        await asyncio.sleep(self.INTERVAL_ACCESS_TO_RESPONSE_BODY)
+        response.raise_for_status()
+        self.logger.info("status = %s", response.status)
+        return await HtmlTextLoadCoroutine.execute(response)

parallelhtmlscraper-0.2.0/parallelhtmlscraper/html_text_load_coroutine.py

@@ -0,0 +1,33 @@
+# Copyright (C) 2019 Yukihiko Shinoda
+"""Parser for response body to BeautifulSoup."""
+
+from __future__ import annotations
+
+from logging import getLogger
+from typing import TYPE_CHECKING
+
+from bs4 import BeautifulSoup
+
+if TYPE_CHECKING:
+    from aiohttp import ClientResponse
+
+
+class HtmlTextLoadCoroutine:
+    """Parser for response body to BeautifulSoup."""
+
+    LOGGER = getLogger(__name__)
+
+    @classmethod
+    async def execute(cls, response: ClientResponse) -> BeautifulSoup:
+        return BeautifulSoup(await cls._execute(response), "html.parser")
+
+    @classmethod
+    async def _execute(cls, response: ClientResponse) -> str:
+        try:
+            return await response.text()
+        except UnicodeDecodeError:
+            # if response header includes no encoding information,
+            # aiohttp try to detect encoding by chardet.
+            # However chardet doesn't support Emoji.
+            cls.LOGGER.exception("UnicodeDecodeError. URL = %s, encoding = %s", response.url, response.get_encoding())
+        return await response.text("utf-8")

parallelhtmlscraper-0.2.0/parallelhtmlscraper/parallel_html_request_coroutine.py

@@ -0,0 +1,48 @@
+# Copyright (C) 2019 Yukihiko Shinoda
+"""Executes HTML requests as parallel."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+from typing import TypeVar
+
+import aiohttp
+
+from parallelhtmlscraper.html_request_coroutine import HtmlRequestCoroutine
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from parallelhtmlscraper.html_analyzer import HtmlAnalyzer
+
+# noinspection PyShadowingBuiltins
+_T = TypeVar("_T")
+
+
+class ParallelHtmlRequestCoroutine:
+    """Executes HTML requests as parallel."""
+
+    @staticmethod
+    async def execute(
+        base_url: str,
+        list_url: Iterable[str],
+        analyzer: HtmlAnalyzer[_T],
+        *,
+        semaphore: asyncio.Semaphore | None = None,
+        interval: int = HtmlRequestCoroutine.MINIMUM_INTERVAL_REQUEST,
+    ) -> list[_T]:
+        """Execute HTML requests in parallel."""
+        semaphore = asyncio.Semaphore(HtmlRequestCoroutine.SEMAPHORE_MAX_VALUE) if semaphore is None else semaphore
+        html_request_coroutine = HtmlRequestCoroutine(semaphore=semaphore)
+        async with aiohttp.ClientSession() as session:
+            tasks = [
+                html_request_coroutine.execute(
+                    session,
+                    url if base_url in url else f"{base_url}{url}",
+                    analyzer,
+                    interval=interval,
+                )
+                for url in list_url
+            ]
+            return await asyncio.gather(*tasks)

parallelhtmlscraper-0.2.0/parallelhtmlscraper/parallel_html_scraper.py

@@ -0,0 +1,64 @@
+# Copyright (C) 2019 Yukihiko Shinoda
+"""API of parallel HTML scraping."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+from typing import TypeVar
+
+from parallelhtmlscraper.html_request_coroutine import HtmlRequestCoroutine
+from parallelhtmlscraper.parallel_html_request_coroutine import ParallelHtmlRequestCoroutine
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable
+
+    from parallelhtmlscraper.html_analyzer import HtmlAnalyzer
+
+__all__ = ["ParallelHtmlScraper"]
+# noinspection PyShadowingBuiltins
+_T = TypeVar("_T")
+
+
+class ParallelHtmlScraper:
+    """API of parallel HTML scraping.
+
+    Following steps hasn't implemented:
+    - don't follow link when a tag has rel="nofollow"
+    - Follow attributes of robots meta tag
+    - Follow X-Robots-Tag in HTTP header
+    - Follow robots.txt
+    - Set User-agent and etc...
+    @see https://vaaaaaanquish.hatenablog.com/entry/2017/12/01/064227
+    """
+
+    @staticmethod
+    def execute(
+        base_url: str,
+        list_url: Iterable[str],
+        analyzer: HtmlAnalyzer[_T],
+        *,
+        limit: int = HtmlRequestCoroutine.SEMAPHORE_MAX_VALUE,
+        interval: int = HtmlRequestCoroutine.MINIMUM_INTERVAL_REQUEST,
+    ) -> list[_T]:
+        """Execute parallel HTML scraping."""
+        return asyncio.run(ParallelHtmlScraper._execute(base_url, list_url, analyzer, limit=limit, interval=interval))
+
+    @staticmethod
+    async def _execute(
+        base_url: str,
+        list_url: Iterable[str],
+        analyzer: HtmlAnalyzer[_T],
+        *,
+        limit: int,
+        interval: int,
+    ) -> list[_T]:
+        # Reason: Before Python 3.10, asyncio.Semaphore binds the event loop when instantiated,
+        # so it has to be instantiated in the event loop which asyncio.run() creates.
+        return await ParallelHtmlRequestCoroutine.execute(
+            base_url,
+            list_url,
+            analyzer,
+            semaphore=asyncio.Semaphore(limit),
+            interval=interval,
+        )