Data

def _chunk_text(full_content: str, chunk_size: int) -> List[str]:
    """Split long content into reasonably sized chunks for model input."""
    chunks = []
    for i in range(0, len(full_content), chunk_size):
        chunk = full_content[i:i+chunk_size].strip()
        if chunk:
            chunks.append(chunk)
    return chunks

def _extract_audio_from_video(file_path: str, max_duration: int = 600) -> Optional[str]:
    """
    Use ffmpeg to dump the audio track from a video into a temp wav for transcription.
    Returns the temp path or None.
    """
    try:
        temp_audio = tempfile.NamedTemporaryFile(delete=False, suffix=".wav")
        temp_audio.close()
        cmd = [
            "ffmpeg",
            "-y",
            "-i",
            file_path,
            "-vn",
            "-ac",
            "1",
            "-ar",
            "16000",
            "-t",
            str(max_duration),
            temp_audio.name,
        ]
        subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        return temp_audio.name
    except Exception:
        return None

def _transcribe_audio(file_path: str, language: Optional[str] = None) -> str:
    """
    Best-effort audio transcription using optional dependencies.
    Tries faster-whisper, then openai/whisper. Falls back to metadata only.
    """
    try:
        from npcpy.data.audio import transcribe_audio_file
        text = transcribe_audio_file(file_path, language=language)
        if text:
            return text
    except Exception:
        pass

    try:
        from faster_whisper import WhisperModel
        try:
            import torch
            device = "cuda" if torch.cuda.is_available() else "cpu"
        except Exception:
            device = "cpu"
        model = WhisperModel("small", device=device)
        segments, _ = model.transcribe(file_path, language=language, beam_size=5)
        return " ".join(seg.text.strip() for seg in segments if seg.text).strip()
    except Exception:
        pass

    try:
        import whisper
        model = whisper.load_model("small")
        result = model.transcribe(file_path, language=language)
        return result.get("text", "").strip()
    except Exception:
        pass

    return f"[Audio file at {file_path}; install faster-whisper or whisper for transcription]"

def load_audio(file_path: str, language: Optional[str] = None) -> str:
    """Load and transcribe an audio file into text."""
    transcript = _transcribe_audio(file_path, language=language)
    if transcript:
        return transcript
    return f"[Audio file at {file_path}; no transcript available]"

def load_csv(file_path):
    df = pd.read_csv(file_path)
    return df

def load_docx(file_path):
    if Document is None:
        raise ImportError("Please install python-docx to load .docx files.")
    doc = Document(file_path)
    full_text = "\n".join([para.text for para in doc.paragraphs])
    return full_text

def load_excel(file_path):
    df = pd.read_excel(file_path)
    return df

def load_file_contents(file_path, chunk_size=None):
    file_ext = os.path.splitext(file_path)[1].upper().lstrip('.')
    full_content = ""
    if not isinstance(chunk_size, int):
        chunk_size=8000
    try:
        if file_ext == 'PDF':
            full_content = load_pdf(file_path)
        elif file_ext == 'DOCX':
            full_content = load_docx(file_path)
        elif file_ext == 'PPTX':
            full_content = load_pptx(file_path)
        elif file_ext in ['HTML', 'HTM']:
            full_content = load_html(file_path)
        elif file_ext == 'CSV':
            df = load_csv(file_path)
            full_content = df.to_string()
        elif file_ext in ['XLS', 'XLSX']:
            df = load_excel(file_path)
            full_content = df.to_string()
        elif file_ext in ['TXT', 'MD', 'PY', 'JSX', 'TSX', 'TS', 'JS', 'JSON', 'SQL', 'NPC', 'JINX', 'LINE', 'YAML', 'DART', 'JAVA']:
            full_content = load_txt(file_path)
        elif file_ext == 'JSON':
            data = load_json(file_path)
            full_content = json.dumps(data, indent=2)
        elif file_ext in ['MP3', 'WAV', 'M4A', 'AAC', 'FLAC', 'OGG']:
            full_content = load_audio(file_path)
        elif file_ext in ['MP4', 'AVI', 'MOV', 'WMV', 'MPG', 'MPEG', 'WEBM', 'MKV']:
            full_content = load_video(file_path)
        else:
            return [f"Unsupported file format for content loading: {file_ext}"]

        if not full_content:
            return []

        return _chunk_text(full_content, chunk_size)

    except Exception as e:
        return [f"Error loading file {file_path}: {str(e)}"]

