webscout 8.2.2__py3-none-any.whl → 2026.1.19__py3-none-any.whl

webscout/Provider/AISEARCH/iask_search.py

@@ -1,64 +1,17 @@
-import aiohttp
 import asyncio
-import lxml.html
 import re
 import urllib.parse
-from markdownify import markdownify as md
-from typing import Dict, Optional, Generator, Union, AsyncIterator, Literal
+from typing import Any, AsyncIterator, Dict, Generator, Literal, Optional, Union, cast
+
+import lxml.html
+from curl_cffi.requests import AsyncSession
 
-from webscout.AIbase import AISearch
 from webscout import exceptions
+from webscout.AIbase import AISearch, SearchResponse
+from webscout.litagent import LitAgent
 from webscout.scout import Scout
 
-
-class Response:
-    """A wrapper class for IAsk API responses.
-
-    This class automatically converts response objects to their text representation
-    when printed or converted to string.
-
-    Attributes:
-        text (str): The text content of the response
-
-    Example:
-        >>> response = Response("Hello, world!")
-        >>> print(response)
-        Hello, world!
-        >>> str(response)
-        'Hello, world!'
-    """
-    def __init__(self, text: str):
-        self.text = text
-
-    def __str__(self):
-        return self.text
-
-    def __repr__(self):
-        return self.text
-
-
-def cache_find(diff: Union[dict, list]) -> Optional[str]:
-    """Find HTML content in a nested dictionary or list structure.
-
-    Args:
-        diff (Union[dict, list]): The nested structure to search
-
-    Returns:
-        Optional[str]: The found HTML content, or None if not found
-    """
-    values = diff if isinstance(diff, list) else diff.values()
-    for value in values:
-        if isinstance(value, (list, dict)):
-            cache = cache_find(value)
-            if cache:
-                return cache
-        if isinstance(value, str) and re.search(r"<p>.+?</p>", value):
-            return md(value).strip()
-
-    return None
-
-
-ModeType = Literal["question", "academic", "fast", "forums", "wiki", "advanced"]
+ModeType = Literal["question", "academic", "forums", "wiki", "thinking"]
 DetailLevelType = Literal["concise", "detailed", "comprehensive"]
 
 
@@ -113,10 +66,17 @@ class IAsk(AISearch):
         self.proxies = proxies or {}
         self.default_mode = mode
         self.default_detail_level = detail_level
-        self.api_endpoint = "https://iask.ai/"
+        self.api_endpoint = "https://iask.ai"
+        self.query_endpoint = "https://iask.ai/q"
         self.last_response = {}
+        self.agent = LitAgent()
 
-    def create_url(self, query: str, mode: ModeType = "question", detail_level: Optional[DetailLevelType] = None) -> str:
+    def create_url(
+        self,
+        query: str,
+        mode: ModeType = "question",
+        detail_level: Optional[DetailLevelType] = None,
+    ) -> str:
         """Create a properly formatted URL with mode and detail level parameters.
 
         Args:
@@ -131,13 +91,10 @@ class IAsk(AISearch):
             >>> ai = IAsk()
             >>> url = ai.create_url("Climate change", mode="academic", detail_level="detailed")
             >>> print(url)
-            https://iask.ai/?mode=academic&q=Climate+change&options%5Bdetail_level%5D=detailed
+            https://iask.ai/q?mode=academic&q=Climate+change&options%5Bdetail_level%5D=detailed
         """
         # Create a dictionary of parameters with flattened structure
-        params = {
-            "mode": mode,
-            "q": query
-        }
+        params = {"mode": mode, "q": query}
 
         # Add detail_level if provided using the flattened format
         if detail_level:
@@ -145,7 +102,7 @@ class IAsk(AISearch):
 
         # Encode the parameters and build the URL
         query_string = urllib.parse.urlencode(params)
-        url = f"{self.api_endpoint}?{query_string}"
+        url = f"{self.query_endpoint}?{query_string}"
 
         return url
 
