webscout 8.3.1__py3-none-any.whl → 8.3.3__py3-none-any.whl

webscout/Provider/TTS/speechma.py

@@ -1,15 +1,12 @@
 ##################################################################################
 ##  Modified version of code written by t.me/infip1217                          ##
 ##################################################################################
-import time
 import requests
 import pathlib
 import tempfile
-from io import BytesIO
 from webscout import exceptions
 from webscout.litagent import LitAgent
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from webscout.Provider.TTS import utils
+from webscout.Litlogger import Logger, LogLevel
 from webscout.Provider.TTS.base import BaseTTSProvider
 
 class SpeechMaTTS(BaseTTSProvider):
@@ -18,12 +15,11 @@ class SpeechMaTTS(BaseTTSProvider):
     """
     # Request headers
     headers = {
-        "accept": "*/*",
-        "accept-language": "en-IN,en-GB;q=0.9,en-US;q=0.8,en;q=0.7,en-AU;q=0.6",
-        "content-type": "application/json",
+        "authority": "speechma.com",
         "origin": "https://speechma.com",
-        "priority": "u=1, i",
-        "User-Agent": LitAgent().random()
+        "referer": "https://speechma.com/",
+        "content-type": "application/json",
+        **LitAgent().generate_fingerprint()
     }
 
     # Available voices with their IDs
@@ -496,8 +492,9 @@ class SpeechMaTTS(BaseTTSProvider):
         if proxies:
             self.session.proxies.update(proxies)
         self.timeout = timeout
+        self.logger = Logger(name="SpeechMaTTS", level=LogLevel.INFO)
 
-    def tts(self, text: str, voice: str = "Emma", pitch: int = 0, rate: int = 0) -> str:
+    def tts(self, text: str, voice: str = "Emma", pitch: int = 0, rate: int = 0, verbose: bool = False) -> str:
         """
         Converts text to speech using the SpeechMa API and saves it to a file.
 
@@ -506,6 +503,7 @@ class SpeechMaTTS(BaseTTSProvider):
             voice (str): The voice to use for TTS (default: "Emma")
             pitch (int): Voice pitch adjustment (-10 to 10, default: 0)
             rate (int): Voice rate/speed adjustment (-10 to 10, default: 0)
+            verbose (bool): Whether to print debug information (default: False)
 
         Returns:
             str: Path to the generated audio file
@@ -517,10 +515,13 @@ class SpeechMaTTS(BaseTTSProvider):
             voice in self.all_voices
         ), f"Voice '{voice}' not one of [{', '.join(self.all_voices.keys())}]"
 
+        if not text or text.strip() == '':
+            raise exceptions.FailedToGenerateResponseError("Text is empty")
+
         filename = pathlib.Path(tempfile.mktemp(suffix=".mp3", dir=self.temp_dir))
         voice_id = self.all_voices[voice]
 
-        # Prepare payload for the job-based API
+        # Prepare payload for the API
         payload = {
             "text": text,
             "voice": voice_id,
@@ -530,44 +531,49 @@ class SpeechMaTTS(BaseTTSProvider):
         }
 
         try:
+            # Set logger level based on verbose flag
+            if verbose:
+                self.logger.level = LogLevel.DEBUG
+                self.logger.debug(f"Generating audio for voice: {voice} ({voice_id})")
+                self.logger.debug(f"Text length: {len(text)} characters")
+            else:
+                self.logger.level = LogLevel.INFO
+
+            # Make the request to the SpeechMa API
             response = self.session.post(
                 self.api_url,
                 headers=self.headers,
                 json=payload,
                 timeout=self.timeout
             )
-            response.raise_for_status()
-            resp_json = response.json()
-            if not resp_json.get("success") or "data" not in resp_json or "job_id" not in resp_json["data"]:
-                raise exceptions.FailedToGenerateResponseError(f"SpeechMa API error: {resp_json}")
-            job_id = resp_json["data"]["job_id"]
 
