webscout 7.3__py3-none-any.whl → 7.4__py3-none-any.whl

webscout/Provider/PI.py

@@ -1,4 +1,4 @@
-
+from uuid import uuid4
 import cloudscraper
 import json
 import re
@@ -10,7 +10,6 @@ from webscout.AIutel import AwesomePrompts
 from webscout.AIbase import Provider
 from typing import Dict, Union, Any, Optional
 from webscout import LitAgent
-from webscout.Litlogger import Logger, LogFormat
 
 class PiAI(Provider):
     """
@@ -21,10 +20,21 @@ class PiAI(Provider):
         AVAILABLE_VOICES (Dict[str, int]): Available voice options for audio responses
     """
 
+    AVAILABLE_VOICES: Dict[str, int] = {
+        "voice1": 1,
+        "voice2": 2,
+        "voice3": 3,
+        "voice4": 4,
+        "voice5": 5,
+        "voice6": 6,
+        "voice7": 7,
+        "voice8": 8
+    }
+
     def __init__(
         self,
         is_conversation: bool = True,
-        max_tokens: int = 600,
+        max_tokens: int = 2048,
         timeout: int = 30,
         intro: str = None,
         filepath: str = None,
@@ -32,21 +42,29 @@ class PiAI(Provider):
         proxies: dict = {},
         history_offset: int = 10250,
         act: str = None,
-        logging: bool = False,
+        voice: bool = False,
+        voice_name: str = "voice3",
+        output_file: str = "PiAI.mp3"
     ):
         """
-        Initializes the PiAI provider with specified parameters.
+        Initializes PiAI with voice support.
+        
+        Args:
+            voice (bool): Enable/disable voice output
+            voice_name (str): Name of the voice to use (if None, uses default)
+            output_file (str): Path to save voice output (default: PiAI.mp3)
         """
+        # Voice settings
+        self.voice_enabled = voice
+        self.voice_name = voice_name
+        self.output_file = output_file
+
+        if voice and voice_name and voice_name not in self.AVAILABLE_VOICES:
+            raise ValueError(f"Voice '{voice_name}' not available. Choose from: {list(self.AVAILABLE_VOICES.keys())}")
+
+        # Initialize other attributes
         self.scraper = cloudscraper.create_scraper()
         self.url = 'https://pi.ai/api/chat'
-        self.AVAILABLE_VOICES: Dict[str, str] = {
-            "William": 1,
-            "Samantha": 2,
-            "Peter": 3,
-            "Amy": 4,
-            "Alice": 5,
-            "Harry": 6
-        }
         self.headers = {
             'Accept': 'text/event-stream',
             'Accept-Encoding': 'gzip, deflate, br, zstd',
@@ -65,14 +83,15 @@ class PiAI(Provider):
             'X-Api-Version': '3'
         }
         self.cookies = {
-            '__Host-session': 'Ca5SoyAMJEaaB79jj1T69',
-            '__cf_bm': 'g07oaL0jcstNfKDyZv7_YFjN0jnuBZjbMiXOWhy7V7A-1723536536-1.0.1.1-xwukd03L7oIAUqPG.OHbFNatDdHGZ28mRGsbsqfjBlpuy.b8w6UZIk8F3knMhhtNzwo4JQhBVdtYOlG0MvAw8A'
+            '__cf_bm': uuid4().hex
         }
 
         self.session = requests.Session()
+        self.session.headers.update(self.headers)
+        self.session.proxies = proxies
+
         self.is_conversation = is_conversation
         self.max_tokens_to_sample = max_tokens
-        self.stream_chunk_size = 64
         self.timeout = timeout
         self.last_response = {} if self.is_conversation else {'text': ""}
         self.conversation_id = None
@@ -82,37 +101,26 @@ class PiAI(Provider):
             for method in dir(Optimizers)
             if callable(getattr(Optimizers, method)) and not method.startswith("__")
         )
-        self.session.headers.update(self.headers)
+
+        # Setup conversation
         Conversation.intro = (
             AwesomePrompts().get_act(
                 act, raise_not_found=True, default=None, case_insensitive=True
-            )
-            if act
-            else intro or Conversation.intro
+            ) if act else intro or Conversation.intro
         )
         self.conversation = Conversation(
             is_conversation, self.max_tokens_to_sample, filepath, update_file
         )
         self.conversation.history_offset = history_offset
         self.session.proxies = proxies