@@ -158,17 +115,19 @@ class IAsk(AISearch):
         Returns:
             str: Formatted text.
         """
-        scout = Scout(html_content, features='html.parser')
+        scout = Scout(html_content, features="html.parser")
         output_lines = []
 
-        for child in scout.find_all(['h1', 'h2', 'h3', 'p', 'ol', 'ul', 'div']):
+        for child in scout.find_all(["h1", "h2", "h3", "p", "ol", "ul", "div"]):
             if child.name in ["h1", "h2", "h3"]:
                 output_lines.append(f"\n**{child.get_text().strip()}**\n")
             elif child.name == "p":
                 text = child.get_text().strip()
-                text = re.sub(r"^According to Ask AI & Question AI www\.iAsk\.ai:\s*", "", text).strip()
+                text = re.sub(
+                    r"^According to Ask AI & Question AI www\.iAsk\.ai:\s*", "", text
+                ).strip()
                 # Remove footnote markers
-                text = re.sub(r'\[\d+\]\(#fn:\d+ \'see footnote\'\)', '', text)
+                text = re.sub(r"\[\d+\]\(#fn:\d+ \'see footnote\'\)", "", text)
                 output_lines.append(text + "\n")
             elif child.name in ["ol", "ul"]:
                 for li in child.find_all("li"):
@@ -189,7 +148,8 @@ class IAsk(AISearch):
         raw: bool = False,
         mode: Optional[ModeType] = None,
         detail_level: Optional[DetailLevelType] = None,
-    ) -> Union[Response, Generator[Union[Dict[str, str], Response], None, None]]:
+        **kwargs: Any,
+    ) -> Union[SearchResponse, Generator[Union[Dict[str, str], SearchResponse], None, None]]:
         """Search using the IAsk API and get AI-generated responses.
 
         This method sends a search query to IAsk and returns the AI-generated response.