def load_html(file_path):
    if BeautifulSoup is None:
        raise ImportError("Please install beautifulsoup4 to load .html files.")
    with open(file_path, 'r', encoding='utf-8') as f:
        soup = BeautifulSoup(f, 'html.parser')
    return soup.get_text(separator='\n', strip=True)

def load_image(file_path):
    img = Image.open(file_path)
    img_array = np.array(img)
    df = pd.DataFrame(
        {
            "image_array": [img_array.tobytes()],
            "shape": [img_array.shape],
            "dtype": [img_array.dtype.str],
        }
    )
    return df

def load_json(file_path):
    with open(file_path, "r", encoding='utf-8') as f:
        data = json.load(f)
    return data

def load_pdf(file_path):
    reader = pypdf.PdfReader(file_path)
    full_text = ""
    for page in reader.pages:
        full_text += (page.extract_text() or "") + "\n"
    return full_text

def load_pptx(file_path):
    if Presentation is None:
        raise ImportError("Please install python-pptx to load .pptx files.")
    prs = Presentation(file_path)
    full_text = ""
    for slide in prs.slides:
        for shape in slide.shapes:
            if hasattr(shape, "text"):
                full_text += shape.text + "\n"
    return full_text

def load_txt(file_path):
    with open(file_path, "r", encoding='utf-8') as f:
        text = f.read()
    return text

def load_video(file_path: str, language: Optional[str] = None, max_audio_seconds: int = 600) -> str:
    """
    Summarize a video by reporting metadata and (optionally) transcribing its audio track.
    """
    try:
        from npcpy.data.video import summarize_video_file
        return summarize_video_file(file_path, language=language, max_audio_seconds=max_audio_seconds)
    except Exception:
        pass

    meta_bits = []
    try:
        import cv2
        video = cv2.VideoCapture(file_path)
        fps = video.get(cv2.CAP_PROP_FPS)
        frame_count = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
        width = int(video.get(cv2.CAP_PROP_FRAME_WIDTH))
        height = int(video.get(cv2.CAP_PROP_FRAME_HEIGHT))
        duration = frame_count / fps if fps else 0
        meta_bits.append(
            f"Video file: {os.path.basename(file_path)} | {width}x{height} | {fps:.2f} fps | {frame_count} frames | ~{duration:.1f}s"
        )
        video.release()
    except Exception:
        meta_bits.append(f"Video file: {os.path.basename(file_path)}")

    audio_path = _extract_audio_from_video(file_path, max_duration=max_audio_seconds)
    transcript = ""
    if audio_path:
        try:
            transcript = _transcribe_audio(audio_path, language=language)
        finally:
            try:
                os.remove(audio_path)
            except Exception:
                pass

    if transcript:
        meta_bits.append("Audio transcript:")
        meta_bits.append(transcript)
    else:
        meta_bits.append("[No transcript extracted; ensure ffmpeg and faster-whisper/whisper are installed]")

    return "\n".join(meta_bits)

def audio_callback(in_data, frame_count, time_info, status):
    import pyaudio
    audio_queue = queue.Queue()
    audio_queue.put(in_data)
    return (in_data, pyaudio.paContinue)