-
-        self.logger = Logger(name="PiAI", format=LogFormat.MODERN_EMOJI) if logging else None
-        
-        self.knowledge_cutoff = "December 2023"
         
         if self.is_conversation:
             self.start_conversation()
 
-        if self.logger:
-            self.logger.info("PiAI instance initialized successfully")
-
     def start_conversation(self) -> str:
         """
         Initializes a new conversation and returns the conversation ID.
         """
-        if self.logger:
-            self.logger.debug("Starting new conversation")
-            
         response = self.scraper.post(
             "https://pi.ai/api/chat/start",
             headers=self.headers,
@@ -122,33 +130,44 @@ class PiAI(Provider):
         )
         
         if not response.ok:
-            if self.logger:
-                self.logger.error(f"Failed to start conversation. Status code: {response.status_code}")
             raise Exception(f"Failed to start conversation: {response.status_code}")
             
         data = response.json()
         self.conversation_id = data['conversations'][0]['sid']
         
-        if self.logger:
-            self.logger.info(f"Conversation started successfully with ID: {self.conversation_id}")
-            
         return self.conversation_id
 
     def ask(
         self,
         prompt: str,
-        voice_name: Optional[str] = None,
         stream: bool = False,
         raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
+        voice: bool = None,
+        voice_name: str = None,
         output_file: str = None
     ) -> dict:
         """
         Interact with Pi.ai by sending a prompt and receiving a response.
+        
+        Args:
+            prompt (str): The prompt to send
+            stream (bool): Whether to stream the response
+            raw (bool): Return raw response format
+            optimizer (str): Prompt optimizer to use
+            conversationally (bool): Use conversation context
+            voice (bool): Override default voice setting
+            voice_name (str): Override default voice name
+            output_file (str): Override default output file path
         """
-        if self.logger:
-            self.logger.debug(f"Processing request - Prompt: {prompt[:50]}... Voice: {voice_name}")
+        # Voice configuration
+        voice = self.voice_enabled if voice is None else voice
+        voice_name = self.voice_name if voice_name is None else voice_name
+        output_file = self.output_file if output_file is None else output_file
+
+        if voice and voice_name and voice_name not in self.AVAILABLE_VOICES:
+            raise ValueError(f"Voice '{voice_name}' not available. Choose from: {list(self.AVAILABLE_VOICES.keys())}")
 
         conversation_prompt = self.conversation.gen_complete_prompt(prompt)
         if optimizer:
@@ -157,18 +176,14 @@ class PiAI(Provider):
                     conversation_prompt if conversationally else prompt
                 )
             else:
-                if self.logger:
-                    self.logger.error(f"Invalid optimizer requested: {optimizer}")
-                raise Exception(
-                    f"Optimizer is not one of {self.__available_optimizers}"
-                )
+                raise Exception(f"Optimizer is not one of {self.__available_optimizers}")
 
         data = {
             'text': conversation_prompt,
             'conversation': self.conversation_id
         }
 
-        def for_stream():
+        def process_stream():
             response = self.scraper.post(
                 self.url, 
                 headers=self.headers, 
@@ -179,15 +194,13 @@ class PiAI(Provider):
             )
             
             if not response.ok:
-                if self.logger:
-                    self.logger.error(f"API request failed. Status code: {response.status_code}")
                 raise Exception(f"API request failed: {response.status_code}")
 
             output_str = response.content.decode('utf-8')
             sids = re.findall(r'"sid":"(.*?)"', output_str)
             second_sid = sids[1] if len(sids) >= 2 else None
 
