janito 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

janito/tools/bash/win_persistent_bash.py

@@ -0,0 +1,308 @@
+import subprocess
+import os
+import platform
+import time
+import uuid
+import sys
+import io
+import codecs
+
+class PersistentBash:
+    """
+    A wrapper class that maintains a persistent Bash session.
+    Allows sending commands and collecting output without restarting Bash.
+    """
+    
+    def __init__(self, bash_path=None):
+        """
+        Initialize a persistent Bash session.
+        
+        Args:
+            bash_path (str, optional): Path to the Bash executable. If None, tries to detect automatically.
+                                      This can be configured in Janito's config using the gitbash_path setting.
+        """
+        self.process = None
+        self.bash_path = bash_path
+        
+        # Configure UTF-8 support for Windows
+        if platform.system() == "Windows":
+            # Force UTF-8 mode in Python 3.7+
+            os.environ["PYTHONUTF8"] = "1"
+            
+            # Set Python's standard IO encoding to UTF-8
+            if hasattr(sys.stdout, 'reconfigure'):
+                sys.stdout.reconfigure(encoding='utf-8')
+            if hasattr(sys.stderr, 'reconfigure'):
+                sys.stderr.reconfigure(encoding='utf-8')
+            if hasattr(sys.stdin, 'reconfigure'):
+                sys.stdin.reconfigure(encoding='utf-8')
+                
+            # Ensure Windows console is in UTF-8 mode
+            try:
+                # Try to set console mode to UTF-8
+                os.system("chcp 65001 > nul")
+                
+                # Redirect stdout through a UTF-8 writer
+                sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace', line_buffering=True)
+                sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace', line_buffering=True)
+            except Exception as e:
+                print(f"Warning: Failed to set up UTF-8 encoding: {str(e)}")
+        
+        # If bash_path is not provided, try to detect it
+        if self.bash_path is None:
+            if platform.system() == "Windows":
+                # Common paths for Git Bash on Windows
+                possible_paths = [
+                    r"C:\Program Files\Git\bin\bash.exe",
+                    r"C:\Program Files (x86)\Git\bin\bash.exe",
+                ]
+                for path in possible_paths:
+                    if os.path.exists(path):
+                        self.bash_path = path
+                        break
+                if self.bash_path is None:
+                    raise FileNotFoundError("Could not find Git Bash executable. Please specify the path manually.")
+            else:
+                # On Unix-like systems, bash is usually in the PATH
+                self.bash_path = "bash"
+        
+        # Start the bash process
+        self.start_process()
+    
+    def start_process(self):
+        """Start the Bash process."""
+        # Create a subprocess with pipe for stdin, stdout, and stderr
+        bash_args = [self.bash_path]
+        
+        # Set UTF-8 codepage for Windows
+        env = os.environ.copy()
+        if platform.system() == "Windows":
+            # Set codepage to UTF-8 (65001) - run this before starting the process
+            os.system("chcp 65001 > nul")
+            # Set environment variables for proper UTF-8 handling
+            env["PYTHONIOENCODING"] = "utf-8"
+            env["PYTHONUTF8"] = "1"
+            # Add additional environment variables for Windows CMD
+            env["LANG"] = "en_US.UTF-8"
+            env["LC_ALL"] = "en_US.UTF-8"
+        
+        # Create the process with binary pipes for better control over encoding
+        if platform.system() == "Windows":
+            # On Windows, we need special handling for UTF-8
+            self.process = subprocess.Popen(
+                bash_args,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,  # Redirect stderr to stdout
+                bufsize=0,                # Unbuffered
+                universal_newlines=False, # Use binary mode
+                env=env                   # Pass the modified environment
+            )
+            
+            # Create UTF-8 wrappers for stdin/stdout
+            self.stdin = io.TextIOWrapper(self.process.stdin, encoding='utf-8', errors='replace', line_buffering=True)
+            self.stdout = io.TextIOWrapper(self.process.stdout, encoding='utf-8', errors='replace', line_buffering=True)
+        else:
+            # On Unix systems, the standard approach works fine
+            self.process = subprocess.Popen(
+                bash_args,
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,  # Redirect stderr to stdout
+                text=True,                # Use text mode for input/output
+                bufsize=0,                # Unbuffered
+                universal_newlines=True,  # Universal newlines mode
+                env=env,                  # Pass the modified environment
+                encoding='utf-8',         # Explicitly set encoding to UTF-8
+                errors='replace'          # Replace invalid characters instead of failing
+            )
+            self.stdin = self.process.stdin
+            self.stdout = self.process.stdout
+        
+        # Set up a more reliable environment
+        setup_commands = [
+            "export PS1='$ '",  # Simple prompt to avoid parsing issues
+            "export TERM=dumb",  # Disable color codes and other terminal features
+            "set +o history",  # Disable history
+            "shopt -s expand_aliases", # Enable alias expansion
+            "export LANG=en_US.UTF-8", # Set UTF-8 locale
+            "export LC_ALL=en_US.UTF-8", # Set all locale categories to UTF-8
+        ]
+        
+        # Additional setup for Windows to handle UTF-8
+        if platform.system() == "Windows":
+            setup_commands.extend([
+                # Force Git Bash to use UTF-8
+                "export LESSCHARSET=utf-8",
+                # Ensure proper display of Unicode characters
+                "export PYTHONIOENCODING=utf-8"
+            ])
+        
+        # Send setup commands
+        for cmd in setup_commands:
+            self._send_command(cmd)
+        
+        # Clear initial output with a marker
+        marker = f"INIT_COMPLETE_{uuid.uuid4().hex}"
+        self._send_command(f"echo {marker}")
+        
+        while True:
+            line = self.stdout.readline().strip()
+            if marker in line:
+                break
+    
+    def _send_command(self, command):
+        """Send a command to the Bash process without reading the output."""
+        if self.process is None or self.process.poll() is not None:
+            self.start_process()
+            
+        # Use our stdin wrapper instead of process.stdin directly
+        self.stdin.write(command + "\n")
+        self.stdin.flush()
+    
+    def execute(self, command, timeout=None):
+        """
+        Execute a command in the Bash session and return the output.
+        
+        Args:
+            command (str): The command to execute.
+            timeout (int, optional): Timeout in seconds. If None, no timeout is applied.
+            
+        Returns:
+            str: The command output.
+        """
+        if self.process is None or self.process.poll() is not None:
+            # Process has terminated, restart it
+            self.start_process()
+        
+        # Create a unique marker to identify the end of output
+        end_marker = f"END_OF_COMMAND_{uuid.uuid4().hex}"
+        
+        # Construct the wrapped command with echo markers
+        # Only use timeout when explicitly requested
+        if timeout is not None and timeout > 0:
+            # Check if timeout command is available
+            is_timeout_available = False
+            try:
+                check_cmd = "command -v timeout > /dev/null 2>&1 && echo available || echo unavailable"
+                self._send_command(check_cmd)
+                for _ in range(10):  # Read up to 10 lines to find the result
+                    line = self.stdout.readline().strip()
+                    if "available" in line:
+                        is_timeout_available = True
+                        break
+                    elif "unavailable" in line:
+                        is_timeout_available = False
+                        break
+            except:
+                is_timeout_available = False
+
+            if is_timeout_available:
+                # For timeout to work with shell syntax, we need to use bash -c
+                wrapped_command = f"timeout {timeout}s bash -c \"{command.replace('"', '\\"')}\" 2>&1; echo '{end_marker}'"
+            else:
+                wrapped_command = f"{command} 2>&1; echo '{end_marker}'"
+        else:
+            wrapped_command = f"{command} 2>&1; echo '{end_marker}'"
+        
+        # Send the command
+        self._send_command(wrapped_command)
+        
+        # Import the console here to avoid circular imports
+        from janito.tools.rich_console import console
+        
+        # Collect output until the end marker is found
+        output_lines = []
+        start_time = time.time()
+        max_wait = timeout if timeout is not None else 3600  # Default to 1 hour if no timeout
+        
+        while time.time() - start_time < max_wait + 5:  # Add buffer time
+            try:
+                line = self.stdout.readline().rstrip('\r\n')
+                if end_marker in line:
+                    break
+                    
+                # Print the output to the console in real-time if not in trust mode
+                if line:
+                    from janito.config import get_config
+                    if not get_config().trust_mode:
+                        console.print(line)
+                    
+                output_lines.append(line)
+            except UnicodeDecodeError as e:
+                # Handle potential UTF-8 decoding errors
+                error_msg = f"[Warning: Unicode decode error occurred: {str(e)}]"
+                console.print(error_msg, style="yellow")
+                output_lines.append(error_msg)
+                # Just continue with replacement character
+                continue
+            except Exception as e:
+                error_msg = f"[Error reading output: {str(e)}]"
+                console.print(error_msg, style="red")
+                output_lines.append(error_msg)
+                continue
+            
+        # Check for timeout
+        if time.time() - start_time >= max_wait + 5:
+            timeout_msg = f"Error: Command timed out after {max_wait} seconds"
+            console.print(timeout_msg, style="red bold")
+            output_lines.append(timeout_msg)
+            
+            # Try to reset the bash session after a timeout
+            self.close()
+            self.start_process()
+        
+        return "\n".join(output_lines)
+    
+    def windows_to_bash_path(self, windows_path):
+        """
+        Convert a Windows path to a Git Bash compatible path.
+        
+        Args:
+            windows_path (str): A Windows path like 'C:\\folder\\file.txt'
+            
+        Returns:
+            str: Git Bash compatible path like '/c/folder/file.txt'
+        """
+        if not windows_path or not platform.system() == "Windows":
+            return windows_path
+            
+        # Handle drive letter (e.g., C: -> /c)
+        if ":" in windows_path:
+            drive, path = windows_path.split(":", 1)
+            unix_path = f"/{drive.lower()}{path}"
+        else:
+            unix_path = windows_path
+            
+        # Convert backslashes to forward slashes
+        unix_path = unix_path.replace("\\", "/")
+        
+        # Remove any double slashes
+        while "//" in unix_path:
+            unix_path = unix_path.replace("//", "/")
+            
+        # If the path contains spaces, we need to escape them or quote the entire path
+        if " " in unix_path:
+            unix_path = f'"{unix_path}"'
+            
+        return unix_path
+    
+    def close(self):
+        """Close the Bash session."""
+        if self.process and self.process.poll() is None:
+            try:
+                self._send_command("exit")
+                self.process.wait(timeout=2)
+            except:
+                pass
+            finally:
+                try:
+                    self.process.terminate()
+                except:
+                    pass
+                
+        self.process = None
+    
+    def __del__(self):
+        """Destructor to ensure the process is closed."""
+        self.close()

