webscout 8.3.4__py3-none-any.whl → 8.3.5__py3-none-any.whl

webscout/Provider/TypliAI.py

@@ -33,7 +33,7 @@ class TypliAI(Provider):
         >>> print(response)
         'I don't have access to real-time weather information...'
     """
-    AVAILABLE_MODELS = ["free-no-sign-up-chatgpt"]
+    AVAILABLE_MODELS = ["gpt-4o-mini"]
 
     def __init__(
         self,
@@ -47,7 +47,7 @@ class TypliAI(Provider):
         history_offset: int = 10250,
         act: str = None,
         system_prompt: str = "You are a helpful assistant.",
-        model: str = "free-no-sign-up-chatgpt"
+        model: str = "gpt-4o-mini"
     ):
         """
         Initializes the TypliAI API with given parameters.
@@ -119,16 +119,6 @@ class TypliAI(Provider):
         self.conversation.history_offset = history_offset
 
 
-    @staticmethod
-    def _typli_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
-        """Extracts content from the Typli.ai stream format '0:"..."'."""
-        if isinstance(chunk, str):
-            match = re.search(r'0:"(.*?)"', chunk)
-            if match:
-                # Decode potential unicode escapes like \u00e9
-                content = match.group(1).encode().decode('unicode_escape')
-                return content.replace('\\\\', '\\').replace('\\"', '"') # Handle escaped backslashes and quotes
-        return None
 
     def ask(
         self,
@@ -182,7 +172,7 @@ class TypliAI(Provider):
                     ]
                 }
             ],
-            "slug": self.model
+            "slug": "free-no-sign-up-chatgpt"
         }
 
         def for_stream():
@@ -202,13 +192,21 @@ class TypliAI(Provider):
                     raise exceptions.FailedToGenerateResponseError(error_msg)
 
                 streaming_response = ""
-                # Use sanitize_stream with the custom extractor
+                # Use sanitize_stream with extract_regexes
                 processed_stream = sanitize_stream(
                     data=response.iter_content(chunk_size=None), # Pass byte iterator
                     intro_value=None, # No simple prefix like 'data:'
                     to_json=False,    # Content is extracted as string, not JSON object per line
-                    content_extractor=self._typli_extractor, # Use the specific extractor
-                    skip_markers=["f:{", "e:{", "d:{", "8:[", "2:["] # Skip metadata lines based on observed format
+                    extract_regexes=[r'0:"(.*?)"'], # Extract content from '0:"..."' format
+                    skip_regexes=[
+                        r'^f:\{.*\}$',  # Skip metadata lines starting with f:{
+                        r'^e:\{.*\}$',  # Skip metadata lines starting with e:{
+                        r'^d:\{.*\}$',  # Skip metadata lines starting with d:{
+                        r'^8:\[.*\]$',  # Skip metadata lines starting with 8:[
+                        r'^2:\[.*\]$',  # Skip metadata lines starting with 2:[
+                        r'^\s*$'        # Skip empty lines
+                    ],
+                    raw=raw  # Pass the raw parameter to sanitize_stream
                 )
 
                 for content_chunk in processed_stream:
@@ -244,6 +242,7 @@ class TypliAI(Provider):
         self,
         prompt: str,
         stream: bool = False,
+        raw: bool = False,
         optimizer: str = None,
         conversationally: bool = False,
     ) -> Union[str, Generator[str, None, None]]:
@@ -253,6 +252,7 @@ class TypliAI(Provider):
         Args:
             prompt (str): The prompt to send to the API.
             stream (bool): Whether to stream the response.
+            raw (bool): Whether to return the raw response.
             optimizer (str): Optimizer to use for the prompt.
             conversationally (bool): Whether to generate the prompt conversationally.
 
@@ -262,19 +262,25 @@ class TypliAI(Provider):
 
         def for_stream():
             for response in self.ask(
-                prompt, True, optimizer=optimizer, conversationally=conversationally
+                prompt, True, raw=raw, optimizer=optimizer, conversationally=conversationally
             ):
-                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,
-                )
+            result = self.ask(
+                prompt,
+                False,
+                raw=raw,
+                optimizer=optimizer,
+                conversationally=conversationally,
             )
