camel-ai 0.2.45__py3-none-any.whl → 0.2.46__py3-none-any.whl

camel/toolkits/video_analysis_toolkit.py

@@ -12,6 +12,7 @@
 # limitations under the License.
 # ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========
 
+import io
 import os
 import tempfile
 from pathlib import Path
@@ -92,9 +93,15 @@ class VideoAnalysisToolkit(BaseToolkit):
             transcription using OpenAI's audio models. Requires a valid OpenAI
             API key. When disabled, video analysis will be based solely on
             visual content. (default: :obj:`False`)
+        frame_interval (float, optional): Interval in seconds between frames
+            to extract from the video. (default: :obj:`4.0`)
+        output_language (str, optional): The language for output responses.
+            (default: :obj:`"English"`)
+        cookies_path (Optional[str]): The path to the cookies file
+            for the video service in Netscape format. (default: :obj:`None`)
         timeout (Optional[float]): The timeout value for API requests
-                in seconds. If None, no timeout is applied.
-                (default: :obj:`None`)
+            in seconds. If None, no timeout is applied.
+            (default: :obj:`None`)
     """
 
     @dependencies_required("ffmpeg", "scenedetect")
@@ -103,27 +110,29 @@ class VideoAnalysisToolkit(BaseToolkit):
         download_directory: Optional[str] = None,
         model: Optional[BaseModelBackend] = None,
         use_audio_transcription: bool = False,
+        frame_interval: float = 4.0,
+        output_language: str = "English",
+        cookies_path: Optional[str] = None,
         timeout: Optional[float] = None,
     ) -> None:
         super().__init__(timeout=timeout)
         self._cleanup = download_directory is None
         self._temp_files: list[str] = []  # Track temporary files for cleanup
         self._use_audio_transcription = use_audio_transcription
+        self.output_language = output_language
+        self.frame_interval = frame_interval
 
         self._download_directory = Path(
             download_directory or tempfile.mkdtemp()
         ).resolve()
 
         self.video_downloader_toolkit = VideoDownloaderToolkit(
-            download_directory=str(self._download_directory)
+            download_directory=str(self._download_directory),
+            cookies_path=cookies_path,
         )
 
         try:
             self._download_directory.mkdir(parents=True, exist_ok=True)
-        except FileExistsError:
-            raise ValueError(
-                f"{self._download_directory} is not a valid directory."
-            )
         except OSError as e:
             raise ValueError(
                 f"Error creating directory {self._download_directory}: {e}"
@@ -137,16 +146,18 @@ class VideoAnalysisToolkit(BaseToolkit):
             # Import ChatAgent at runtime to avoid circular imports
             from camel.agents import ChatAgent
 
-            self.vl_agent = ChatAgent(model=self.vl_model)
+            self.vl_agent = ChatAgent(
+                model=self.vl_model, output_language=self.output_language
+            )
         else:
             # If no model is provided, use default model in ChatAgent
             # Import ChatAgent at runtime to avoid circular imports
             from camel.agents import ChatAgent
 
-            self.vl_agent = ChatAgent()
+            self.vl_agent = ChatAgent(output_language=self.output_language)
             logger.warning(
-                "No vision-language model provided. Using default model in"
-                " ChatAgent."
+                "No vision-language model provided. Using default model in "
+                "ChatAgent."
             )
 
         # Initialize audio models only if audio transcription is enabled
@@ -179,16 +190,22 @@ class VideoAnalysisToolkit(BaseToolkit):
         # Clean up temporary directory if needed
         if self._cleanup and os.path.exists(self._download_directory):
             try:
-                import shutil
+                import sys
 
-                shutil.rmtree(self._download_directory)
-                logger.debug(
-                    f"Removed temporary directory: {self._download_directory}"
-                )
+                if getattr(sys, 'modules', None) is not None:
+                    import shutil
+
+                    shutil.rmtree(self._download_directory)
+                    logger.debug(
+                        f"Removed temp directory: {self._download_directory}"
+                    )
+            except (ImportError, AttributeError):
+                # Skip cleanup if interpreter is shutting down
+                pass
             except OSError as e:
                 logger.warning(
-                    f"Failed to remove temporary directory"
-                    f" {self._download_directory}: {e}"
+                    f"Failed to remove temporary directory "
+                    f"{self._download_directory}: {e}"
                 )
 
     def _extract_audio_from_video(
@@ -242,88 +259,217 @@ class VideoAnalysisToolkit(BaseToolkit):
             logger.error(f"Audio transcription failed: {e}")
             return "Audio transcription failed."
 
-    def _extract_keyframes(
-        self, video_path: str, num_frames: int, threshold: float = 25.0
-    ) -> List[Image.Image]:
-        r"""Extract keyframes from a video based on scene changes
-        and return them as PIL.Image.Image objects.
+    def _extract_keyframes(self, video_path: str) -> List[Image.Image]:
+        r"""Extract keyframes from a video based on scene changes and
+        regular intervals,and return them as PIL.Image.Image objects.
 
         Args:
             video_path (str): Path to the video file.
-            num_frames (int): Number of keyframes to extract.
-            threshold (float): The threshold value for scene change detection.
 
         Returns:
-            list: A list of PIL.Image.Image objects representing
+            List[Image.Image]: A list of PIL.Image.Image objects representing
                 the extracted keyframes.
+
+        Raises:
+            ValueError: If no frames could be extracted from the video.
         """
+        import cv2
+        import numpy as np
         from scenedetect import (  # type: ignore[import-untyped]
             SceneManager,
-            VideoManager,
+            open_video,
         )
         from scenedetect.detectors import (  # type: ignore[import-untyped]
             ContentDetector,
         )
 
-        if num_frames <= 0:
+        # Get video information
+        cap = cv2.VideoCapture(video_path)
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        duration = total_frames / fps if fps > 0 else 0
+        cap.release()
+
+        frame_interval = self.frame_interval  # seconds
+        # Maximum number of frames to extract to avoid memory issues
+        MAX_FRAMES = 100
+        # Minimum time difference (in seconds) to consider frames as distinct
+        TIME_THRESHOLD = 1.0
+
+        # Calculate the total number of frames to extract
+        if duration <= 0 or fps <= 0:
             logger.warning(
-                f"Invalid num_frames: {num_frames}, using default of 1"
+                "Invalid video duration or fps, using default frame count"
             )
-            num_frames = 1
+            num_frames = 10
+        else:
+            num_frames = max(int(duration / frame_interval), 1)
+
+            if num_frames > MAX_FRAMES:
+                frame_interval = duration / MAX_FRAMES
+                num_frames = MAX_FRAMES
 
-        video_manager = VideoManager([video_path])
+            logger.info(
+                f"Video duration: {duration:.2f}s, target frames: {num_frames}"
+                f"at {frame_interval:.2f}s intervals"
+            )
+
+        # Use scene detection to extract keyframes
+        # Use open_video instead of VideoManager
+        video = open_video(video_path)
         scene_manager = SceneManager()
-        scene_manager.add_detector(ContentDetector(threshold=threshold))
+        scene_manager.add_detector(ContentDetector())
 
-        video_manager.set_duration()
-        video_manager.start()
-        scene_manager.detect_scenes(video_manager)
+        # Detect scenes using the modern API
+        scene_manager.detect_scenes(video)
 
         scenes = scene_manager.get_scene_list()
         keyframes: List[Image.Image] = []
 
-        # Handle case where no scenes are detected
-        if not scenes:
+        # If scene detection is successful, prioritize scene change points
+        if scenes:
+            logger.info(f"Detected {len(scenes)} scene changes")
+
+            if len(scenes) > num_frames:
+                scene_indices = np.linspace(
+                    0, len(scenes) - 1, num_frames, dtype=int
+                )
+                selected_scenes = [scenes[i] for i in scene_indices]
+            else:
+                selected_scenes = scenes
+
+            # Extract frames from scenes
+            for scene in selected_scenes:
+                try:
+                    # Get start time in seconds
+                    start_time = scene[0].get_seconds()
+                    frame = _capture_screenshot(video_path, start_time)
+                    keyframes.append(frame)
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to capture frame at scene change"
+                        f" {scene[0].get_seconds()}s: {e}"
+                    )
+
+        if len(keyframes) < num_frames and duration > 0:
+            logger.info(
+                f"Scene detection provided {len(keyframes)} frames, "
+                f"supplementing with regular interval frames"
+            )
+
+            existing_times = []
+            if scenes:
+                existing_times = [scene[0].get_seconds() for scene in scenes]
+
+            regular_frames = []
+            for i in range(num_frames):
+                time_sec = i * frame_interval
+
+                is_duplicate = False
+                for existing_time in existing_times:
+                    if abs(existing_time - time_sec) < TIME_THRESHOLD:
+                        is_duplicate = True
+                        break
+
+                if not is_duplicate:
+                    try:
+                        frame = _capture_screenshot(video_path, time_sec)
+                        regular_frames.append(frame)
+                    except Exception as e:
+                        logger.warning(
+                            f"Failed to capture frame at {time_sec}s: {e}"
+                        )
+
+            frames_needed = num_frames - len(keyframes)
+            if frames_needed > 0 and regular_frames:
+                if len(regular_frames) > frames_needed:
+                    indices = np.linspace(
+                        0, len(regular_frames) - 1, frames_needed, dtype=int
+                    )
+                    selected_frames = [regular_frames[i] for i in indices]
+                else:
+                    selected_frames = regular_frames
+
+                keyframes.extend(selected_frames)
+
+        if not keyframes:
             logger.warning(
-                "No scenes detected in video, capturing frames at "
-                "regular intervals"
+                "No frames extracted, falling back to simple interval"
+                "extraction"
             )
-            import cv2
-
-            cap = cv2.VideoCapture(video_path)
-            total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
-            fps = cap.get(cv2.CAP_PROP_FPS)
-            duration = total_frames / fps if fps > 0 else 0
-
-            if duration > 0 and total_frames > 0:
-                # Extract frames at regular intervals
-                interval = duration / min(num_frames, total_frames)
-                for i in range(min(num_frames, total_frames)):
-                    time_sec = i * interval
+            for i in range(
+                min(num_frames, 10)
+            ):  # Limit to a maximum of 10 frames to avoid infinite loops
+                time_sec = i * (duration / 10 if duration > 0 else 6.0)
+                try:
                     frame = _capture_screenshot(video_path, time_sec)
                     keyframes.append(frame)
-
-            cap.release()
-        else:
-            # Extract frames from detected scenes
-            for start_time, _ in scenes:
-                if len(keyframes) >= num_frames:
-                    break
-                frame = _capture_screenshot(video_path, start_time)
-                keyframes.append(frame)
+                except Exception as e:
+                    logger.warning(
+                        f"Failed to capture frame at {time_sec}s: {e}"
+                    )
 
         if not keyframes:
-            logger.error("Failed to extract any keyframes from video")
-            raise ValueError("Failed to extract keyframes from video")
+            error_msg = (
+                f"Failed to extract any keyframes from video: {video_path}"
+            )
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+
+        # Normalize image sizes
+        normalized_keyframes = self._normalize_frames(keyframes)
+
+        logger.info(
+            f"Extracted and normalized {len(normalized_keyframes)} keyframes"
+        )
+        return normalized_keyframes
+
+    def _normalize_frames(
+        self, frames: List[Image.Image], target_width: int = 512
+    ) -> List[Image.Image]:
+        r"""Normalize the size of extracted frames.
 
-        logger.info(f"Extracted {len(keyframes)} keyframes")
-        return keyframes
+        Args:
+            frames (List[Image.Image]): List of frames to normalize.
+            target_width (int): Target width for normalized frames.
+
+        Returns:
+            List[Image.Image]: List of normalized frames.
+        """
+        normalized_frames: List[Image.Image] = []
+
+        for frame in frames:
+            # Get original dimensions
+            width, height = frame.size
+
+            # Calculate new height, maintaining aspect ratio
+            aspect_ratio = width / height
+            new_height = int(target_width / aspect_ratio)
+
+            # Resize image
+            resized_frame = frame.resize(
+                (target_width, new_height), Image.Resampling.LANCZOS
+            )
+
+            # Ensure the image has a proper format
+            if resized_frame.mode != 'RGB':
+                resized_frame = resized_frame.convert('RGB')
+
+            # Create a new image with explicit format
+            with io.BytesIO() as buffer:
+                resized_frame.save(buffer, format='JPEG')
+                buffer.seek(0)
+                formatted_frame = Image.open(buffer)
+                formatted_frame.load()  # Load the image data
+
+            normalized_frames.append(formatted_frame)
+
+        return normalized_frames
 
     def ask_question_about_video(
         self,
         video_path: str,
         question: str,
-        num_frames: int = 28,
     ) -> str:
         r"""Ask a question about the video.
 
@@ -331,24 +477,12 @@ class VideoAnalysisToolkit(BaseToolkit):
             video_path (str): The path to the video file.
                 It can be a local file or a URL (such as Youtube website).
             question (str): The question to ask about the video.
-            num_frames (int): The number of frames to extract from the video.
-                To be adjusted based on the length of the video.
-                (default: :obj:`28`)
 
         Returns:
             str: The answer to the question.
         """
         from urllib.parse import urlparse
 
-        if not question:
-            raise ValueError("Question cannot be empty")
-
-        if num_frames <= 0:
-            logger.warning(
-                f"Invalid num_frames: {num_frames}, using default of 28"
-            )
-            num_frames = 28
-
         parsed_url = urlparse(video_path)
         is_url = all([parsed_url.scheme, parsed_url.netloc])
 
@@ -374,7 +508,7 @@ class VideoAnalysisToolkit(BaseToolkit):
                 audio_path = self._extract_audio_from_video(video_path)
                 audio_transcript = self._transcribe_audio(audio_path)
 
-            video_frames = self._extract_keyframes(video_path, num_frames)
+            video_frames = self._extract_keyframes(video_path)
             prompt = VIDEO_QA_PROMPT.format(
                 audio_transcription=audio_transcript,
                 question=question,
@@ -385,7 +519,8 @@ class VideoAnalysisToolkit(BaseToolkit):
                 content=prompt,
                 image_list=video_frames,
             )
-
+            # Reset the agent to clear previous state
+            self.vl_agent.reset()
             response = self.vl_agent.step(msg)
             if not response or not response.msgs:
                 logger.error("Model returned empty response")
@@ -398,7 +533,7 @@ class VideoAnalysisToolkit(BaseToolkit):
             return answer
 
         except Exception as e:
-            error_message = f"Error processing video: {e!s}"
+            error_message = f"Error processing video: {e}"
             logger.error(error_message)
             return f"Error: {error_message}"
 

camel/toolkits/video_download_toolkit.py

@@ -102,10 +102,17 @@ class VideoDownloaderToolkit(BaseToolkit):
         Cleans up the downloaded video if they are stored in a temporary
         directory.
         """
-        import shutil
-
         if self._cleanup:
-            shutil.rmtree(self._download_directory, ignore_errors=True)
+            try:
+                import sys
+
+                if getattr(sys, 'modules', None) is not None:
+                    import shutil
+
+                    shutil.rmtree(self._download_directory, ignore_errors=True)
+            except (ImportError, AttributeError):
+                # Skip cleanup if interpreter is shutting down
+                pass
 
     def download_video(self, url: str) -> str:
         r"""Download the video and optionally split it into chunks.

camel/types/enums.py

@@ -43,6 +43,15 @@ class ModelType(UnifiedModelType, Enum):
     GPT_4_1_MINI = "gpt-4.1-mini-2025-04-14"
     GPT_4_1_NANO = "gpt-4.1-nano-2025-04-14"
 
+    AWS_CLAUDE_3_7_SONNET = "anthropic.claude-3-7-sonnet-20250219-v1:0"
+    AWS_CLAUDE_3_5_SONNET = "anthropic.claude-3-5-sonnet-20241022-v2:0"
+    AWS_CLAUDE_3_HAIKU = "anthropic.claude-3-haiku-20240307-v1:0"
+    AWS_CLAUDE_3_SONNET = "anthropic.claude-3-sonnet-20240229-v1:0"
+    AWS_DEEPSEEK_R1 = "us.deepseek.r1-v1:0"
+    AWS_LLAMA_3_3_70B_INSTRUCT = "us.meta.llama3-3-70b-instruct-v1:0"
+    AWS_LLAMA_3_2_90B_INSTRUCT = "us.meta.llama3-2-90b-instruct-v1:0"
+    AWS_LLAMA_3_2_11B_INSTRUCT = "us.meta.llama3-2-11b-instruct-v1:0"
+
     GLM_4 = "glm-4"
     GLM_4V = "glm-4v"
     GLM_4V_FLASH = "glm-4v-flash"
@@ -75,6 +84,12 @@ class ModelType(UnifiedModelType, Enum):
     OPENROUTER_LLAMA_4_SCOUT_FREE = "meta-llama/llama-4-scout:free"
     OPENROUTER_OLYMPICODER_7B = "open-r1/olympiccoder-7b:free"
 
+    # LMStudio models
+    LMSTUDIO_GEMMA_3_1B = "gemma-3-1b"
+    LMSTUDIO_GEMMA_3_4B = "gemma-3-4b"
+    LMSTUDIO_GEMMA_3_12B = "gemma-3-12b"
+    LMSTUDIO_GEMMA_3_27B = "gemma-3-27b"
+
     # TogetherAI platform models support tool calling
     TOGETHER_LLAMA_3_1_8B = "meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo"
     TOGETHER_LLAMA_3_1_70B = "meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo"
@@ -308,6 +323,7 @@ class ModelType(UnifiedModelType, Enum):
                 self.is_sambanova,
                 self.is_groq,
                 self.is_openrouter,
+                self.is_lmstudio,
                 self.is_sglang,
                 self.is_moonshot,
                 self.is_siliconflow,
@@ -337,6 +353,20 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GPT_4_1_NANO,
         }
 
+    @property
+    def is_aws_bedrock(self) -> bool:
+        r"""Returns whether this type of models is an AWS Bedrock model."""
+        return self in {
+            ModelType.AWS_CLAUDE_3_7_SONNET,
+            ModelType.AWS_CLAUDE_3_5_SONNET,
+            ModelType.AWS_CLAUDE_3_HAIKU,
+            ModelType.AWS_CLAUDE_3_SONNET,
+            ModelType.AWS_DEEPSEEK_R1,
+            ModelType.AWS_LLAMA_3_3_70B_INSTRUCT,
+            ModelType.AWS_LLAMA_3_2_90B_INSTRUCT,
+            ModelType.AWS_LLAMA_3_2_11B_INSTRUCT,
+        }
+
     @property
     def is_azure_openai(self) -> bool:
         r"""Returns whether this type of models is an OpenAI-released model
@@ -414,6 +444,16 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.OPENROUTER_OLYMPICODER_7B,
         }
 
+    @property
+    def is_lmstudio(self) -> bool:
+        r"""Returns whether this type of models is served by LMStudio."""
+        return self in {
+            ModelType.LMSTUDIO_GEMMA_3_1B,
+            ModelType.LMSTUDIO_GEMMA_3_4B,
+            ModelType.LMSTUDIO_GEMMA_3_12B,
+            ModelType.LMSTUDIO_GEMMA_3_27B,
+        }
+
     @property
     def is_together(self) -> bool:
         r"""Returns whether this type of models is served by Together AI."""
@@ -690,6 +730,10 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GLM_4V_FLASH,
             ModelType.GLM_4_AIRX,
             ModelType.OPENROUTER_OLYMPICODER_7B,
+            ModelType.LMSTUDIO_GEMMA_3_1B,
+            ModelType.LMSTUDIO_GEMMA_3_4B,
+            ModelType.LMSTUDIO_GEMMA_3_12B,
+            ModelType.LMSTUDIO_GEMMA_3_27B,
         }:
             return 8_192
         elif self in {
@@ -765,6 +809,7 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.PPIO_DEEPSEEK_V3_COMMUNITY,
             ModelType.PPIO_DEEPSEEK_R1,
             ModelType.PPIO_DEEPSEEK_V3,
+            ModelType.AWS_DEEPSEEK_R1,
         }:
             return 64_000
         elif self in {
@@ -811,6 +856,9 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.GLM_4_AIR_0111,
             ModelType.GLM_4_FLASHX,
             ModelType.GLM_4_FLASH,
+            ModelType.AWS_LLAMA_3_3_70B_INSTRUCT,
+            ModelType.AWS_LLAMA_3_2_90B_INSTRUCT,
+            ModelType.AWS_LLAMA_3_2_11B_INSTRUCT,
         }:
             return 128_000
         elif self in {
@@ -841,6 +889,10 @@ class ModelType(UnifiedModelType, Enum):
             ModelType.CLAUDE_3_5_HAIKU,
             ModelType.CLAUDE_3_7_SONNET,
             ModelType.YI_MEDIUM_200K,
+            ModelType.AWS_CLAUDE_3_5_SONNET,
+            ModelType.AWS_CLAUDE_3_HAIKU,
+            ModelType.AWS_CLAUDE_3_SONNET,
+            ModelType.AWS_CLAUDE_3_7_SONNET,
         }:
             return 200_000
         elif self in {
@@ -1034,12 +1086,14 @@ class ModelPlatformType(Enum):
     DEFAULT = os.getenv("DEFAULT_MODEL_PLATFORM_TYPE", "openai")
 
     OPENAI = "openai"
+    AWS_BEDROCK = "aws-bedrock"
     AZURE = "azure"
     ANTHROPIC = "anthropic"
     GROQ = "groq"
     OPENROUTER = "openrouter"
     OLLAMA = "ollama"
     LITELLM = "litellm"
+    LMSTUDIO = "lmstudio"
     ZHIPU = "zhipuai"
     GEMINI = "gemini"
     VLLM = "vllm"
@@ -1075,6 +1129,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is openai."""
         return self is ModelPlatformType.OPENAI
 
+    @property
+    def is_aws_bedrock(self) -> bool:
+        r"""Returns whether this platform is aws-bedrock."""
+        return self is ModelPlatformType.AWS_BEDROCK
+
     @property
     def is_azure(self) -> bool:
         r"""Returns whether this platform is azure."""
@@ -1095,6 +1154,11 @@ class ModelPlatformType(Enum):
         r"""Returns whether this platform is openrouter."""
         return self is ModelPlatformType.OPENROUTER
 
+    @property
+    def is_lmstudio(self) -> bool:
+        r"""Returns whether this platform is lmstudio."""
+        return self is ModelPlatformType.LMSTUDIO
+
     @property
     def is_ollama(self) -> bool:
         r"""Returns whether this platform is ollama."""

camel/types/unified_model_type.py

@@ -63,6 +63,11 @@ class UnifiedModelType(str):
         r"""Returns whether the model is an OpenAI model."""
         return True
 
+    @property
+    def is_aws_bedrock(self) -> bool:
+        r"""Returns whether the model is an AWS Bedrock model."""
+        return True
+
     @property
     def is_anthropic(self) -> bool:
         r"""Returns whether the model is an Anthropic model."""
@@ -83,6 +88,11 @@ class UnifiedModelType(str):
         r"""Returns whether the model is a OpenRouter served model."""
         return True
 
+    @property
+    def is_lmstudio(self) -> bool:
+        r"""Returns whether the model is a LMStudio served model."""
+        return True
+
     @property
     def is_ppio(self) -> bool:
         r"""Returns whether the model is a PPIO served model."""

{camel_ai-0.2.45.dist-info → camel_ai-0.2.46.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camel-ai
-Version: 0.2.45
+Version: 0.2.46
 Summary: Communicative Agents for AI Society Study
 Project-URL: Homepage, https://www.camel-ai.org/
 Project-URL: Repository, https://github.com/camel-ai/camel
@@ -84,6 +84,7 @@ Requires-Dist: playwright>=1.50.0; extra == 'all'
 Requires-Dist: prance<24,>=23.6.21.0; extra == 'all'
 Requires-Dist: praw<8,>=7.7.1; extra == 'all'
 Requires-Dist: pre-commit<4,>=3; extra == 'all'
+Requires-Dist: pyautogui<0.10,>=0.9.54; extra == 'all'
 Requires-Dist: pydub<0.26,>=0.25.1; extra == 'all'
 Requires-Dist: pygithub<3,>=2.6.0; extra == 'all'
 Requires-Dist: pymilvus<3,>=2.4.0; extra == 'all'