janito/tools/decorators.py

@@ -2,9 +2,8 @@
 Decorators for janito tools.
 """
 import functools
-import inspect
 import string
-from typing import Any, Callable, Dict, Optional, Tuple
+from typing import Any, Callable, Dict, Optional
 
 
 class ToolMetaFormatter(string.Formatter):
@@ -83,19 +82,9 @@ def format_tool_label(func: Callable, tool_input: Dict[str, Any]) -> Optional[st
     # Get the label template
     label_template = func._tool_meta['label']
     
-    # Special handling for str_replace_editor which uses **kwargs
-    if func.__name__ == 'str_replace_editor':
-        # Extract command and file_path from tool_input if they exist
-        command = tool_input.get('command', 'unknown')
-        file_path = tool_input.get('file_path', '')
-        
-        # Simple string replacement for the common case
-        if '{command}' in label_template and '{file_path}' in label_template:
-            return label_template.replace('{command}', command).replace('{file_path}', file_path)
-    
     # Format the label with the parameters
     try:
         formatter = ToolMetaFormatter()
         return formatter.format(label_template, **tool_input)
-    except Exception as e:
+    except Exception:
         return f"{func.__name__}"

janito/tools/delete_file.py

@@ -1,15 +1,14 @@
 """
 Tool for deleting files through the claudine agent.
 """
-import os
 from pathlib import Path
-from typing import Dict, Any, Tuple
-from janito.config import get_config
+from typing import Tuple
 from janito.tools.str_replace_editor.utils import normalize_path
-from janito.tools.decorators import tool_meta
+from janito.tools.rich_console import print_info, print_success, print_error
+from janito.tools.usage_tracker import track_usage, get_tracker
 
 
-@tool_meta(label="Deleting file {file_path}")
+@track_usage('files_deleted')
 def delete_file(
     file_path: str,
 ) -> Tuple[str, bool]:
@@ -22,6 +21,7 @@ def delete_file(
     Returns:
         A tuple containing (message, is_error)
     """