+            if raw:
+                return result
+            else:
+                return self.get_message(result)
 
         return for_stream() if stream else for_non_stream()
 
@@ -290,7 +296,7 @@ class TypliAI(Provider):
         """
         assert isinstance(response, dict), "Response should be of dict data-type only"
         # Ensure text exists before processing
-        return response.get("text", "")
+        return response.get("text", "").replace('\\n', '\n').replace('\\n\\n', '\n\n')
 
 
 
@@ -298,7 +304,7 @@ if __name__ == "__main__":
     from rich import print
     try:
         ai = TypliAI(timeout=60)
-        response = ai.chat("Write a short poem about AI", stream=True)
+        response = ai.chat("Write a short poem about AI", stream=True, raw=False)
         for chunk in response:
             print(chunk, end="", flush=True)
     except Exception as e:

webscout/Provider/UNFINISHED/PERPLEXED_search.py

@@ -0,0 +1,254 @@
+import requests
+import json
+from typing import Any, Dict, Generator, Optional, Union
+
+from webscout.AIbase import AISearch, SearchResponse
+from webscout import exceptions
+from webscout.litagent import LitAgent
+from webscout.AIutel import sanitize_stream
+
+
+class PERPLEXED(AISearch):
+    """A class to interact with the PERPLEXED stream search API.
+    
+    PERPLEXED provides an AI-powered search interface that returns emotionally intelligent
+    responses based on web content. It supports both streaming and non-streaming responses.
+    
+    Basic Usage:
+        >>> from webscout import PERPLEXED
+        >>> ai = PERPLEXED()
+        >>> # Non-streaming example
+        >>> response = ai.search("What is Python?")
+        >>> print(response)
+        Python is a high-level programming language...
+        
+        >>> # Streaming example
+        >>> for chunk in ai.search("Tell me about AI", stream=True):
+        ...     print(chunk, end="", flush=True)
+        Artificial Intelligence is...
+        
+        >>> # Raw response format
+        >>> for chunk in ai.search("Hello", stream=True, raw=True):
+        ...     print(chunk)
+        {'text': 'Hello'}
+        {'text': ' there!'}
+    
+    Args:
+        timeout (int, optional): Request timeout in seconds. Defaults to 30.
+        proxies (dict, optional): Proxy configuration for requests. Defaults to None.
+    
+    Attributes:
+        api_endpoint (str): The PERPLEXED API endpoint URL.
+        stream_chunk_size (int): Size of chunks when streaming responses.
+        timeout (int): Request timeout in seconds.
+        headers (dict): HTTP headers used in requests.
+    """
+
+    def __init__(
+        self,
+        timeout: int = 30,
+        proxies: Optional[dict] = None,
+    ):
+        """Initialize the PERPLEXED API client.
+        
+        Args:
+            timeout (int, optional): Request timeout in seconds. Defaults to 30.
+            proxies (dict, optional): Proxy configuration for requests. Defaults to None.
+        
+        Example:
+            >>> ai = PERPLEXED(timeout=60)  # Longer timeout
+            >>> ai = PERPLEXED(proxies={'http': 'http://proxy.com:8080'})  # With proxy
+        """
+        self.session = requests.Session()
+        self.api_endpoint = "https://d21l5c617zttgr.cloudfront.net/stream_search"
+        self.stream_chunk_size = 64
+        self.timeout = timeout
+        self.last_response = {}
+        self.headers = {
+            "accept": "*/*",
+            "accept-encoding": "gzip, deflate, br, zstd",
+            "accept-language": "en-US,en;q=0.9,en-IN;q=0.8",
+            "content-type": "application/json",
+            "dnt": "1",
+            "origin": "https://d37ozmhmvu2kcg.cloudfront.net",
+            "referer": "https://d37ozmhmvu2kcg.cloudfront.net/",
+            "sec-ch-ua": '"Not)A;Brand";v="8", "Chromium";v="138", "Microsoft Edge";v="138"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": '"Windows"',
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "cross-site",
+            "sec-gpc": "1",
+            "user-agent": LitAgent().random()
+        }
+        self.session.headers.update(self.headers)
+        self.proxies = proxies
+
+    def search(
+        self,
+        prompt: str,
+        stream: bool = False,
+        raw: bool = False,
+    ) -> Union[SearchResponse, Generator[Union[Dict[str, str], SearchResponse], None, None]]:
+        """Search using the PERPLEXED API and get AI-generated responses.
+        
+        This method sends a search query to PERPLEXED and returns the AI-generated response.
+        It supports both streaming and non-streaming modes, as well as raw response format.
+        
+        Args:
+            prompt (str): The search query or prompt to send to the API.
+            stream (bool, optional): If True, yields response chunks as they arrive.
+                                   If False, returns complete response. Defaults to False.
+            raw (bool, optional): If True, returns raw response dictionaries with 'text' key.
+                                If False, returns SearchResponse objects that convert to text automatically.
+                                Defaults to False.
+        
+        Returns:
+            Union[SearchResponse, Generator[Union[Dict[str, str], SearchResponse], None, None]]: 
+                - If stream=False: Returns complete response as SearchResponse object
+                - If stream=True: Yields response chunks as either Dict or SearchResponse objects
+        
+        Raises:
+            APIConnectionError: If the API request fails
+        
+        Examples:
+            Basic search:
+            >>> ai = PERPLEXED()
+            >>> response = ai.search("What is Python?")
+            >>> print(response)
+            Python is a programming language...
+            
+            Streaming response:
+            >>> for chunk in ai.search("Tell me about AI", stream=True):
+            ...     print(chunk, end="")
+            Artificial Intelligence...
+            
+            Raw response format:
+            >>> for chunk in ai.search("Hello", stream=True, raw=True):
+            ...     print(chunk)
+            {'text': 'Hello'}
+            {'text': ' there!'}
+            
+            Error handling:
+            >>> try:
+            ...     response = ai.search("My question")
+            ... except exceptions.APIConnectionError as e:
+            ...     print(f"API error: {e}")
+        """
+        payload = {
+            "user_prompt": prompt
+        }
+
+        def extract_answer_content(data):
+            """Extract answer content from PERPLEXED response."""
+            print(f"[DEBUG] extract_answer_content received: {type(data)}")
+            if isinstance(data, dict):
+                print(f"[DEBUG] Dict keys: {list(data.keys())}")
+                print(f"[DEBUG] success: {data.get('success')}")
+                print(f"[DEBUG] stage: {data.get('stage')}")
+                print(f"[DEBUG] answer present: {'answer' in data}")
+                answer_val = data.get('answer', 'NOT_FOUND')
+                print(f"[DEBUG] answer value: {repr(answer_val[:100] if isinstance(answer_val, str) and len(answer_val) > 100 else answer_val)}")
+                
+                # Check if this is the final answer - answer field exists and is not empty
+                if data.get("success") and "answer" in data and data["answer"]:
+                    print(f"[DEBUG] Returning answer content (length: {len(data['answer'])})")
+                    return data["answer"]
+                # Check if this is a stage update with no answer yet
+                elif data.get("success") and data.get("stage"):
+                    print(f"[DEBUG] Skipping stage update: {data.get('stage')}")
+                    return None  # Skip stage updates without answers
+                else:
+                    print(f"[DEBUG] No matching condition, returning None")
+            else:
+                print(f"[DEBUG] Data is not dict, returning None")
+            return None
+
+        def for_stream():
+            try:
+                with self.session.post(
+                    self.api_endpoint,
+                    json=payload,
+                    stream=True,
+                    timeout=self.timeout,
+                    proxies=self.proxies,
+                ) as response:
+                    if not response.ok:
+                        raise exceptions.APIConnectionError(
+                            f"Failed to generate response - ({response.status_code}, {response.reason}) - {response.text}"
+                        )
+
+                    # Process the streaming response manually
+                    full_response = ""
+                    for line in response.iter_lines(decode_unicode=True):
+                        if line:
+                            full_response += line
+
+                    # Split by the separator to get individual JSON chunks
+                    chunks = full_response.split("[/PERPLEXED-SEPARATOR]")
+                    
+                    for chunk_text in chunks:
+                        if chunk_text.strip():
+                            try:
+                                # Parse the JSON chunk
+                                chunk_data = json.loads(chunk_text.strip())
+                                
+                                if raw:
+                                    # For raw mode, yield the entire JSON string
+                                    yield {"text": chunk_text.strip()}
+                                else:
+                                    # For non-raw mode, extract the answer if available
+                                    answer_content = extract_answer_content(chunk_data)
+                                    if answer_content:
+                                        yield SearchResponse(answer_content)
+                                        
+                            except json.JSONDecodeError:
+                                # Skip invalid JSON chunks
+                                continue
+
+            except requests.exceptions.RequestException as e:
+                raise exceptions.APIConnectionError(f"Request failed: {e}")
+
+        def for_non_stream():
+            if raw:
+                # For raw mode, yield each chunk as it comes
+                for chunk in for_stream():
+                    yield chunk
+            else:
+                # For non-raw mode, accumulate all chunks and return final response
+                full_response = ""
+                for chunk in for_stream():
+                    full_response += str(chunk)
+                
+                if full_response:
+                    self.last_response = SearchResponse(full_response)
+                else:
+                    # Return empty response if no content was extracted
+                    self.last_response = SearchResponse("")
+                
+                return self.last_response
+        
+        if stream:
+            return for_stream()
+        else:
+            # For non-streaming mode, we need to consume the generator and return the result
+            result = for_non_stream()
+            # If result is a generator (which it shouldn't be), consume it
+            if hasattr(result, '__iter__') and not isinstance(result, (str, bytes)):
+                try:
+                    # This shouldn't happen with our current implementation, but just in case
+                    return list(result)[0] if list(result) else SearchResponse("")
+                except:
+                    return SearchResponse("")
+            return result
+
+
+if __name__ == "__main__":
+    from rich import print
+    ai = PERPLEXED()
+    
+    # Test with raw=False to see debug output
+    print("=== Testing with raw=False ===")
+    response = ai.search(input(">>> "), stream=False, raw=False)
+    print("Final response:", response)
+    print("Response type:", type(response))

webscout/Provider/UNFINISHED/fetch_together_models.py

@@ -49,11 +49,11 @@ def fetch_together_models():
                 print(f"Model: {model_id}")
                 print(f"  Type: {model_type}")
                 print(f"  Context Length: {context_length}")
-                if model.get("config"):
-                    config = model["config"]
-                    if config.get("stop"):
-                        print(f"  Stop Tokens: {config['stop']}")
-                print("-" * 40)
+                # if model.get("config"):
+                #     config = model["config"]
+                #     if config.get("stop"):
+                #         print(f"  Stop Tokens: {config['stop']}")
+                # print("-" * 40)
         
         print(f"\nSUMMARY:")
         print(f"Chat Models: {len(chat_models)}")
@@ -87,9 +87,4 @@ if __name__ == "__main__":
     result = fetch_together_models()
     
     if result:
-        print(f"\n📊 Successfully fetched {len(result['all_models'])} models from Together.xyz")
-        
-        # Save to file
-        with open("together_models.json", "w") as f:
-            json.dump(result, f, indent=2)
-        print("✅ Results saved to together_models.json")
+        print(f"\n📊 Successfully fetched {len(result['all_models'])} models from Together.xyz")

webscout/Provider/Venice.py

@@ -20,6 +20,7 @@ class Venice(Provider):
     AVAILABLE_MODELS = [
         "mistral-31-24b",
         "dolphin-3.0-mistral-24b",
+        "dolphin-3.0-mistral-24b-1dot1",
         "qwen2dot5-coder-32b",
         "deepseek-coder-v2-lite",
 

webscout/Provider/WiseCat.py

@@ -76,16 +76,6 @@ class WiseCat(Provider):
         )
         self.conversation.history_offset = history_offset
 
-    @staticmethod
-    def _wisecat_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
-        """Extracts content from the WiseCat stream format '0:"..."'."""
-        if isinstance(chunk, str):
-            match = re.search(r'0:"(.*?)"', chunk)
-            if match:
-                # Decode potential unicode escapes like \u00e9
-                content = match.group(1).encode().decode('unicode_escape')
-                return content.replace('\\\\', '\\').replace('\\"', '"') # Handle escaped backslashes and quotes
-        return None
 
     def ask(
         self,
@@ -138,19 +128,27 @@ class WiseCat(Provider):
                     data=response.iter_content(chunk_size=None),
                     intro_value=None,
                     to_json=False,
-                    content_extractor=self._wisecat_extractor,
+                    extract_regexes=[
+                        r'0:"(.*?)"'  # Extract content from 0:"..." format
+                    ],
+                    skip_regexes=[
+                        r'\(\d+\.?\d*s\)',  # Skip timing information like (0.3s), (1s), (0.5s)
+                        r'\(\d+\.?\d*ms\)', # Skip millisecond timing like (300ms)
+                    ],
                     raw=raw
                 )
                 for content_chunk in processed_stream:
-                    # Always yield as string, even in raw mode
-                    if isinstance(content_chunk, bytes):
-                        content_chunk = content_chunk.decode('utf-8', errors='ignore')
-                    if raw:
-                        yield content_chunk
-                    else:
-                        if content_chunk and isinstance(content_chunk, str):
-                            streaming_text += content_chunk
-                            yield dict(text=content_chunk)
+                    if content_chunk and isinstance(content_chunk, str):
+                        # Content is already extracted by sanitize_stream
+                        # Handle unicode escaping and quote unescaping
+                        extracted_content = content_chunk.encode().decode('unicode_escape')
+                        extracted_content = extracted_content.replace('\\\\', '\\').replace('\\"', '"')
+                        
+                        if raw:
+                            yield extracted_content
+                        else:
+                            streaming_text += extracted_content
+                            yield dict(text=extracted_content)
                 self.last_response.update(dict(text=streaming_text))
                 self.conversation.update_chat_history(
                     prompt, self.get_message(self.last_response)

webscout/Provider/__init__.py

@@ -34,7 +34,6 @@ from .llmchatco import LLMChatCo  # Add new LLMChat.co provider
 from .talkai import *
 from .llama3mitril import *
 from .Marcus import *
-from .typegpt import *
 from .multichat import *
 from .Jadve import *
 from .chatglm import *
@@ -54,7 +53,6 @@ from .Venice import *
 from .GithubChat import *
 from .copilot import *
 from .sonus import *
-from .uncovr import *
 from .LambdaChat import *
 from .ChatGPTClone import *
 from .VercelAI import *
@@ -68,7 +66,6 @@ from .scira_chat import *
 from .StandardInput import *
 from .toolbaz import Toolbaz
 from .scnet import SCNet
-from .WritingMate import WritingMate
 from .MCPCore import MCPCore
 from .TypliAI import TypliAI
 from .ChatSandbox import ChatSandbox
@@ -116,7 +113,6 @@ __all__ = [
     'AllenAI',
     'PerplexityLabs',
     'AkashGPT',
-    'WritingMate',
     'WiseCat',
     'IBMGranite',
     'QwenLM',
@@ -160,7 +156,6 @@ __all__ = [
     'Talkai',
     'Llama3Mitril',
     'Marcus',
-    'TypeGPT',
     'Netwrck',
     'MultiChatAI',
     'JadveOpenAI',
@@ -168,7 +163,6 @@ __all__ = [
     'NousHermes',
     'FreeAIChat',
     'GithubChat',
-    'UncovrAI',
     'VercelAI',
     'ExaChat',
     'AskSteve',

webscout/Provider/scira_chat.py

@@ -43,6 +43,8 @@ class SciraAI(Provider):
         "claude-4-opus-20250514": "scira-opus",
         "claude-4-opus-20250514-pro": "scira-opus-pro",
         "meta-llama/llama-4-maverick-17b-128e-instruct": "scira-llama-4",
+        "kimi-k2-instruct": "scira-kimi-k2",
+        "scira-kimi-k2": "kimi-k2-instruct",
     }
     
     # Reverse mapping: Scira format to actual model names
@@ -57,6 +59,8 @@ class SciraAI(Provider):
     SCIRA_TO_MODEL["scira-qwen-30b"] = "qwen3-30b-a3b"
     SCIRA_TO_MODEL["scira-deepseek-v3"] = "deepseek-v3-0324"
     SCIRA_TO_MODEL["scira-grok-4"] = "grok-4"
+    SCIRA_TO_MODEL["scira-kimi-k2"] = "kimi-k2-instruct"
+    SCIRA_TO_MODEL["kimi-k2-instruct"] = "scira-kimi-k2"
     MODEL_MAPPING["claude-4-opus-20250514-pro"] = "scira-opus-pro"
     # Available models list (actual model names + scira aliases)
     AVAILABLE_MODELS = list(MODEL_MAPPING.keys()) + list(SCIRA_TO_MODEL.keys())

webscout/Provider/toolbaz.py

@@ -37,8 +37,9 @@ class Toolbaz(Provider):
         "Qwen2.5-72B",
         "grok-2-1212",
         "grok-3-beta",
-        "toolbaz_v3.5_pro",
         "toolbaz_v3",
+        "toolbaz_v3.5_pro",
+        "toolbaz_v4",
         "mixtral_8x22b",
         "L3-70B-Euryale-v2.1",
         "midnight-rose",
@@ -112,12 +113,6 @@ class Toolbaz(Provider):
         )
         self.conversation.history_offset = history_offset
 
-    @staticmethod
-    def _toolbaz_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
-        """Removes [model:...] tags from a string chunk."""
-        if isinstance(chunk, str):
-            return re.sub(r"\[model:.*?\]", "", chunk)
-        return None
 
     def random_string(self, length):
         return ''.join(random.choices(string.ascii_letters + string.digits, k=length))
@@ -217,14 +212,14 @@ class Toolbaz(Provider):
 
                 streaming_text = ""
 
-                # Use sanitize_stream with the custom extractor
+                # Use sanitize_stream with skip_regexes to remove [model:...] tags
                 # It will decode bytes and yield processed string chunks
                 processed_stream = sanitize_stream(
                     data=resp.iter_content(chunk_size=None), # Pass byte iterator
                     intro_value=None, # No simple prefix
                     to_json=False,    # Content is text
-                    content_extractor=self._toolbaz_extractor, # Use the tag remover
-                    yield_raw_on_error=True, # Yield even if extractor somehow fails (though unlikely for regex)
+                    skip_regexes=[r"\[model:.*?\]"], # Skip [model:...] tags
+                    yield_raw_on_error=True, # Yield even if regex processing fails
                     raw=raw
                 )
 

webscout/Provider/typefully.py

@@ -71,16 +71,6 @@ class TypefullyAI(Provider):
         )
         self.conversation.history_offset = history_offset
 
-    @staticmethod
-    def _typefully_extractor(chunk: Union[str, Dict[str, Any]]) -> Optional[str]:
-        if isinstance(chunk, str):
-            if isinstance(chunk, bytes):
-                chunk = chunk.decode('utf-8', errors='replace')
-            match = re.search(r'0:"(.*?)"', chunk)
-            if match:
-                content = match.group(1).encode().decode('unicode_escape')
-                return content.replace('\\', '\\').replace('\\"', '"')
-        return None
 
     def ask(
         self,
@@ -125,7 +115,7 @@ class TypefullyAI(Provider):
                     data=response.iter_content(chunk_size=None),
                     intro_value=None,
                     to_json=False,
-                    content_extractor=self._typefully_extractor,
+                    extract_regexes=[r'0:"(.*?)"'],
                     raw=raw
                 )
                 for content_chunk in processed_stream:

webscout/__init__.py

@@ -17,17 +17,9 @@ from .litagent import LitAgent
 from .scout import *
 from .zeroart import *
 from .yep_search import *
+from .AIutel import *
 
-# Import litprinter components for direct access from webscout (uncomment if needed)
-# from .litprinter import lit, litprint, ic, install, uninstall
-
-# Import sanitize_stream and lit_streamer for easy access
-from .AIutel import sanitize_stream, lit_streamer, LITSTREAM
-
-agent = LitAgent()
-
-__repo__ = "https://github.com/OE-LUCIFER/Webscout"
-
+useragent = LitAgent()
 # Add update checker
 from .update_checker import check_for_updates
 try:
@@ -36,9 +28,5 @@ try:
         print(update_message)
 except Exception:
     pass  # Silently handle any update check errors
-
-import logging
-logging.getLogger("webscout").addHandler(logging.NullHandler())
-
 # Import models for easy access
-from .models import model
+from .models import model