-            if voice_name and second_sid:
+            if voice and voice_name and second_sid:
                 threading.Thread(
                     target=self.download_audio_threaded, 
                     args=(voice_name, second_sid, output_file)
@@ -204,65 +217,74 @@ class PiAI(Provider):
                             self.last_response.update(resp)
                             yield parsed_data if raw else resp
                     except json.JSONDecodeError:
-                        if self.logger:
-                            self.logger.warning("Failed to parse JSON from stream")
                         continue
 
             self.conversation.update_chat_history(
                 prompt, self.get_message(self.last_response)
             )
 
-        def for_non_stream():
-            for _ in for_stream():
+        if stream:
+            return process_stream()
+        else:
+            # For non-stream, collect all responses and return the final one
+            for res in process_stream():
                 pass
             return self.last_response
 
-        return for_stream() if stream else for_non_stream()
-
     def chat(
         self,
         prompt: str,
-        voice_name: Optional[str] = None,
         stream: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
-        output_file: str = "PiAi.mp3"
+        voice: bool = None,
+        voice_name: str = None,
+        output_file: str = None
     ) -> str:
         """
         Generates a response based on the provided prompt.
+        
+        Args:
+            prompt (str): The prompt to send
+            stream (bool): Whether to stream the response
+            optimizer (str): Prompt optimizer to use
+            conversationally (bool): Use conversation context
+            voice (bool): Override default voice setting
+            voice_name (str): Override default voice name
+            output_file (str): Override default output file path
         """
-        if self.logger:
-            self.logger.debug(f"Chat request initiated - Prompt: {prompt[:50]}...")
+        # Use instance defaults if not specified
+        voice = self.voice_enabled if voice is None else voice
+        voice_name = self.voice_name if voice_name is None else voice_name
+        output_file = self.output_file if output_file is None else output_file
 
-        if voice_name and voice_name not in self.AVAILABLE_VOICES:
-            if self.logger:
-                self.logger.error(f"Invalid voice requested: {voice_name}")
-            raise ValueError(f"Voice '{voice_name}' not one of [{', '.join(self.AVAILABLE_VOICES.keys())}]")
-
-        def for_stream():
-            for response in self.ask(
-                prompt, 
-                voice_name, 
-                True, 
-                optimizer=optimizer, 
-                conversationally=conversationally,
-                output_file=output_file
-            ):
-                yield self.get_message(response).encode('utf-8').decode('utf-8')
+        if voice and voice_name and voice_name not in self.AVAILABLE_VOICES:
+            raise ValueError(f"Voice '{voice_name}' not available. Choose from: {list(self.AVAILABLE_VOICES.keys())}")
 
-        def for_non_stream():
-            return self.get_message(
-                self.ask(
+        if stream:
+            def stream_generator():
+                for response in self.ask(
                     prompt,
-                    voice_name,
-                    False,
+                    stream=True,
                     optimizer=optimizer,
                     conversationally=conversationally,
+                    voice=voice,
+                    voice_name=voice_name,
                     output_file=output_file
-                )
-            ).encode('utf-8').decode('utf-8')
-
-        return for_stream() if stream else for_non_stream()
+                ):
+                    yield self.get_message(response).encode('utf-8').decode('utf-8')
+            return stream_generator()
+        else:
+            response = self.ask(
+                prompt,
+                stream=False,
+                optimizer=optimizer,
+                conversationally=conversationally,
+                voice=voice,
+                voice_name=voice_name,
+                output_file=output_file
+            )
+            return self.get_message(response)
 
     def get_message(self, response: dict) -> str:
         """Retrieves message only from response"""
@@ -271,9 +293,6 @@ class PiAI(Provider):
 
     def download_audio_threaded(self, voice_name: str, second_sid: str, output_file: str) -> None:
         """Downloads audio in a separate thread."""
-        if self.logger:
-            self.logger.debug(f"Starting audio download - Voice: {voice_name}, SID: {second_sid}")
-
         params = {
             'mode': 'eager',
             'voice': f'voice{self.AVAILABLE_VOICES[voice_name]}',
@@ -290,8 +309,6 @@ class PiAI(Provider):
             )
             
             if not audio_response.ok:
-                if self.logger:
-                    self.logger.error(f"Audio download failed. Status code: {audio_response.status_code}")
                 return
                 
             audio_response.raise_for_status()
@@ -299,16 +316,12 @@ class PiAI(Provider):
             with open(output_file, "wb") as file:
                 file.write(audio_response.content)
                 
-            if self.logger:
-                self.logger.info(f"Audio file successfully downloaded to: {output_file}")
-                
-        except requests.exceptions.RequestException as e:
-            if self.logger:
-                self.logger.error(f"Audio download failed: {str(e)}")
+        except requests.exceptions.RequestException:
+            pass
 
 if __name__ == '__main__':
     from rich import print
-    ai = PiAI(logging=True)
+    ai = PiAI()
     response = ai.chat(input(">>> "), stream=True)
     for chunk in response:
         print(chunk, end="", flush=True)