+    print_info(f"Deleting file {file_path}", "Delete Operation")
     # Store the original path for display purposes
     original_path = file_path
     
@@ -33,15 +33,33 @@ def delete_file(
     
     # Check if the file exists
     if not path_obj.exists():
-        return (f"File {original_path} does not exist.", True)
+        error_msg = f"File {original_path} does not exist."
+        print_error(error_msg, "Error")
+        return (error_msg, True)
     
     # Check if it's a directory
     if path_obj.is_dir():
-        return (f"{original_path} is a directory, not a file. Use delete_directory for directories.", True)
+        error_msg = f"{original_path} is a directory, not a file. Use delete_directory for directories."
+        print_error(error_msg, "Error")
+        return (error_msg, True)
     
     # Delete the file
     try:
+        # Count the number of lines in the file before deleting
+        try:
+            with open(path_obj, 'r', encoding='utf-8') as f:
+                line_count = len(f.readlines())
+            # Track negative line delta for deleted file
+            get_tracker().increment('lines_delta', -line_count)
+        except Exception:
+            # If we can't read the file, we can't count lines
+            pass
+            
         path_obj.unlink()
-        return (f"Successfully deleted file {original_path}", False)
+        success_msg = f"Successfully deleted file {original_path}"
+        print_success("", "Success")
+        return (success_msg, False)
     except Exception as e:
-        return (f"Error deleting file {original_path}: {str(e)}", True)
+        error_msg = f"Error deleting file {original_path}: {str(e)}"
+        print_error(error_msg, "Error")
+        return (error_msg, True)

janito/tools/fetch_webpage/__init__.py

@@ -0,0 +1,34 @@
+"""
+Webpage Content Extractor Package
+
+A comprehensive tool for extracting clean, relevant content from web pages
+for processing with LLMs. Features include:
+- General content extraction with multiple methods
+- Specialized handling for news aggregator sites
+- Targeted extraction based on specific search strings
+- Chunking for large content
+- Structured content extraction
+
+Dependencies:
+- requests
+- beautifulsoup4
+- trafilatura
+- newspaper3k
+
+Author: Claude (Anthropic)
+"""
+
+from janito.tools.fetch_webpage.core import fetch_webpage, fetch_and_extract
+from janito.tools.fetch_webpage.news import fetch_and_extract_news_aggregator
+from janito.tools.fetch_webpage.extractors import extract_clean_text, extract_targeted_content, extract_structured_content
+from janito.tools.fetch_webpage.chunking import chunk_large_content
+
+__all__ = [
+    'fetch_webpage',
+    'fetch_and_extract',
+    'fetch_and_extract_news_aggregator',
+    'extract_clean_text',
+    'extract_targeted_content',
+    'extract_structured_content',
+    'chunk_large_content'
+]

janito/tools/fetch_webpage/chunking.py

@@ -0,0 +1,76 @@
+"""
+Functions for chunking large content into manageable pieces.
+"""
+
+from typing import List
+from janito.tools.rich_console import print_info, print_success
+
+
+def chunk_large_content(text: str, chunk_size: int = 4000, overlap: int = 500) -> List[str]:
+    """
+    Split very large text content into manageable chunks suitable for LLM processing.
+    
+    Args:
+        text: The text to chunk
+        chunk_size: Target size for each chunk in characters
+        overlap: Number of characters to overlap between chunks
+        
+    Returns:
+        List of text chunks
+    """
+    if not text or len(text) <= chunk_size:
+        return [text] if text else []
+    
+    print_info(f"Chunking {len(text)} characters of text into ~{chunk_size} character chunks", "Content Chunking")
+    
+    # Try to split on paragraph breaks first
+    paragraphs = text.split('\n\n')
+    chunks = []
+    current_chunk = ""
+    
+    for para in paragraphs:
+        # If adding this paragraph would exceed chunk size
+        if len(current_chunk) + len(para) + 2 > chunk_size:
+            # If current chunk is not empty, add it to chunks
+            if current_chunk:
+                chunks.append(current_chunk)
+                # Start new chunk with overlap from previous chunk
+                if overlap > 0 and len(current_chunk) > overlap:
+                    current_chunk = current_chunk[-overlap:] + "\n\n" + para
+                else:
+                    current_chunk = para
+            else:
+                # If paragraph itself is bigger than chunk size, split it
+                if len(para) > chunk_size:
+                    words = para.split()
+                    temp_chunk = ""
+                    for word in words:
+                        if len(temp_chunk) + len(word) + 1 > chunk_size:
+                            chunks.append(temp_chunk)
+                            # Start new chunk with overlap
+                            if overlap > 0 and len(temp_chunk) > overlap:
+                                temp_chunk = temp_chunk[-overlap:] + " " + word
+                            else:
+                                temp_chunk = word
+                        else:
+                            if temp_chunk:
+                                temp_chunk += " " + word
+                            else:
+                                temp_chunk = word
+                    if temp_chunk:
+                        current_chunk = temp_chunk
+                else:
+                    chunks.append(para)
+        else:
+            # Add paragraph to current chunk
+            if current_chunk:
+                current_chunk += "\n\n" + para
+            else:
+                current_chunk = para
+    
+    # Don't forget the last chunk
+    if current_chunk:
+        chunks.append(current_chunk)
+    
+    print_success(f"Text chunked into {len(chunks)} segments", "Content Chunking")
+    return chunks

janito/tools/fetch_webpage/core.py

@@ -0,0 +1,155 @@
+"""
+Core functionality for fetching web pages and extracting content.
+"""
+
+import requests
+from typing import Tuple, List, Optional
+from urllib.parse import urlparse
+from janito.tools.rich_console import print_info, print_success, print_error, print_warning
+from janito.tools.usage_tracker import track_usage
+
+from janito.tools.fetch_webpage.extractors import extract_clean_text
+# Import moved to fetch_and_extract function to avoid circular imports
+from janito.tools.fetch_webpage.utils import SITE_SPECIFIC_STRATEGIES
+
+
+@track_usage('web_requests')
+def fetch_webpage(url: str, headers: dict = None, timeout: int = 30, max_size: int = 5000000, 
+                 target_strings: List[str] = None) -> Tuple[str, bool]:
+    """
+    Fetch the content of a web page from a given URL.
+    
+    Args:
+        url: The URL of the web page to fetch
+        headers: Optional HTTP headers to include in the request (default: None)
+        timeout: Request timeout in seconds (default: 30)
+        max_size: Maximum size in bytes to download (default: 5MB)
+        target_strings: Optional list of strings to target specific content sections
+        
+    Returns:
+        A tuple containing (message, is_error)
+    """
+    print_info(f"Fetching content from URL: {url}", "Web Fetch")
+    
+    try:
+        # Set default headers if none provided
+        if headers is None:
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+            }
+        
+        # Make the HTTP request with streaming enabled
+        response = requests.get(url, headers=headers, timeout=timeout, stream=True)
+        
+        # Raise an exception for HTTP errors
+        response.raise_for_status()
+        
+        # Check content length before downloading fully
+        content_length = response.headers.get('Content-Length')
+        if content_length and int(content_length) > max_size:
+            warning_msg = f"Web Fetch: Content size ({int(content_length)/1000000:.1f}MB) exceeds max size ({max_size/1000000:.1f}MB). Aborting download."
+            print_warning(warning_msg)
+            return warning_msg, True
+            
+        # Download content with size limit
+        content_bytes = b''
+        for chunk in response.iter_content(chunk_size=1024 * 1024):  # 1MB chunks
+            content_bytes += chunk
+            if len(content_bytes) > max_size:
+                warning_msg = f"Web Fetch: Download exceeded max size ({max_size/1000000:.1f}MB). Truncating."
+                print_warning(warning_msg)
+                break
+                
+        # Get the content
+        content = content_bytes.decode('utf-8', errors='replace')
+        
+        # If target strings are provided, extract only the relevant sections
+        if target_strings and len(target_strings) > 0:
+            print_info(f"Targeting specific content using {len(target_strings)} search strings", "Web Fetch")
+            from janito.tools.fetch_webpage.extractors import extract_targeted_content
+            targeted_content = extract_targeted_content(content, target_strings)
+            
+            if targeted_content:
+                print_success(f"Successfully targeted specific content based on search strings", "Web Fetch")
+                # Create a summary with first 300 chars of targeted content
+                content_preview = targeted_content[:300] + "..." if len(targeted_content) > 300 else targeted_content
+                summary = f"Successfully fetched targeted content from {url}\n\nContent preview:\n{content_preview}"
+                print_success(f"Successfully fetched targeted content from {url} ({len(targeted_content)} bytes)", "Web Fetch")
+                return targeted_content, False
+            else:
+                print_warning(f"Web Fetch: Could not find content matching the target strings. Returning full content.")
+        
+        # Create a summary message with first 300 chars of content
+        content_preview = content[:300] + "..." if len(content) > 300 else content
+        
+        print_success(f"({len(content)} bytes)", "Web Fetch")
+        
+        # Return the full content
+        return content, False
+        
+    except requests.exceptions.RequestException as e:
+        error_msg = f"Error fetching web page: {str(e)}"
+        print_error(error_msg, "Web Fetch Error")
+        return error_msg, True
+
+
+@track_usage('web_content')
+def fetch_and_extract(url: str, extract_method: str = 'trafilatura', 
+                     max_length: int = 10000,
+                     target_strings: List[str] = None) -> Tuple[str, bool]:
+    """
+    Fetch a webpage and extract its main content in a format suitable for LLM processing.
+    
+    Args:
+        url: The URL to fetch
+        extract_method: Content extraction method ('trafilatura', 'newspaper', 'beautifulsoup', 'all')
+        max_length: Maximum length of text to return
+        target_strings: Optional list of strings to target specific content sections
+        
+    Returns:
+        A tuple containing (extracted_content, is_error)
+    """
+    # Check if this is a news aggregator site that needs special handling
+    domain = urlparse(url).netloc
+    for site_domain in SITE_SPECIFIC_STRATEGIES.keys():
+        if site_domain in domain:
+            print_info(f"Detected news aggregator site: {domain}. Using specialized extraction.", "Content Extraction")
+            # Import here to avoid circular imports
+            from janito.tools.fetch_webpage.news import fetch_and_extract_news_aggregator
+            return fetch_and_extract_news_aggregator(url)
+    
+    # If target strings are provided, pass them directly to fetch_webpage for efficiency
+    if target_strings and len(target_strings) > 0:
+        html_content, is_error = fetch_webpage(url, target_strings=target_strings)
+    else:
+        html_content, is_error = fetch_webpage(url)
+    
+    if is_error:
+        return html_content, True
+    
+    extracted_text = extract_clean_text(html_content, method=extract_method, url=url)
+    
+    if not extracted_text or len(extracted_text) < 100:
+        return f"Could not extract meaningful content from {url}", True
+        
+    # If target strings were provided but not already handled by fetch_webpage
+    if target_strings and len(target_strings) > 0 and not any(target in extracted_text for target in target_strings if len(target) > 3):
+        from janito.tools.fetch_webpage.extractors import extract_targeted_content
+        targeted_content = extract_targeted_content(html_content, target_strings)
+        if targeted_content:
+            print_success(f"Successfully extracted targeted content based on {len(target_strings)} search strings", 
+                         "Targeted Extraction")
+            extracted_text = targeted_content
+    
+    # Truncate if needed
+    if len(extracted_text) > max_length:
+        print_info(f"Truncating content from {len(extracted_text)} to {max_length} characters", "Content Extraction")
+        extracted_text = extracted_text[:max_length] + "..."
+        
+    # Check if the content is still too large for an LLM (rough estimate)
+    estimated_tokens = len(extracted_text.split())
+    if estimated_tokens > 10000:  # Conservative estimate for token limits
+        print_warning(f"Content Extraction: Extracted content still very large (~{estimated_tokens} words). Consider using chunk_large_content()")
+    
+    print_success(f"Successfully extracted {len(extracted_text)} characters of content", "Content Extraction")
+    return extracted_text, False