def check_ffmpeg():
    try:
        subprocess.run(
            ["ffmpeg", "-version"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL
        )
        return True
    except (subprocess.SubprocessError, FileNotFoundError):
        return False

def convert_mp3_to_wav(mp3_file, wav_file):
    try:

        if os.path.exists(wav_file):
            os.remove(wav_file)

        subprocess.run(
            [
                "ffmpeg",
                "-y",
                "-i",
                mp3_file,
                "-acodec",
                "pcm_s16le",
                "-ac",
                "1",
                "-ar",
                "44100",
                wav_file,
            ],
            check=True,
            capture_output=True,
            text=True,
        )
    except subprocess.CalledProcessError as e:
        print(f"Error converting MP3 to WAV: {e.stderr}")
        raise
    except Exception as e:
        print(f"Unexpected error during conversion: {e}")
        raise

def create_and_queue_audio(text, state, engine="kokoro", voice=None):
    """Create and play TTS audio using the unified engine interface.

    Args:
        text: Text to speak
        state: Dict with 'tts_is_speaking', 'tts_just_finished', 'running' keys
        engine: TTS engine name (kokoro, qwen3, elevenlabs, openai, gemini, gtts)
        voice: Voice ID (engine-specific)
    """
    import wave
    import uuid

    state["tts_is_speaking"] = True

    if not text.strip():
        state["tts_is_speaking"] = False
        return

    try:
        from npcpy.gen.audio_gen import text_to_speech

        audio_bytes = text_to_speech(text, engine=engine, voice=voice)

        suffix = '.mp3' if engine in ('elevenlabs', 'gtts') else '.wav'
        tmp_path = os.path.join(tempfile.gettempdir(), f"npc_tts_{uuid.uuid4()}{suffix}")
        with open(tmp_path, 'wb') as f:
            f.write(audio_bytes)

        play_path = tmp_path
        if suffix == '.mp3':
            wav_path = tmp_path.replace('.mp3', '.wav')
            convert_mp3_to_wav(tmp_path, wav_path)
            play_path = wav_path

        play_audio(play_path, state)

        for p in set([tmp_path, play_path]):
            try:
                if os.path.exists(p):
                    os.remove(p)
            except Exception:
                pass
    except Exception as e:
        logger.error(f"TTS error: {e}")
    finally:
        state["tts_is_speaking"] = False
        state["tts_just_finished"] = True

def get_available_stt_engines() -> dict:
    """Get info about available STT engines."""
    engines = {
        "whisper": {
            "name": "Whisper (Local)",
            "type": "local",
            "available": False,
            "description": "OpenAI Whisper running locally",
            "install": "pip install faster-whisper"
        },
        "openai": {
            "name": "OpenAI Whisper API",
            "type": "cloud",
            "available": False,
            "description": "OpenAI's cloud Whisper API",
            "requires": "OPENAI_API_KEY"
        },
        "gemini": {
            "name": "Gemini",
            "type": "cloud",
            "available": False,
            "description": "Google Gemini transcription",
            "requires": "GOOGLE_API_KEY or GEMINI_API_KEY"
        },
        "elevenlabs": {
            "name": "ElevenLabs Scribe",
            "type": "cloud",
            "available": False,
            "description": "ElevenLabs speech-to-text",
            "requires": "ELEVENLABS_API_KEY"
        },
        "groq": {
            "name": "Groq Whisper",
            "type": "cloud",
            "available": False,
            "description": "Ultra-fast Whisper via Groq",
            "requires": "GROQ_API_KEY"
        }
    }

    try:
        from faster_whisper import WhisperModel
        engines["whisper"]["available"] = True
    except ImportError:
        try:
            import whisper
            engines["whisper"]["available"] = True
        except ImportError:
            pass

    if os.environ.get('OPENAI_API_KEY'):
        engines["openai"]["available"] = True

    if os.environ.get('GOOGLE_API_KEY') or os.environ.get('GEMINI_API_KEY'):
        engines["gemini"]["available"] = True

    if os.environ.get('ELEVENLABS_API_KEY'):
        engines["elevenlabs"]["available"] = True

    if os.environ.get('GROQ_API_KEY'):
        engines["groq"]["available"] = True

    return engines

def play_audio(filename, state):
    """Play a WAV file via pyaudio with state awareness."""
    import pyaudio
    import wave

    PLAY_CHUNK = 4096

    wf = wave.open(filename, "rb")
    p = pyaudio.PyAudio()

    stream = p.open(
        format=p.get_format_from_width(wf.getsampwidth()),
        channels=wf.getnchannels(),
        rate=wf.getframerate(),
        output=True,
    )

    data = wf.readframes(PLAY_CHUNK)
    while data and state.get("running", True):
        stream.write(data)
        data = wf.readframes(PLAY_CHUNK)

    stream.stop_stream()
    stream.close()
    p.terminate()

def process_text_for_tts(text):
    """Clean text for TTS consumption."""
    text = re.sub(r"[*<>{}()\[\]&%#@^~`]", "", text)
    text = text.strip()
    text = re.sub(r"(\w)\.(\w)\.", r"\1 \2 ", text)
    text = re.sub(r"([.!?])(\w)", r"\1 \2", text)
    return text

def run_transcription(audio_np):
    try:
        temp_file = os.path.join(
            tempfile.gettempdir(), f"temp_recording_{int(time.time())}.wav"
        )
        with wave.open(temp_file, "wb") as wf:
            wf.setnchannels(CHANNELS)
            wf.setsampwidth(2)
            wf.setframerate(RATE)
            wf.writeframes((audio_np * 32768).astype(np.int16).tobytes())
        whisper_model = WhisperModel("large-v3", device="cuda" if torch.cuda.is_available() else "cpu")
        segments, info = whisper_model.transcribe(temp_file, language="en", beam_size=5)
        transcription = " ".join([segment.text for segment in segments])

        try:
            if os.path.exists(temp_file):
                os.remove(temp_file)
        except Exception:
            if temp_file not in cleanup_files:
                cleanup_files.append(temp_file)

        return transcription.strip()

    except Exception as e:
        print(f"Transcription error: {str(e)}")
        return None

def speech_to_text(
    audio_data: bytes,
    engine: str = "whisper",
    language: str = None,
    **kwargs
) -> dict:
    """
    Unified STT interface.

    Args:
        audio_data: Audio bytes (WAV, MP3, etc.)
        engine: STT engine (whisper, openai, gemini, elevenlabs, groq)
        language: Language hint
        **kwargs: Engine-specific options

    Returns:
        Dict with at least 'text' key
    """
    engine = engine.lower()

    if engine == "whisper" or engine == "faster-whisper":
        try:
            return stt_whisper(audio_data, language=language, **kwargs)
        except ImportError:
            import whisper
            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
                f.write(audio_data)
                temp_path = f.name
            try:
                model = whisper.load_model(kwargs.get("model_size", "base"))
                result = model.transcribe(temp_path, language=language)
                return {"text": result["text"].strip(), "language": result.get("language", "en")}
            finally:
                os.unlink(temp_path)

    elif engine == "openai":
        return stt_openai(audio_data, language=language, **kwargs)

    elif engine == "gemini":
        return stt_gemini(audio_data, language=language, **kwargs)

    elif engine == "elevenlabs":
        return stt_elevenlabs(audio_data, language=language, **kwargs)

    elif engine == "groq":
        return stt_groq(audio_data, language=language, **kwargs)

    else:
        raise ValueError(f"Unknown STT engine: {engine}")

def stt_elevenlabs(
    audio_data: bytes,
    api_key: str = None,
    model_id: str = "scribe_v1",
    language: str = None
) -> dict:
    """
    Transcribe audio using ElevenLabs Scribe API.

    Args:
        audio_data: Audio bytes
        api_key: ElevenLabs API key
        model_id: Model (scribe_v1)
        language: Language code (ISO 639-1)

    Returns:
        Dict with 'text', 'language', 'words'
    """
    import requests

    api_key = api_key or os.environ.get('ELEVENLABS_API_KEY')
    if not api_key:
        raise ValueError("ELEVENLABS_API_KEY not set")

    url = "https://api.elevenlabs.io/v1/speech-to-text"
    headers = {"xi-api-key": api_key}

    files = {"file": ("audio.wav", audio_data, "audio/wav")}
    data = {"model_id": model_id}
    if language:
        data["language_code"] = language

    response = requests.post(url, headers=headers, files=files, data=data)
    response.raise_for_status()

    result = response.json()
    return {
        "text": result.get("text", "").strip(),
        "language": result.get("language_code"),
        "words": result.get("words", [])
    }

def stt_gemini(
    audio_data: bytes,
    api_key: str = None,
    model: str = "gemini-1.5-flash",
    language: str = None,
    mime_type: str = "audio/wav"
) -> dict:
    """
    Transcribe audio using Gemini API.

    Args:
        audio_data: Audio bytes
        api_key: Google/Gemini API key
        model: Gemini model
        language: Language hint
        mime_type: Audio MIME type

    Returns:
        Dict with 'text'
    """
    import google.generativeai as genai

    api_key = api_key or os.environ.get('GOOGLE_API_KEY') or os.environ.get('GEMINI_API_KEY')
    if not api_key:
        raise ValueError("GOOGLE_API_KEY or GEMINI_API_KEY not set")

    genai.configure(api_key=api_key)
    model_obj = genai.GenerativeModel(model)

    prompt = "Transcribe this audio exactly. Output only the transcription, nothing else."
    if language:
        prompt = f"Transcribe this audio in {language}. Output only the transcription, nothing else."

    response = model_obj.generate_content([
        prompt,
        {"mime_type": mime_type, "data": audio_data}
    ])

    return {"text": response.text.strip()}

def stt_groq(
    audio_data: bytes,
    api_key: str = None,
    model: str = "whisper-large-v3",
    language: str = None
) -> dict:
    """
    Transcribe audio using Groq's Whisper API (very fast).

    Args:
        audio_data: Audio bytes
        api_key: Groq API key
        model: whisper-large-v3 or whisper-large-v3-turbo
        language: Language code

    Returns:
        Dict with 'text'
    """
    import requests

    api_key = api_key or os.environ.get('GROQ_API_KEY')
    if not api_key:
        raise ValueError("GROQ_API_KEY not set")

    url = "https://api.groq.com/openai/v1/audio/transcriptions"
    headers = {"Authorization": f"Bearer {api_key}"}

    files = {"file": ("audio.wav", audio_data, "audio/wav")}
    data = {"model": model}
    if language:
        data["language"] = language

    response = requests.post(url, headers=headers, files=files, data=data)
    response.raise_for_status()

    return {"text": response.json().get("text", "").strip()}

def stt_openai(
    audio_data: bytes,
    api_key: str = None,
    model: str = "whisper-1",
    language: str = None,
    response_format: str = "verbose_json",
    filename: str = "audio.wav"
) -> dict:
    """
    Transcribe audio using OpenAI Whisper API.

    Args:
        audio_data: Audio bytes
        api_key: OpenAI API key
        model: Model name (whisper-1)
        language: Optional language hint
        response_format: json, text, srt, verbose_json, vtt
        filename: Filename hint for format detection

    Returns:
        Dict with 'text', 'language', 'segments' (if verbose_json)
    """
    import requests

    api_key = api_key or os.environ.get('OPENAI_API_KEY')
    if not api_key:
        raise ValueError("OPENAI_API_KEY not set")

    url = "https://api.openai.com/v1/audio/transcriptions"
    headers = {"Authorization": f"Bearer {api_key}"}

    files = {"file": (filename, audio_data)}
    data = {"model": model, "response_format": response_format}
    if language:
        data["language"] = language

    response = requests.post(url, headers=headers, files=files, data=data)
    response.raise_for_status()

    if response_format == "verbose_json":
        result = response.json()
        return {
            "text": result.get("text", "").strip(),
            "language": result.get("language", "en"),
            "duration": result.get("duration"),
            "segments": result.get("segments", [])
        }
    elif response_format == "json":
        return {"text": response.json().get("text", "").strip()}
    else:
        return {"text": response.text.strip()}

def stt_whisper(
    audio_data: bytes,
    model_size: str = "base",
    language: str = None,
    device: str = "auto"
) -> dict:
    """
    Transcribe audio using local Whisper (faster-whisper).

    Args:
        audio_data: Audio bytes (WAV, MP3, etc.)
        model_size: Model size (tiny, base, small, medium, large-v3)
        language: Language code or None for auto-detect
        device: 'cpu', 'cuda', or 'auto'

    Returns:
        Dict with 'text', 'language', 'segments'
    """
    from faster_whisper import WhisperModel

    if device == "auto":
        try:
            import torch
            device = "cuda" if torch.cuda.is_available() else "cpu"
        except ImportError:
            device = "cpu"

    compute_type = "float16" if device == "cuda" else "int8"
    model = WhisperModel(model_size, device=device, compute_type=compute_type)

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
        f.write(audio_data)
        temp_path = f.name

    try:
        segments, info = model.transcribe(
            temp_path,
            language=language,
            beam_size=5,
            vad_filter=True
        )

        segment_list = []
        text_parts = []
        for segment in segments:
            segment_list.append({
                "start": segment.start,
                "end": segment.end,
                "text": segment.text
            })
            text_parts.append(segment.text)

        return {
            "text": " ".join(text_parts).strip(),
            "language": info.language,
            "language_probability": info.language_probability,
            "segments": segment_list
        }
    finally:
        os.unlink(temp_path)

def transcribe_audio_file(file_path: str, language=None) -> str:
    """
    File-based transcription helper that prefers the local faster-whisper/whisper
    setup used elsewhere in this module.
    """
    try:
        from faster_whisper import WhisperModel
        try:
            import torch
            device = "cuda" if torch.cuda.is_available() else "cpu"
        except Exception:
            device = "cpu"
        model = WhisperModel("small", device=device)
        segments, _ = model.transcribe(file_path, language=language, beam_size=5)
        text = " ".join(seg.text.strip() for seg in segments if seg.text).strip()
        if text:
            return text
    except Exception:
        pass

    try:
        import whisper
        model = whisper.load_model("small")
        result = model.transcribe(file_path, language=language)
        text = result.get("text", "").strip()
        if text:
            return text
    except Exception:
        pass

    return ""

def transcribe_recording(audio_data):
    if not audio_data:
        return None

    audio_np = (
        np.frombuffer(b"".join(audio_data), dtype=np.int16).astype(np.float32) / 32768.0
    )
    return run_transcription(audio_np)

def _windows_snip_to_file(file_path: str) -> bool:
    """Helper function to trigger Windows snipping and save to file."""
    try:

        import win32clipboard
        from PIL import ImageGrab
        from ctypes import windll


        windll.user32.keybd_event(0x5B, 0, 0, 0)  
        windll.user32.keybd_event(0x10, 0, 0, 0)  
        windll.user32.keybd_event(0x53, 0, 0, 0)  
        windll.user32.keybd_event(0x53, 0, 0x0002, 0)  
        windll.user32.keybd_event(0x10, 0, 0x0002, 0)  
        windll.user32.keybd_event(0x5B, 0, 0x0002, 0)  


        print("Please select an area to capture...")
        time.sleep(1)  


        max_wait = 30  
        start_time = time.time()

        while time.time() - start_time < max_wait:
            try:
                image = ImageGrab.grabclipboard()
                if image:
                    image.save(file_path, "PNG")
                    return True
            except Exception:
                pass
            time.sleep(0.5)

        return False

    except ImportError:
        print("Required packages not found. Please install: pip install pywin32 Pillow")
        return False

def capture_screenshot( full=False) -> Dict[str, str]:
    """
    Function Description:
        This function captures a screenshot of the current screen and saves it to a file.
    Args:
        npc: The NPC object representing the current NPC.
        full: Boolean to determine if full screen capture is needed. Default to true.
        path: Optional path to save the screenshot. Must not use placeholders. Relative paths preferred if the user specifies they want a specific path, otherwise default to None.
    Returns:
        A dictionary containing the filename, file path, and model kwargs.
    """


    directory = os.path.expanduser("~/.npcsh/screenshots")
    timestamp = time.strftime("%Y%m%d_%H%M%S")
    filename = f"screenshot_{timestamp}.png"

    file_path = os.path.join(directory, filename)
    os.makedirs(directory, exist_ok=True)



    system = platform.system()

    model_kwargs = {}

    if full:

        if system.lower() == "darwin":

            subprocess.run(["screencapture", file_path], capture_output=True)

        elif system == "Linux":
            _took = False
            for _cmd, _args in [
                ("grim", [file_path]),
                ("scrot", [file_path]),
                ("import", ["-window", "root", file_path]),
                ("gnome-screenshot", ["-f", file_path]),
            ]:
                if subprocess.run(["which", _cmd], capture_output=True).returncode == 0:
                    subprocess.run([_cmd] + _args, capture_output=True, timeout=10)
                    if os.path.exists(file_path):
                        _took = True
                        break
            if not _took:
                print("No supported screenshot tool found. Install scrot, grim, or imagemagick.")

        elif system == "Windows":

            try:
                import win32gui
                import win32ui
                import win32con
                from PIL import Image


                width = win32api.GetSystemMetrics(win32con.SM_CXVIRTUALSCREEN)
                height = win32api.GetSystemMetrics(win32con.SM_CYVIRTUALSCREEN)


                hdesktop = win32gui.GetDesktopWindow()
                desktop_dc = win32gui.GetWindowDC(hdesktop)
                img_dc = win32ui.CreateDCFromHandle(desktop_dc)
                mem_dc = img_dc.CreateCompatibleDC()


                screenshot = win32ui.CreateBitmap()
                screenshot.CreateCompatibleBitmap(img_dc, width, height)
                mem_dc.SelectObject(screenshot)
                mem_dc.BitBlt((0, 0), (width, height), img_dc, (0, 0), win32con.SRCCOPY)


                screenshot.SaveBitmapFile(mem_dc, file_path)


                mem_dc.DeleteDC()
                win32gui.DeleteObject(screenshot.GetHandle())

            except ImportError:
                print(
                    "Required packages not found. Please install: pip install pywin32"
                )
                return None
        else:
            print(f"Unsupported operating system: {system}")
            return None
    else:
        if system == "Darwin":
            subprocess.run(["screencapture", "-i", file_path])
        elif system == "Linux":
            if (
                subprocess.run(
                    ["which", "gnome-screenshot"], capture_output=True
                ).returncode
                == 0
            ):
                subprocess.Popen(["gnome-screenshot", "-a", "-f", file_path])
                while not os.path.exists(file_path):
                    time.sleep(0.5)
            elif (
                subprocess.run(["which", "scrot"], capture_output=True).returncode == 0
            ):
                subprocess.Popen(["scrot", "-s", file_path])
                while not os.path.exists(file_path):
                    time.sleep(0.5)
            else:
                print(
                    "No supported screenshot jinx found. Please install gnome-screenshot or scrot."
                )
                return None
        elif system == "Windows":
            success = _windows_snip_to_file(file_path)
            if not success:
                print("Screenshot capture failed or timed out.")
                return None
        else:
            print(f"Unsupported operating system: {system}")
            return None


    if os.path.exists(file_path):
        print(f"Screenshot saved to: {file_path}")
        return {
            "filename": filename,
            "file_path": file_path,
            "model_kwargs": model_kwargs,
        }
    else:
        print("Screenshot capture failed or was cancelled.")
        return None