@@ -236,9 +196,10 @@ class IAsk(AISearch):
             >>> print(response)
             Climate change refers to...
         """
-        # Use provided parameters or fall back to instance defaults
-        search_mode = mode or self.default_mode
-        search_detail_level = detail_level or self.default_detail_level
+        search_mode = cast(ModeType, mode or self.default_mode)
+        search_detail_level = cast(
+            Optional[DetailLevelType], detail_level or self.default_detail_level
+        )
 
         # For non-streaming, run the async search and return the complete response
         if not stream:
@@ -249,52 +210,84 @@ class IAsk(AISearch):
                 result = loop.run_until_complete(
                     self._async_search(prompt, False, raw, search_mode, search_detail_level)
                 )
-                return result
+                return cast(
+                    Union[
+                        SearchResponse, Generator[Union[Dict[str, str], SearchResponse], None, None]
+                    ],
+                    result,
+                )
             finally:
                 loop.close()
-
-        # For streaming, use a simpler approach with a single event loop
-        # that stays open until the generator is exhausted
         buffer = ""
 
         def sync_generator():
             nonlocal buffer
-            # Create a new event loop for this generator
+
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
 
             try:
                 # Get the async generator
-                async_gen_coro = self._async_search(prompt, True, raw, search_mode, search_detail_level)
+                async_gen_coro = self._async_search(
+                    prompt, True, raw, search_mode, search_detail_level
+                )
                 async_gen = loop.run_until_complete(async_gen_coro)
 
                 # Process chunks one by one
-                while True:
-                    try:
-                        # Get the next chunk
-                        chunk_coro = async_gen.__anext__()
-                        chunk = loop.run_until_complete(chunk_coro)
-
-                        # Update buffer and yield the chunk
-                        if isinstance(chunk, dict) and 'text' in chunk:
-                            buffer += chunk['text']
-                        elif isinstance(chunk, Response):
-                            buffer += chunk.text
-                        else:
-                            buffer += str(chunk)
-
-                        yield chunk
-                    except StopAsyncIteration:
-                        break
-                    except Exception as e:
-                        print(f"Error in generator: {e}")
-                        break
+                if hasattr(async_gen, "__anext__"):
+                    async_iterator = cast(AsyncIterator, async_gen)
+                    while True:
+                        try:
+                            # Get the next chunk
+                            chunk_coro = async_iterator.__anext__()
+                            chunk = loop.run_until_complete(chunk_coro)
+
+                            # Update buffer and yield the chunk
+                            if isinstance(chunk, dict) and "text" in chunk:
+                                buffer += chunk["text"]
+                            elif isinstance(chunk, SearchResponse):
+                                buffer += chunk.text
+                            else:
+                                buffer += str(chunk)
+
+                            yield chunk
+                        except StopAsyncIteration:
+                            break
+                        except Exception as e:
+                            print(f"Error in generator: {e}")
+                            break
+                elif isinstance(async_gen, SearchResponse):
+                    yield async_gen
+                else:
+                    yield str(async_gen)
             finally:
                 # Store the final response and close the loop
                 self.last_response = {"text": buffer}
                 loop.close()
 
-        return sync_generator()
+        return cast(
+            Union[SearchResponse, Generator[Union[Dict[str, str], SearchResponse], None, None]],
+            sync_generator(),
+        )
+
+    def _extract_answer(self, html_content: str) -> str:
+        """Extract and format the answer HTML from the results page."""
+        etree = lxml.html.fromstring(html_content)
+        text_nodes = etree.xpath('//*[@id="text"]')
+        if not text_nodes:
+            raise exceptions.APIConnectionError("No answer content found in iAsk response.")
+        text_node = text_nodes[0]
+        text_html = lxml.html.tostring(text_node, encoding="unicode", method="html")
+        return self.format_html(text_html).strip()
+
+    def _iter_chunks(self, text: str) -> Generator[str, None, None]:
+        """Yield a response string in readable chunks for streaming."""
+        for line in text.splitlines(keepends=True):
+            if line.strip() == "":
+                yield line
+                continue
+            for chunk in re.findall(r".{1,800}(?:\s+|$)", line):
+                yield chunk
 
     async def _async_search(
         self,
@@ -303,134 +296,62 @@ class IAsk(AISearch):
         raw: bool = False,
         mode: ModeType = "question",
         detail_level: Optional[DetailLevelType] = None,
-    ) -> Union[Response, AsyncIterator[Union[Dict[str, str], Response]]]:
+    ) -> Union[SearchResponse, str, AsyncIterator[Union[str, Dict[str, str], SearchResponse]]]:
         """Internal async implementation of the search method."""
 
-        async def stream_generator() -> AsyncIterator[str]:
-            async with aiohttp.ClientSession() as session:
-                # Prepare parameters
-                params = {"mode": mode, "q": prompt}
-                if detail_level:
-                    params["options[detail_level]"] = detail_level
-
-                try:
-                    async with session.get(
-                        self.api_endpoint,
-                        params=params,
-                        proxy=self.proxies.get('http') if self.proxies else None,
-                        timeout=self.timeout
-                    ) as response:
-                        if not response.ok:
-                            raise exceptions.APIConnectionError(
-                                f"Failed to generate response - ({response.status_code}, {response.reason}) - {await response.text()}"
-                            )
-
-                        etree = lxml.html.fromstring(await response.text())
-                        phx_node = etree.xpath('//*[starts-with(@id, "phx-")]').pop()
-                        csrf_token = (
-                            etree.xpath('//*[@name="csrf-token"]').pop().get("content")
-                        )
-
-                    async with session.ws_connect(
-                        f"{self.api_endpoint}live/websocket",
-                        params={
-                            "_csrf_token": csrf_token,
-                            "vsn": "2.0.0",
-                        },
-                        proxy=self.proxies.get('http') if self.proxies else None,
-                        timeout=self.timeout
-                    ) as wsResponse:
-                        await wsResponse.send_json(
-                            [
-                                None,
-                                None,
-                                f"lv:{phx_node.get('id')}",
-                                "phx_join",
-                                {
-                                    "params": {"_csrf_token": csrf_token},
-                                    "url": str(response.url),
-                                    "session": phx_node.get("data-phx-session"),
-                                },
-                            ]
-                        )
-                        while True:
-                            json_data = await wsResponse.receive_json()
-                            if not json_data:
-                                break
-                            diff: dict = json_data[4]
-                            try:
-                                chunk: str = diff["e"][0][1]["data"]
-                                # Check if the chunk contains HTML content
-                                if re.search(r"<[^>]+>", chunk):
-                                    formatted_chunk = self.format_html(chunk)
-                                    yield formatted_chunk
-                                else:
-                                    yield chunk.replace("<br/>", "\n")
-                            except:
-                                cache = cache_find(diff)
-                                if cache:
-                                    if diff.get("response", None):
-                                        # Format the cache content if it contains HTML
-                                        if re.search(r"<[^>]+>", cache):
-                                            formatted_cache = self.format_html(cache)
-                                            yield formatted_cache
-                                        else:
-                                            yield cache
-                                    break
-                except Exception as e:
-                    raise exceptions.APIConnectionError(f"Error connecting to IAsk API: {str(e)}")
+        async def fetch_answer() -> str:
+            timeout = self.timeout
+            params = {"mode": mode, "q": prompt}
+            if detail_level:
+                params["options[detail_level]"] = detail_level
+
+            headers = {
+                "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+                "User-Agent": self.agent.random(),
+            }
+
+            async with AsyncSession() as session:
+                response = await session.get(
+                    self.query_endpoint,
+                    params=params,
+                    headers=headers,
+                    proxies=self.proxies or None,
+                    timeout=timeout,
+                )
+            if response.status_code != 200:
+                raise exceptions.APIConnectionError(
+                    "Failed to generate response - "
+                    f"({response.status_code}, {response.reason}) - {response.text}"
+                )
+            return self._extract_answer(response.text)
 
         # For non-streaming, collect all chunks and return a single response
         if not stream:
-            buffer = ""
-            async for chunk in stream_generator():
-                buffer += chunk
-            self.last_response = {"text": buffer}
-            return Response(buffer) if not raw else {"text": buffer}
+            buffer = await fetch_answer()
+            self.last_response = SearchResponse(buffer)
+            return buffer if raw else self.last_response
 
         # For streaming, create an async generator that yields chunks
         async def process_stream():
             buffer = ""
-            async for chunk in stream_generator():
+            text = await fetch_answer()
+            for chunk in self._iter_chunks(text):
                 buffer += chunk
                 if raw:
-                    yield {"text": chunk}
+                    yield chunk
                 else:
-                    yield Response(chunk)
-            self.last_response = {"text": buffer}
+                    yield SearchResponse(chunk)
+            self.last_response = SearchResponse(buffer)
 
         # Return the async generator
         return process_stream()
 
 
 if __name__ == "__main__":
-    from rich import print
-
     ai = IAsk()
-
-    # Example 1: Simple search with default mode
-    print("\n[bold cyan]Example 1: Simple search with default mode[/bold cyan]")
-    response = ai.search("What is Python?", stream=True)
-    for chunk in response:
-        print(chunk, end="", flush=True)
-    print("\n\n[bold green]Response complete.[/bold green]\n")
-
-    # Example 2: Search with academic mode
-    print("\n[bold cyan]Example 2: Search with academic mode[/bold cyan]")
-    response = ai.search("Quantum computing applications", mode="academic", stream=True)
-    for chunk in response:
-        print(chunk, end="", flush=True)
-    print("\n\n[bold green]Response complete.[/bold green]\n")
-
-    # Example 3: Search with advanced mode and detailed level
-    print("\n[bold cyan]Example 3: Search with advanced mode and detailed level[/bold cyan]")
-    response = ai.search("Climate change solutions", mode="advanced", detail_level="detailed", stream=True)
-    for chunk in response:
-        print(chunk, end="", flush=True)
-    print("\n\n[bold green]Response complete.[/bold green]\n")
-
-    # Example 4: Demonstrating the create_url method
-    print("\n[bold cyan]Example 4: Generated URL for browser access[/bold cyan]")
-    url = ai.create_url("Helpingai details", mode="question", detail_level="detailed")
-    print(f"URL: {url}")
-    print("This URL can be used directly in a browser or with other HTTP clients.")
+    response = ai.search("What is Python?", stream=True, raw=True)
+    if hasattr(response, "__iter__") and not isinstance(response, (str, SearchResponse)):
+        for chunk in response:
+            print(chunk, end="", flush=True)
+    else:
+        print(response)