-            # Poll for job completion
-            status_url = f"https://speechma.com/com.api/tts-api.php/status/{job_id}"
-            for _ in range(30):  # up to ~30 seconds
-                status_resp = self.session.get(
-                    status_url,
-                    headers=self.headers,
-                    timeout=self.timeout
-                )
-                status_resp.raise_for_status()
-                status_json = status_resp.json()
-                if status_json.get("success") and status_json.get("data", {}).get("status") == "completed":
-                    break
-                time.sleep(1)
-            else:
-                raise exceptions.FailedToGenerateResponseError("TTS job did not complete in time.")
+            if response.status_code != 200:
+                if verbose:
+                    self.logger.error(f"API error: Status {response.status_code}")
+                raise exceptions.FailedToGenerateResponseError(f"API returned status {response.status_code}: {response.text[:500]}")
 
-            # Download the audio file (API provides a URL in the status response)
-            data = status_json["data"]
-            audio_url = f"https://speechma.com/com.api/tts-api.php/audio/{job_id}"
-            audio_resp = self.session.get(audio_url, timeout=self.timeout)
-            audio_resp.raise_for_status()
-            with open(filename, 'wb') as f:
-                f.write(audio_resp.content)
-            return filename.as_posix()
+            # Check if response is audio data (content-type should be audio/mpeg)
+            content_type = response.headers.get('content-type', '').lower()
+            if verbose:
+                self.logger.debug(f"Response content type: {content_type}")
+                self.logger.debug(f"Response size: {len(response.content)} bytes")
+
+            if 'audio' in content_type or response.content.startswith(b'\xff\xfb') or response.content.startswith(b'ID3') or b'LAME' in response.content[:100]:
+                # This is audio data, save it directly
+                with open(filename, 'wb') as f:
+                    f.write(response.content)
+                if verbose:
+                    self.logger.debug(f"Audio saved to: {filename}")
+                return filename.as_posix()
+            else:
+                # Unexpected response format
+                if verbose:
+                    self.logger.error(f"Unexpected response format: {content_type}")
+                raise exceptions.FailedToGenerateResponseError(f"Unexpected response format. Content-Type: {content_type}, Content: {response.text[:200]}")
 
         except requests.exceptions.RequestException as e:
+            if verbose:
+                self.logger.error(f"Request failed: {e}")
             raise exceptions.FailedToGenerateResponseError(
                 f"Failed to perform the operation: {e}"
             )

webscout/Provider/TeachAnything.py

@@ -163,6 +163,7 @@ class TeachAnything(Provider):
         stream: bool = False, # Keep stream param for interface consistency
         optimizer: str = None,
         conversationally: bool = False,
+        raw: bool = False,  # Added raw parameter
     ) -> Union[str, Any]:
         """Generate response `str` or yield for streaming compatibility
         Args:
@@ -170,22 +171,29 @@ class TeachAnything(Provider):
             stream (bool, optional): Flag for streaming response. Defaults to False.
             optimizer (str, optional): Prompt optimizer name - `[code, shell_command]`. Defaults to None.
             conversationally (bool, optional): Chat conversationally when using optimizer. Defaults to False.
+            raw (bool, optional): If True, return raw string output.
         Returns:
             str or generator: Response generated
         """
         response_data = self.ask(
             prompt, 
             stream=False, # Call ask in non-stream mode internally
-            raw=False, # Ensure ask returns dict
+            raw=raw, # Pass raw flag
             optimizer=optimizer, 
             conversationally=conversationally
         )
         if stream:
             def stream_wrapper():
-                yield self.get_message(response_data)
+                if raw:
+                    yield response_data if isinstance(response_data, str) else self.get_message(response_data)
+                else:
+                    yield self.get_message(response_data)
             return stream_wrapper()
         else:
-            return self.get_message(response_data)
+            if raw:
+                return response_data if isinstance(response_data, str) else self.get_message(response_data)
+            else:
+                return self.get_message(response_data)
 
     def get_message(self, response: Union[dict, str]) -> str:
         """Retrieves message only from response

webscout/Provider/TextPollinationsAI.py

@@ -135,95 +135,98 @@ class TextPollinationsAI(Provider):
             payload["tool_choice"] = tool_choice
 
         def for_stream():
-            try: # Add try block for CurlError
-                # Use curl_cffi session post with impersonate
+            try:
                 response = self.session.post(
                     self.api_endpoint,
-                    # headers are set on the session
                     json=payload,
                     stream=True,
                     timeout=self.timeout,
-                    impersonate="chrome120" # Add impersonate
+                    impersonate="chrome120"
                 )
-
                 if not response.ok:
                     raise exceptions.FailedToGenerateResponseError(
                         f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
                     )
-
                 streaming_text = ""
-                # Use sanitize_stream
                 processed_stream = sanitize_stream(
-                    data=response.iter_content(chunk_size=None), # Pass byte iterator
+                    data=response.iter_content(chunk_size=None),
                     intro_value="data:",
-                    to_json=True,     # Stream sends JSON
+                    to_json=True,
                     skip_markers=["[DONE]"],
-                    # Extractor handles both content and tool_calls
                     content_extractor=lambda chunk: chunk.get('choices', [{}])[0].get('delta') if isinstance(chunk, dict) else None,
-                    yield_raw_on_error=False # Skip non-JSON or lines where extractor fails
+                    yield_raw_on_error=False,
+                    raw=raw
                 )
-
                 for delta in processed_stream:
-                    # delta is the extracted 'delta' object or None
-                    if delta and isinstance(delta, dict):
-                        if 'content' in delta and delta['content'] is not None:
-                            content = delta['content']
-                            streaming_text += content
-                            yield content if raw else dict(text=content)
-                        elif 'tool_calls' in delta:
-                            tool_calls = delta['tool_calls']
-                            yield tool_calls if raw else dict(tool_calls=tool_calls)
-
-                # Update history and last response after stream finishes
-                self.last_response.update(dict(text=streaming_text)) # Store aggregated text
-                if streaming_text: # Only update history if text was received
+                    if isinstance(delta, bytes):
+                        delta = delta.decode('utf-8', errors='ignore')
+                    if delta is None:
+                        continue
+                    if raw:
+                        # Only yield content or tool_calls as string
+                        if isinstance(delta, dict):
+                            if 'content' in delta and delta['content'] is not None:
+                                content = delta['content']
+                                streaming_text += content
+                                yield content
+                            elif 'tool_calls' in delta:
+                                tool_calls = delta['tool_calls']
+                                yield json.dumps(tool_calls)
+                        elif isinstance(delta, str):
+                            streaming_text += delta
+                            yield delta
+                    else:
+                        if isinstance(delta, dict):
+                            if 'content' in delta and delta['content'] is not None:
+                                content = delta['content']
+                                streaming_text += content
+                                yield dict(text=content)
+                            elif 'tool_calls' in delta:
+                                tool_calls = delta['tool_calls']
+                                yield dict(tool_calls=tool_calls)
+                self.last_response.update(dict(text=streaming_text))
+                if streaming_text:
                     self.conversation.update_chat_history(
-                        prompt, streaming_text # Use the fully aggregated text
+                        prompt, streaming_text
                     )
-            except CurlError as e: # Catch CurlError
+            except CurlError as e:
                 raise exceptions.FailedToGenerateResponseError(f"Request failed (CurlError): {e}") from e
-            except Exception as e: # Catch other potential exceptions
+            except Exception as e:
                 raise exceptions.FailedToGenerateResponseError(f"An unexpected error occurred ({type(e).__name__}): {e}") from e
-
-
         def for_non_stream():
-            # Aggregate the stream using the updated for_stream logic
             final_content = ""
-            tool_calls_aggregated = None # To store potential tool calls
-            try: # Add try block for potential errors during aggregation
+            tool_calls_aggregated = None
+            try:
                 for chunk_data in for_stream():
-                    if isinstance(chunk_data, dict):
-                        if "text" in chunk_data:
-                            final_content += chunk_data["text"]
-                        elif "tool_calls" in chunk_data:
-                            # Aggregate tool calls (simple aggregation, might need refinement)
+                    if raw:
+                        if isinstance(chunk_data, str):
+                            final_content += chunk_data
+                        elif isinstance(chunk_data, bytes):
+                            final_content += chunk_data.decode('utf-8', errors='ignore')
+                        elif isinstance(chunk_data, list):
                             if tool_calls_aggregated is None:
                                 tool_calls_aggregated = []
-                            tool_calls_aggregated.extend(chunk_data["tool_calls"])
-                    elif isinstance(chunk_data, str): # Handle raw stream case
-                        final_content += chunk_data
-                    # Handle raw tool calls list if raw=True
-                    elif isinstance(chunk_data, list) and raw:
-                         if tool_calls_aggregated is None:
-                             tool_calls_aggregated = []
-                         tool_calls_aggregated.extend(chunk_data)
+                            tool_calls_aggregated.extend(chunk_data)
+                    else:
+                        if isinstance(chunk_data, dict):
+                            if "text" in chunk_data:
+                                final_content += chunk_data["text"]
+                            elif "tool_calls" in chunk_data:
+                                if tool_calls_aggregated is None:
+                                    tool_calls_aggregated = []
+                                tool_calls_aggregated.extend(chunk_data["tool_calls"])
+                        elif isinstance(chunk_data, str):
+                            final_content += chunk_data
             except Exception as e:
-                 # If aggregation fails but some text was received, use it. Otherwise, re-raise.
-                 if not final_content and not tool_calls_aggregated:
-                     raise exceptions.FailedToGenerateResponseError(f"Failed to get non-stream response: {str(e)}") from e
-
-
-            # last_response and history are updated within for_stream (for text)
-            # Return a dict containing text and/or tool_calls
+                if not final_content and not tool_calls_aggregated:
+                    raise exceptions.FailedToGenerateResponseError(f"Failed to get non-stream response: {str(e)}") from e
             result = {}
             if final_content:
                 result["text"] = final_content
             if tool_calls_aggregated:
                 result["tool_calls"] = tool_calls_aggregated
-            self.last_response = result # Update last_response with aggregated result
-            return self.last_response
-
-
+            self.last_response = result
+            return self.last_response if not raw else (final_content if final_content else json.dumps(tool_calls_aggregated) if tool_calls_aggregated else "")
         return for_stream() if stream else for_non_stream()
 
     def chat(
@@ -234,27 +237,32 @@ class TextPollinationsAI(Provider):
         conversationally: bool = False,
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Dict[str, Any]] = None,
+        raw: bool = False,  # Added raw parameter
     ) -> Union[str, Generator[str, None, None]]:
         """Generate response as a string"""
         def for_stream():
             for response in self.ask(
-                prompt, True, optimizer=optimizer, conversationally=conversationally,
+                prompt, True, raw=raw, optimizer=optimizer, conversationally=conversationally,
                 tools=tools, tool_choice=tool_choice
             ):
-                yield self.get_message(response)
-
+                if raw:
+                    yield response
+                else:
+                    yield self.get_message(response)
         def for_non_stream():
-            return self.get_message(
-                self.ask(
-                    prompt,
-                    False,
-                    optimizer=optimizer,
-                    conversationally=conversationally,
-                    tools=tools,
-                    tool_choice=tool_choice,
-                )
+            result = self.ask(
+                prompt,
+                False,
+                raw=raw,
+                optimizer=optimizer,
+                conversationally=conversationally,
+                tools=tools,
+                tool_choice=tool_choice,
             )
-
+            if raw:
+                return result if isinstance(result, str) else (result.get("text", "") if isinstance(result, dict) else str(result))
+            else:
+                return self.get_message(result)
         return for_stream() if stream else for_non_stream()
 
     def get_message(self, response: dict) -> str: