🐫 CAMEL: The first and the best multi-agent framework. Finding the Scaling Law of Agents. https://www.camel-ai.org
Python agentai-societiesartificial-intelligencecommunicative-aicooperative-aideep-learninglarge-language-modelsmulti-agent-systemsnatural-language-processing
feat: pptx toolkit (#2475)
Saed Bhati091ced243326
diff --git a/camel/toolkits/__init__.py b/camel/toolkits/__init__.pyindex 5f93be23b..df6f5f40f 100644--- a/camel/toolkits/__init__.py+++ b/camel/toolkits/__init__.py@@ -62,6 +62,7 @@ from .mcp_toolkit import MCPToolkitfrom .browser_toolkit import BrowserToolkitfrom .async_browser_toolkit import AsyncBrowserToolkitfrom .file_write_toolkit import FileWriteToolkit+from .pptx_toolkit import PPTXToolkitfrom .terminal_toolkit import TerminalToolkitfrom .pubmed_toolkit import PubMedToolkitfrom .data_commons_toolkit import DataCommonsToolkit@@ -124,6 +125,7 @@ __all__ = ['BrowserToolkit','AsyncBrowserToolkit','FileWriteToolkit',+ 'PPTXToolkit','TerminalToolkit','PubMedToolkit','DataCommonsToolkit',diff --git a/camel/toolkits/file_write_toolkit.py b/camel/toolkits/file_write_toolkit.pyindex 2dbdcf08e..a7bb29db4 100644--- a/camel/toolkits/file_write_toolkit.py+++ b/camel/toolkits/file_write_toolkit.py@@ -338,8 +338,10 @@ class FileWriteToolkit(BaseToolkit):Args:content (Union[str, List[List[str]]]): The content to write to the- file. For all formats, content must be a string or list in the- appropriate format.+ file. Content format varies by file type:+ - Text formats (txt, md, html, yaml): string+ - CSV: string or list of lists+ - JSON: string or serializable objectfilename (str): The name or path of the file. If a relative path issupplied, it is resolved to self.output_dir.encoding (Optional[str]): The character encoding to use. (default:diff --git a/camel/toolkits/pptx_toolkit.py b/camel/toolkits/pptx_toolkit.pynew file mode 100644index 000000000..b4a49c67f--- /dev/null+++ b/camel/toolkits/pptx_toolkit.py@@ -0,0 +1,777 @@+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+# http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========+++import os+import random+import re+from pathlib import Path+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union++if TYPE_CHECKING:+ from pptx import presentation+ from pptx.slide import Slide+ from pptx.text.text import TextFrame++from camel.logger import get_logger+from camel.toolkits.base import BaseToolkit+from camel.toolkits.function_tool import FunctionTool+from camel.utils import MCPServer, api_keys_required++logger = get_logger(__name__)++# Constants+EMU_TO_INCH_SCALING_FACTOR = 1.0 / 914400++STEP_BY_STEP_PROCESS_MARKER = '>> '++IMAGE_DISPLAY_PROBABILITY = 1 / 3.0++SLIDE_NUMBER_REGEX = re.compile(r"^slide[ ]+\d+:", re.IGNORECASE)+BOLD_ITALICS_PATTERN = re.compile(r'(\*\*(.*?)\*\*|\*(.*?)\*)')+++@MCPServer()+class PPTXToolkit(BaseToolkit):+ r"""A toolkit for creating and writing PowerPoint presentations (PPTX+ files).++ This class provides cross-platform support for creating PPTX files with+ title slides, content slides, text formatting, and image embedding.+ """++ def __init__(+ self,+ output_dir: str = "./",+ timeout: Optional[float] = None,+ ) -> None:+ r"""Initialize the PPTXToolkit.++ Args:+ output_dir (str): The default directory for output files.+ Defaults to the current working directory.+ timeout (Optional[float]): The timeout for the toolkit.+ (default: :obj: `None`)+ """+ super().__init__(timeout=timeout)+ self.output_dir = Path(output_dir).resolve()+ self.output_dir.mkdir(parents=True, exist_ok=True)+ logger.info(+ f"PPTXToolkit initialized with output directory: {self.output_dir}"+ )++ def _resolve_filepath(self, file_path: str) -> Path:+ r"""Convert the given string path to a Path object.++ If the provided path is not absolute, it is made relative to the+ default output directory. The filename part is sanitized to replace+ spaces and special characters with underscores, ensuring safe usage+ in downstream processing.++ Args:+ file_path (str): The file path to resolve.++ Returns:+ Path: A fully resolved (absolute) and sanitized Path object.+ """+ path_obj = Path(file_path)+ if not path_obj.is_absolute():+ path_obj = self.output_dir / path_obj++ sanitized_filename = self._sanitize_filename(path_obj.name)+ path_obj = path_obj.parent / sanitized_filename+ return path_obj.resolve()++ def _sanitize_filename(self, filename: str) -> str:+ r"""Sanitize a filename by replacing special characters and spaces.++ Args:+ filename (str): The filename to sanitize.++ Returns:+ str: The sanitized filename.+ """+ import re++ # Replace spaces and special characters with underscores+ sanitized = re.sub(r'[^\w\-_\.]', '_', filename)+ # Remove multiple consecutive underscores+ sanitized = re.sub(r'_+', '_', sanitized)+ return sanitized++ def _format_text(+ self, frame_paragraph, text: str, set_color_to_white=False+ ) -> None:+ r"""Apply bold and italic formatting while preserving the original+ word order.++ Args:+ frame_paragraph: The paragraph to format.+ text (str): The text to format.+ set_color_to_white (bool): Whether to set the color to white.+ (default: :obj: `False`)+ """+ from pptx.dml.color import RGBColor++ matches = list(BOLD_ITALICS_PATTERN.finditer(text))+ last_index = 0++ for match in matches:+ start, end = match.span()+ if start > last_index:+ run = frame_paragraph.add_run()+ run.text = text[last_index:start]+ if set_color_to_white:+ run.font.color.rgb = RGBColor(255, 255, 255)++ if match.group(2): # Bold+ run = frame_paragraph.add_run()+ run.text = match.group(2)+ run.font.bold = True+ if set_color_to_white:+ run.font.color.rgb = RGBColor(255, 255, 255)+ elif match.group(3): # Italics+ run = frame_paragraph.add_run()+ run.text = match.group(3)+ run.font.italic = True+ if set_color_to_white:+ run.font.color.rgb = RGBColor(255, 255, 255)++ last_index = end++ if last_index < len(text):+ run = frame_paragraph.add_run()+ run.text = text[last_index:]+ if set_color_to_white:+ run.font.color.rgb = RGBColor(255, 255, 255)++ def _add_bulleted_items(+ self,+ text_frame: "TextFrame",+ flat_items_list: List[Tuple[str, int]],+ set_color_to_white: bool = False,+ ) -> None:+ r"""Add a list of texts as bullet points and apply formatting.++ Args:+ text_frame (TextFrame): The text frame where text is to be+ displayed.+ flat_items_list (List[Tuple[str, int]]): The list of items to be+ displayed.+ set_color_to_white (bool): Whether to set the font color to white.+ (default: :obj: `False`)+ """+ if not flat_items_list:+ logger.warning("Empty bullet point list provided")+ return+ for idx, item_content in enumerate(flat_items_list):+ item_text, item_level = item_content++ if idx == 0:+ if not text_frame.paragraphs:+ # Ensure a paragraph exists if the frame is empty or+ # cleared+ paragraph = text_frame.add_paragraph()+ else:+ # Use the first existing paragraph+ paragraph = text_frame.paragraphs[0]+ else:+ paragraph = text_frame.add_paragraph()++ paragraph.level = item_level++ self._format_text(+ paragraph,+ item_text.removeprefix(STEP_BY_STEP_PROCESS_MARKER),+ set_color_to_white=set_color_to_white,+ )++ def _get_flat_list_of_contents(+ self, items: List[Union[str, List[Any]]], level: int+ ) -> List[Tuple[str, int]]:+ r"""Flatten a hierarchical list of bullet points to a single list.++ Args:+ items (List[Union[str, List[Any]]]): A bullet point (string or+ list).+ level (int): The current level of hierarchy.++ Returns:+ List[Tuple[str, int]]: A list of (bullet item text, hierarchical+ level) tuples.+ """+ flat_list = []++ for item in items:+ if isinstance(item, str):+ flat_list.append((item, level))+ elif isinstance(item, list):+ flat_list.extend(+ self._get_flat_list_of_contents(item, level + 1)+ )++ return flat_list++ def _get_slide_width_height_inches(+ self, presentation: "presentation.Presentation"+ ) -> Tuple[float, float]:+ r"""Get the dimensions of a slide in inches.++ Args:+ presentation (presentation.Presentation): The presentation object.++ Returns:+ Tuple[float, float]: The width and height in inches.+ """+ slide_width_inch = EMU_TO_INCH_SCALING_FACTOR * (+ presentation.slide_width or 0+ )+ slide_height_inch = EMU_TO_INCH_SCALING_FACTOR * (+ presentation.slide_height or 0+ )+ return slide_width_inch, slide_height_inch++ def _write_pptx_file(+ self,+ file_path: Path,+ content: List[Dict[str, Any]],+ template: Optional[str] = None,+ ) -> None:+ r"""Write text content to a PPTX file with enhanced formatting.++ Args:+ file_path (Path): The target file path.+ content (List[Dict[str, Any]]): The content to write to the PPTX+ file. Must be a list of dictionaries where:+ - First element: Title slide with keys 'title' and 'subtitle'+ - Subsequent elements: Content slides with keys 'title', 'text'+ template (Optional[str]): The name of the template to use. If not+ provided, the default template will be used. (default: :obj:+ `None`)+ """+ import pptx++ # Use template if provided, otherwise create new presentation+ if template is not None:+ template_path = Path(template).resolve()+ if not template_path.exists():+ logger.warning(+ f"Template file not found: {template_path}, using "+ "default template"+ )+ presentation = pptx.Presentation()+ else:+ presentation = pptx.Presentation(str(template_path))+ # Clear all existing slides by removing them from the slide+ # list+ while len(presentation.slides) > 0:+ rId = presentation.slides._sldIdLst[-1].rId+ presentation.part.drop_rel(rId)+ del presentation.slides._sldIdLst[-1]+ else:+ presentation = pptx.Presentation()++ slide_width_inch, slide_height_inch = (+ self._get_slide_width_height_inches(presentation)+ )++ # Process slides+ if content:+ # Title slide (first element)+ title_slide_data = content.pop(0) if content else {}+ title_layout = presentation.slide_layouts[0]+ title_slide = presentation.slides.add_slide(title_layout)++ # Set title and subtitle+ if title_slide.shapes.title:+ title_slide.shapes.title.text_frame.clear()+ self._format_text(+ title_slide.shapes.title.text_frame.paragraphs[0],+ title_slide_data.get("title", ""),+ )++ if len(title_slide.placeholders) > 1:+ subtitle = title_slide.placeholders[1]+ subtitle.text_frame.clear()+ self._format_text(+ subtitle.text_frame.paragraphs[0],+ title_slide_data.get("subtitle", ""),+ )++ # Content slides+ for slide_data in content:+ if not isinstance(slide_data, dict):+ continue++ # Handle different slide types+ if 'table' in slide_data:+ self._handle_table(+ presentation,+ slide_data,+ )+ elif 'bullet_points' in slide_data:+ if any(+ step.startswith(STEP_BY_STEP_PROCESS_MARKER)+ for step in slide_data['bullet_points']+ ):+ self._handle_step_by_step_process(+ presentation,+ slide_data,+ slide_width_inch,+ slide_height_inch,+ )+ else:+ self._handle_default_display(+ presentation,+ slide_data,+ )++ # Save the presentation+ presentation.save(str(file_path))+ logger.debug(f"Wrote PPTX to {file_path} with enhanced formatting")++ def create_presentation(+ self,+ content: str,+ filename: str,+ template: Optional[str] = None,+ ) -> str:+ r"""Create a PowerPoint presentation (PPTX) file.++ Args:+ content (str): The content to write to the PPTX file as a JSON+ string. Must represent a list of dictionaries with the+ following structure:+ - First dict: title slide {"title": str, "subtitle": str}+ - Other dicts: content slides, which can be one of:+ * Bullet/step slides: {"heading": str, "bullet_points":+ list of str or nested lists, "img_keywords": str+ (optional)}+ - If any bullet point starts with '>> ', it will be+ rendered as a step-by-step process.+ - "img_keywords" can be a URL or search keywords for+ an image (optional).+ * Table slides: {"heading": str, "table": {"headers": list+ of str, "rows": list of list of str}}+ filename (str): The name or path of the file. If a relative path is+ supplied, it is resolved to self.output_dir.+ template (Optional[str]): The path to the template PPTX file.+ Initializes a presentation from a given template file Or PPTX+ file. (default: :obj: `None`)++ Returns:+ str: A success message indicating the file was created.++ Example:+ [+ {+ "title": "Presentation Title",+ "subtitle": "Presentation Subtitle"+ },+ {+ "heading": "Slide Title",+ "bullet_points": [+ "**Bold text** for emphasis",+ "*Italic text* for additional emphasis",+ "Regular text for normal content"+ ],+ "img_keywords": "relevant search terms for images"+ },+ {+ "heading": "Step-by-Step Process",+ "bullet_points": [+ ">> **Step 1:** First step description",+ ">> **Step 2:** Second step description",+ ">> **Step 3:** Third step description"+ ],+ "img_keywords": "process workflow steps"+ },+ {+ "heading": "Comparison Table",+ "table": {+ "headers": ["Column 1", "Column 2", "Column 3"],+ "rows": [+ ["Row 1, Col 1", "Row 1, Col 2", "Row 1, Col 3"],+ ["Row 2, Col 1", "Row 2, Col 2", "Row 2, Col 3"]+ ]+ },+ "img_keywords": "comparison visualization"+ }+ ]+ """+ # Ensure filename has .pptx extension+ if not filename.lower().endswith('.pptx'):+ filename += '.pptx'++ # Resolve file path+ file_path = self._resolve_filepath(filename)++ # Parse and validate content format+ try:+ import json++ parsed_content = json.loads(content)+ except json.JSONDecodeError as e:+ logger.error(f"Content must be valid JSON: {e}")+ return "Failed to parse content as JSON"++ if not isinstance(parsed_content, list):+ logger.error(+ f"PPTX content must be a list of dictionaries, "+ f"got {type(parsed_content).__name__}"+ )+ return "PPTX content must be a list of dictionaries"++ try:+ # Create the PPTX file+ self._write_pptx_file(file_path, parsed_content.copy(), template)++ success_msg = (+ f"PowerPoint presentation successfully created: {file_path}"+ )+ logger.info(success_msg)+ return success_msg++ except Exception as e:+ error_msg = f"Failed to create PPTX file {file_path}: {e!s}"+ logger.error(error_msg)+ return error_msg++ def _handle_default_display(+ self,+ presentation: "presentation.Presentation",+ slide_json: Dict[str, Any],+ ) -> None:+ r"""Display a list of text in a slide.++ Args:+ presentation (presentation.Presentation): The presentation object.+ slide_json (Dict[str, Any]): The content of the slide as JSON data.+ """+ status = False++ if 'img_keywords' in slide_json:+ if random.random() < IMAGE_DISPLAY_PROBABILITY:+ status = self._handle_display_image__in_foreground(+ presentation,+ slide_json,+ )++ if status:+ return++ # Image display failed, so display only text+ bullet_slide_layout = presentation.slide_layouts[1]+ slide = presentation.slides.add_slide(bullet_slide_layout)++ shapes = slide.shapes+ title_shape = shapes.title++ try:+ body_shape = shapes.placeholders[1]+ except KeyError:+ # Get placeholders from the slide without layout_number+ placeholders = self._get_slide_placeholders(slide)+ body_shape = shapes.placeholders[placeholders[0][0]]++ title_shape.text = self._remove_slide_number_from_heading(+ slide_json['heading']+ )+ text_frame = body_shape.text_frame++ flat_items_list = self._get_flat_list_of_contents(+ slide_json['bullet_points'], level=0+ )+ self._add_bulleted_items(text_frame, flat_items_list)++ @api_keys_required(+ [+ ("api_key", 'PEXELS_API_KEY'),+ ]+ )+ def _handle_display_image__in_foreground(+ self,+ presentation: "presentation.Presentation",+ slide_json: Dict[str, Any],+ ) -> bool:+ r"""Create a slide with text and image using a picture placeholder+ layout.++ Args:+ presentation (presentation.Presentation): The presentation object.+ slide_json (Dict[str, Any]): The content of the slide as JSON data.++ Returns:+ bool: True if the slide has been processed.+ """+ from io import BytesIO++ import requests++ img_keywords = slide_json.get('img_keywords', '').strip()+ slide = presentation.slide_layouts[8] # Picture with Caption+ slide = presentation.slides.add_slide(slide)+ placeholders = None++ title_placeholder = slide.shapes.title # type: ignore[attr-defined]+ title_placeholder.text = self._remove_slide_number_from_heading(+ slide_json['heading']+ )++ try:+ pic_col = slide.shapes.placeholders[1] # type: ignore[attr-defined]+ except KeyError:+ # Get placeholders from the slide without layout_number+ placeholders = self._get_slide_placeholders(slide) # type: ignore[arg-type]+ pic_col = None+ for idx, name in placeholders:+ if 'picture' in name:+ pic_col = slide.shapes.placeholders[idx] # type: ignore[attr-defined]++ try:+ text_col = slide.shapes.placeholders[2] # type: ignore[attr-defined]+ except KeyError:+ text_col = None+ if not placeholders:+ placeholders = self._get_slide_placeholders(slide) # type: ignore[arg-type]++ for idx, name in placeholders:+ if 'content' in name:+ text_col = slide.shapes.placeholders[idx] # type: ignore[attr-defined]++ flat_items_list = self._get_flat_list_of_contents(+ slide_json['bullet_points'], level=0+ )+ self._add_bulleted_items(text_col.text_frame, flat_items_list)++ if not img_keywords:+ return True++ if isinstance(img_keywords, str) and img_keywords.startswith(+ ('http://', 'https://')+ ):+ try:+ img_response = requests.get(img_keywords, timeout=30)+ img_response.raise_for_status()+ image_data = BytesIO(img_response.content)+ pic_col.insert_picture(image_data)+ return True+ except Exception as ex:+ logger.error(+ 'Error while downloading image from URL: %s', str(ex)+ )++ try:+ url = 'https://api.pexels.com/v1/search'+ api_key = os.getenv('PEXELS_API_KEY')++ headers = {+ 'Authorization': api_key,+ 'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64; rv:10.0) '+ 'Gecko/20100101 Firefox/10.0',+ }+ params = {+ 'query': img_keywords,+ 'size': 'medium',+ 'page': 1,+ 'per_page': 3,+ }+ response = requests.get(+ url, headers=headers, params=params, timeout=12+ )+ response.raise_for_status()+ json_response = response.json()++ if json_response.get('photos'):+ photo = random.choice(json_response['photos'])+ photo_url = photo.get('src', {}).get('large') or photo.get(+ 'src', {}+ ).get('original')++ if photo_url:+ # Download and insert the image+ img_response = requests.get(+ photo_url, headers=headers, stream=True, timeout=12+ )+ img_response.raise_for_status()+ image_data = BytesIO(img_response.content)++ pic_col.insert_picture(image_data)+ except Exception as ex:+ logger.error(+ 'Error occurred while adding image to slide: %s', str(ex)+ )++ return True++ def _handle_table(+ self,+ presentation: "presentation.Presentation",+ slide_json: Dict[str, Any],+ ) -> None:+ r"""Add a table to a slide.++ Args:+ presentation (presentation.Presentation): The presentation object.+ slide_json (Dict[str, Any]): The content of the slide as JSON data.+ """+ headers = slide_json['table'].get('headers', [])+ rows = slide_json['table'].get('rows', [])+ bullet_slide_layout = presentation.slide_layouts[1]+ slide = presentation.slides.add_slide(bullet_slide_layout)+ shapes = slide.shapes+ shapes.title.text = self._remove_slide_number_from_heading(+ slide_json['heading']+ )+ left = slide.placeholders[1].left+ top = slide.placeholders[1].top+ width = slide.placeholders[1].width+ height = slide.placeholders[1].height+ table = slide.shapes.add_table(+ len(rows) + 1, len(headers), left, top, width, height+ ).table++ # Set headers+ for col_idx, header_text in enumerate(headers):+ table.cell(0, col_idx).text = header_text+ table.cell(0, col_idx).text_frame.paragraphs[0].font.bold = True++ # Fill in rows+ for row_idx, row_data in enumerate(rows, start=1):+ for col_idx, cell_text in enumerate(row_data):+ table.cell(row_idx, col_idx).text = cell_text++ def _handle_step_by_step_process(+ self,+ presentation: "presentation.Presentation",+ slide_json: Dict[str, Any],+ slide_width_inch: float,+ slide_height_inch: float,+ ) -> None:+ r"""Add shapes to display a step-by-step process in the slide.++ Args:+ presentation (presentation.Presentation): The presentation object.+ slide_json (Dict[str, Any]): The content of the slide as JSON data.+ slide_width_inch (float): The width of the slide in inches.+ slide_height_inch (float): The height of the slide in inches.+ """+ import pptx+ from pptx.enum.shapes import MSO_AUTO_SHAPE_TYPE+ from pptx.util import Inches, Pt++ steps = slide_json['bullet_points']+ n_steps = len(steps)++ bullet_slide_layout = presentation.slide_layouts[1]+ slide = presentation.slides.add_slide(bullet_slide_layout)+ shapes = slide.shapes+ shapes.title.text = self._remove_slide_number_from_heading(+ slide_json['heading']+ )++ if 3 <= n_steps <= 4:+ # Horizontal display+ height = Inches(1.5)+ width = Inches(slide_width_inch / n_steps - 0.01)+ top = Inches(slide_height_inch / 2)+ left = Inches(+ (slide_width_inch - width.inches * n_steps) / 2 + 0.05+ )++ for step in steps:+ shape = shapes.add_shape(+ MSO_AUTO_SHAPE_TYPE.CHEVRON, left, top, width, height+ )+ text_frame = shape.text_frame+ text_frame.clear()+ paragraph = text_frame.paragraphs[0]+ paragraph.alignment = pptx.enum.text.PP_ALIGN.CENTER+ text_frame.vertical_anchor = pptx.enum.text.MSO_ANCHOR.MIDDLE+ self._format_text(+ paragraph, step.removeprefix(STEP_BY_STEP_PROCESS_MARKER)+ )+ for run in paragraph.runs:+ run.font.size = Pt(14)+ left = Inches(left.inches + width.inches - Inches(0.4).inches)+ elif 4 < n_steps <= 6:+ # Vertical display+ height = Inches(0.65)+ top = Inches(slide_height_inch / 4)+ left = Inches(1)+ width = Inches(slide_width_inch * 2 / 3)++ for step in steps:+ shape = shapes.add_shape(+ MSO_AUTO_SHAPE_TYPE.PENTAGON, left, top, width, height+ )+ text_frame = shape.text_frame+ text_frame.clear()+ paragraph = text_frame.paragraphs[0]+ paragraph.alignment = pptx.enum.text.PP_ALIGN.CENTER+ text_frame.vertical_anchor = pptx.enum.text.MSO_ANCHOR.MIDDLE+ self._format_text(+ paragraph, step.removeprefix(STEP_BY_STEP_PROCESS_MARKER)+ )+ for run in paragraph.runs:+ run.font.size = Pt(14)+ top = Inches(top.inches + height.inches + Inches(0.3).inches)+ left = Inches(left.inches + Inches(0.5).inches)++ def _remove_slide_number_from_heading(self, header: str) -> str:+ r"""Remove the slide number from a given slide header.++ Args:+ header (str): The header of a slide.++ Returns:+ str: The header without slide number.+ """+ if SLIDE_NUMBER_REGEX.match(header):+ idx = header.find(':')+ header = header[idx + 1 :]+ return header++ def _get_slide_placeholders(+ self,+ slide: "Slide",+ ) -> List[Tuple[int, str]]:+ r"""Return the index and name of all placeholders present in a slide.++ Args:+ slide (Slide): The slide.++ Returns:+ List[Tuple[int, str]]: A list containing placeholders (idx, name)+ tuples.+ """+ if hasattr(slide.shapes, 'placeholders'):+ placeholders = [+ (shape.placeholder_format.idx, shape.name.lower())+ for shape in slide.shapes.placeholders+ ]+ if placeholders and len(placeholders) > 0:+ placeholders.pop(0) # Remove the title placeholder+ return placeholders+ return []++ def get_tools(self) -> List[FunctionTool]:+ r"""Returns a list of FunctionTool objects representing the+ functions in the toolkit.++ Returns:+ List[FunctionTool]: A list of FunctionTool objects+ representing the functions in the toolkit.+ """+ return [FunctionTool(self.create_presentation)]diff --git a/docs/key_modules/tools.md b/docs/key_modules/tools.mdindex 8436ee68a..5b5126f29 100644--- a/docs/key_modules/tools.md+++ b/docs/key_modules/tools.md@@ -175,6 +175,7 @@ CAMEL provides a variety of built-in toolkits that you can use right away. Here'| NotionToolkit | A toolkit for retrieving information from Notion pages and workspaces using the Notion API. || OpenAPIToolkit | A toolkit for working with OpenAPI specifications and REST APIs. || OpenBBToolkit | A toolkit for accessing and analyzing financial market data through the OpenBB Platform, including stocks, ETFs, cryptocurrencies, and economic indicators. |+| PPTXToolkit | A toolkit for creating and manipulating PowerPoint (PPTX) files, including adding slides, text, and images. || PubMedToolkit | A toolkit for interacting with PubMed's E-utilities API to access MEDLINE data. || RedditToolkit | A toolkit for Reddit operations including collecting top posts, performing sentiment analysis on comments, and tracking keyword discussions. || RetrievalToolkit | A toolkit for retrieving information from local vector storage systems based on specified queries. |diff --git a/docs/mintlify/docs.json b/docs/mintlify/docs.jsonindex c1686dca2..952115311 100644--- a/docs/mintlify/docs.json+++ b/docs/mintlify/docs.json@@ -477,6 +477,7 @@"reference/camel.toolkits.openai_agent_toolkit","reference/camel.toolkits.openbb_toolkit","reference/camel.toolkits.playwright_mcp_toolkit",+ "reference/camel.toolkits.pptx_toolkit","reference/camel.toolkits.pubmed_toolkit","reference/camel.toolkits.pulse_mcp_search_toolkit","reference/camel.toolkits.pyautogui_toolkit",diff --git a/docs/mintlify/reference/camel.datasets.static_dataset.mdx b/docs/mintlify/reference/camel.datasets.static_dataset.mdxindex 73bd3ee2a..fd8e09dbc 100644--- a/docs/mintlify/reference/camel.datasets.static_dataset.mdx+++ b/docs/mintlify/reference/camel.datasets.static_dataset.mdx@@ -240,7 +240,6 @@ def save_to_huggingface(language: Optional[List[str]] = None,task_categories: Optional[List[str]] = None,authors: Optional[List[str]] = None,- overwrite: bool = False,**kwargs: Any):```diff --git a/docs/mintlify/reference/camel.toolkits.file_write_toolkit.mdx b/docs/mintlify/reference/camel.toolkits.file_write_toolkit.mdxindex a15ab7662..77609827b 100644--- a/docs/mintlify/reference/camel.toolkits.file_write_toolkit.mdx+++ b/docs/mintlify/reference/camel.toolkits.file_write_toolkit.mdx@@ -260,7 +260,7 @@ and HTML (.html, .htm).**Parameters:**-- **content** (Union[str, List[List[str]]]): The content to write to the file. For all formats, content must be a string or list in the appropriate format.+- **content** (Union[str, List[List[str]]]): The content to write to the file. Content format varies by file type: - Text formats (txt, md, html, yaml): string - CSV: string or list of lists - JSON: string or serializable object- **filename** (str): The name or path of the file. If a relative path is supplied, it is resolved to self.output_dir.- **encoding** (Optional[str]): The character encoding to use. (default: :obj: `None`)- **use_latex** (bool): For PDF files, whether to use LaTeX rendering (True) or simple FPDF rendering (False). (default: :obj: `False`)diff --git a/docs/mintlify/reference/camel.toolkits.pptx_toolkit.mdx b/docs/mintlify/reference/camel.toolkits.pptx_toolkit.mdxnew file mode 100644index 000000000..a8b5321f3--- /dev/null+++ b/docs/mintlify/reference/camel.toolkits.pptx_toolkit.mdx@@ -0,0 +1,317 @@+<a id="camel.toolkits.pptx_toolkit"></a>++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit"></a>++## PPTXToolkit++```python+class PPTXToolkit(BaseToolkit):+```++A toolkit for creating and writing PowerPoint presentations (PPTX files).++This class provides cross-platform support for creating PPTX files with+title slides, content slides, text formatting, and image embedding.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit.__init__"></a>++### __init__++```python+def __init__(self, output_dir: str = './', timeout: Optional[float] = None):+```++Initialize the PPTXToolkit.++**Parameters:**++- **output_dir** (str): The default directory for output files. Defaults to the current working directory.+- **timeout** (Optional[float]): The timeout for the toolkit. (default: :obj: `None`)++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._resolve_filepath"></a>++### _resolve_filepath++```python+def _resolve_filepath(self, file_path: str):+```++Convert the given string path to a Path object.++If the provided path is not absolute, it is made relative to the+default output directory. The filename part is sanitized to replace+spaces and special characters with underscores, ensuring safe usage+in downstream processing.++**Parameters:**++- **file_path** (str): The file path to resolve.++**Returns:**++ Path: A fully resolved (absolute) and sanitized Path object.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._sanitize_filename"></a>++### _sanitize_filename++```python+def _sanitize_filename(self, filename: str):+```++Sanitize a filename by replacing special characters and spaces.++**Parameters:**++- **filename** (str): The filename to sanitize.++**Returns:**++ str: The sanitized filename.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._format_text"></a>++### _format_text++```python+def _format_text(+ self,+ frame_paragraph,+ text: str,+ set_color_to_white = False+):+```++Apply bold and italic formatting while preserving the original word order.++**Parameters:**++- **frame_paragraph**: The paragraph to format.+- **text** (str): The text to format.+- **set_color_to_white** (bool): Whether to set the color to white. (default: :obj: `False`)++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._add_bulleted_items"></a>++### _add_bulleted_items++```python+def _add_bulleted_items(+ self,+ text_frame: pptx.text.text.TextFrame,+ flat_items_list: list,+ set_color_to_white = False+):+```++Add a list of texts as bullet points and apply formatting.++**Parameters:**++- **text_frame**: The text frame where text is to be displayed.+- **flat_items_list**: The list of items to be displayed.+- **set_color_to_white** (bool): Whether to set the font color to white. (default: :obj: `False`)++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._get_flat_list_of_contents"></a>++### _get_flat_list_of_contents++```python+def _get_flat_list_of_contents(self, items: list, level: int):+```++Flatten a hierarchical list of bullet points to a single list.++**Parameters:**++- **items**: A bullet point (string or list).+- **level**: The current level of hierarchy.++**Returns:**++ List[Tuple]: A list of (bullet item text, hierarchical level) tuples.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._get_slide_width_height_inches"></a>++### _get_slide_width_height_inches++```python+def _get_slide_width_height_inches(self, presentation: Any):+```++Get the dimensions of a slide in inches.++**Parameters:**++- **presentation**: The presentation object.++**Returns:**++ Tuple[float, float]: The width and height in inches.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._write_pptx_file"></a>++### _write_pptx_file++```python+def _write_pptx_file(+ self,+ file_path: Path,+ content: List[Dict[str, Any]],+ template: Optional[str] = None+):+```++Write text content to a PPTX file with enhanced formatting.++**Parameters:**++- **file_path** (Path): The target file path.+- **content** (List[Dict[str, Any]]): The content to write to the PPTX file. Must be a list of dictionaries where: - First element: Title slide with keys 'title' and 'subtitle' - Subsequent elements: Content slides with keys 'title', 'text' (optional)+- **template** (Optional[str]): The name of the template to use. If not provided, the default template will be used.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit.create_presentation"></a>++### create_presentation++```python+def create_presentation(+ self,+ content: str,+ filename: str,+ template: Optional[str] = None+):+```++Create a PowerPoint presentation (PPTX) file.++**Parameters:**++- **content** (str): The content to write to the PPTX file as a JSON string. Must represent a list of dictionaries with the following structure: - First dict: title slide `{"title": str, "subtitle": str}` - Other dicts: content slides, which can be one of: * Bullet/step slides: `{"heading": str, "bullet_points": list of str or nested lists, "img_keywords": str (optional)}` - If any bullet point starts with '>> ', it will be rendered as a step-by-step process. - "img_keywords" can be a URL or search keywords for an image (optional). * Table slides: `{"heading": str, "table": {"headers": list of str, "rows": list of list of str}}`+- **filename** (str): The name or path of the file. If a relative path is supplied, it is resolved to self.output_dir.+- **template** (Optional[str]): The path to the template PPTX file. Initializes a presentation from a given template file Or PPTX file.++**Returns:**++ str: A success message indicating the file was created.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit.get_tools"></a>++### get_tools++```python+def get_tools(self):+```++**Returns:**++ List[FunctionTool]: A list of FunctionTool objects+representing the functions in the toolkit.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._handle_default_display"></a>++### _handle_default_display++```python+def _handle_default_display(self, presentation: Any, slide_json: dict):+```++Display a list of text in a slide.++**Parameters:**++- **presentation**: The presentation object.+- **slide_json**: The content of the slide as JSON data.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._handle_display_image__in_foreground"></a>++### _handle_display_image__in_foreground++```python+def _handle_display_image__in_foreground(self, presentation: Any, slide_json: dict):+```++Create a slide with text and image using a picture placeholder layout.++**Parameters:**++- **presentation**: The presentation object.+- **slide_json**: The content of the slide as JSON data.++**Returns:**++ bool: True if the slide has been processed.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._handle_table"></a>++### _handle_table++```python+def _handle_table(self, presentation: Any, slide_json: dict):+```++Add a table to a slide.++**Parameters:**++- **presentation**: The presentation object.+- **slide_json**: The content of the slide as JSON data.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._handle_step_by_step_process"></a>++### _handle_step_by_step_process++```python+def _handle_step_by_step_process(+ self,+ presentation: Any,+ slide_json: dict,+ slide_width_inch: float,+ slide_height_inch: float+):+```++Add shapes to display a step-by-step process in the slide.++**Parameters:**++- **presentation**: The presentation object.+- **slide_json**: The content of the slide as JSON data.+- **slide_width_inch**: The width of the slide in inches.+- **slide_height_inch**: The height of the slide in inches.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._remove_slide_number_from_heading"></a>++### _remove_slide_number_from_heading++```python+def _remove_slide_number_from_heading(self, header: str):+```++Remove the slide number from a given slide header.++**Parameters:**++- **header**: The header of a slide.++**Returns:**++ str: The header without slide number.++<a id="camel.toolkits.pptx_toolkit.PPTXToolkit._get_slide_placeholders"></a>++### _get_slide_placeholders++```python+def _get_slide_placeholders(self, slide: Any, layout_number: int):+```++Return the index and name of all placeholders present in a slide.++**Parameters:**++- **slide**: The slide.+- **layout_number**: The layout number used by the slide.++**Returns:**++ List[Tuple[int, str]]: A list containing placeholders (idx, name) tuples.diff --git a/examples/toolkits/pptx_toolkit.py b/examples/toolkits/pptx_toolkit.pynew file mode 100644index 000000000..d6a448581--- /dev/null+++ b/examples/toolkits/pptx_toolkit.py@@ -0,0 +1,269 @@+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+# http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========+"""+Example usage of the PPTXToolkit for creating PowerPoint presentations.+"""++import os++from camel.agents import ChatAgent+from camel.models import ModelFactory+from camel.toolkits import PPTXToolkit+from camel.types import ModelPlatformType, ModelType+++def run_pptx_agent():+ # Set the PEXELS_API_KEY for Pexels image fetching+ os.environ['PEXELS_API_KEY'] = 'your_api_key_here'++ # Initialize the model+ model = ModelFactory.create(+ model_platform=ModelPlatformType.DEFAULT,+ model_type=ModelType.DEFAULT,+ )++ # Initialize the toolkit with an output directory+ pptx_toolkit = PPTXToolkit(+ output_dir="./pptx_outputs",+ )++ # Initialize the agent with the toolkit+ system_message = """You are a helpful assistant that can create PowerPoint+ presentations.+ When creating presentations, you must first select the appropriate+ template based on the topic:++ Available Templates:+ 1. Modern Template (modern.pptx)+ - Best for: Technology, Innovation, Digital topics+ - Path: examples/toolkits/templates/modern.pptx++ 2. Business Template (ion_boardroom.pptx)+ - Best for: Business, Corporate, Professional topics+ - Path: examples/toolkits/templates/ion_boardroom.pptx++ 3. Education Template (urban_monochrome.pptx)+ - Best for: Education, Learning, Academic topics+ - Path: examples/toolkits/templates/urban_monochrome.pptx++ Special formatting rules:+ 1. Use **text** for bold text+ 2. Use *text* for italic text+ 3. Use >> at the start of bullet points for step-by-step processes+ 4. Use proper JSON formatting with double quotes for all strings+ 5. Add img_keywords field to include relevant images from Pexels++ IMPORTANT:+ 1. First, analyze the presentation topic and select the most appropriate+ template+ 2. Then create the JSON content following the format above+ 3. Finally, use the create_presentation tool to generate the PPTX file+ with the selected template++ Example tool usage:+ create_presentation(content='[{"title": "Example", "subtitle": "Demo"}]',+ filename="example.pptx", template="/examples/toolkits/templates/modern.+ pptx")+ """++ camel_agent = ChatAgent(+ system_message=system_message,+ model=model,+ tools=pptx_toolkit.get_tools(),+ )++ print("=== PPTXToolkit Example Usage ===\n")++ # Example 1: Presentation with various slide types+ print("Example 1: Creating a presentation with various slide types")+ presentation_query = """Create a PowerPoint presentation about+ \"CAMEL-AI\" based on the content below:+ CAMEL: The first and the best multi-agent framework. We are working on+ finding the scaling laws of Agents. We believe that studying these agents+ on a large scale offers valuable insights into their behaviors,+ capabilities, and potential risks. To facilitate research in this field,+ we implement and support various types of agents, tasks, prompts, models,+ and simulated environments.++ The CAMEL project is building the foundational infrastructure for AI+ agents: collaborative, tool-using agents that operates in complex,+ real-world environments.++ Our open-source framework empowers researchers and developers to rapidly+ build and experiment with multi-agent systems. These agents are powered by+ large language models (LLMs) and can interact with real-world+ tools—including terminals, web browsers, code execution, and+ APIs—unlocking high-value applications across enterprise automation,+ simulation, and AI research.++ CAMEL is already gaining significant traction: over 200 contributors have+ supported the project globally, our community spans more than 10,000+ active members on private channels like Discord and Slack, and our work+ has been cited more than 700 times in academic literature. CAMEL is widely+ used in research, education, and industry to develop agentic systems and+ drive innovation at the frontier of AI agent research.++ We believe CAMEL is well-positioned to become the core infrastructure+ layer for safe, scalable, and intelligent multi-agent systems in the+ emerging agent economy.+ """++ camel_agent.reset()+ response = camel_agent.step(presentation_query)+ print(response.msgs[0].content)+ print(f"Tool calls: {response.info['tool_calls']}")+ print("\n" + "=" * 50 + "\n")++ # Example 2: Direct toolkit usage with advanced features+ print("Example 2: Direct toolkit usage with advanced features")++ # Define presentation content as JSON string+ import json++ presentation_content = [+ {+ "title": "Modern Software Development",+ "subtitle": "Best Practices and Tools",+ },+ {+ "heading": "Key Development Principles",+ "bullet_points": [+ "**Agile** methodology for flexible development",+ "*Continuous Integration* and *Continuous Deployment*",+ "**Test-Driven Development** (TDD)",+ "Code review and pair programming",+ "Documentation and knowledge sharing",+ ],+ "img_keywords": "software development team collaboration",+ },+ {+ "heading": "Step-by-Step: Development Workflow",+ "bullet_points": [+ ">> **Step 1:** Plan and gather requirements",+ ">> **Step 2:** Design system architecture",+ ">> **Step 3:** Implement features",+ ">> **Step 4:** Write and run tests",+ ">> **Step 5:** Deploy and monitor",+ ],+ "img_keywords": "software development workflow process",+ },+ {+ "heading": "Best Practices Summary",+ "bullet_points": [+ "Write clean, maintainable code",+ "Automate testing and deployment",+ "Monitor and optimize performance",+ "Keep security in mind",+ "Document everything",+ ],+ "img_keywords": "https://images.pexels.com/photos/2014773"+ "/pexels-photo-2014773.jpeg?auto=compress&cs=tinysrgb&w=1260&h=750"+ "&dpr=1",+ },+ {+ "heading": "Development Approaches Comparison",+ "table": {+ "headers": ["Approach", "Pros", "Cons"],+ "rows": [+ [+ "Waterfall",+ "Clear structure, predictable",+ "Less flexible, slow to adapt",+ ],+ [+ "Agile",+ "Flexible, iterative",+ "Requires discipline, can be chaotic",+ ],+ [+ "DevOps",+ "Fast delivery, automation",+ "Complex setup, requires expertise",+ ],+ [+ "Lean",+ "Efficient, waste reduction",+ "Requires cultural change",+ ],+ ],+ },+ "img_keywords": "software development methodologies comparison",+ },+ ]++ # Create the presentation directly+ result = pptx_toolkit.create_presentation(+ content=json.dumps(presentation_content),+ filename="modern_development.pptx",+ )+ print("Direct toolkit usage:")+ print(result)+ print("\n" + "=" * 50 + "\n")++ print("Both presentations have been created successfully!")+ print("Check the './pptx_outputs' directory for the generated PPTX files.")+++if __name__ == "__main__":+ run_pptx_agent()+++"""+===============================================================================+=== PPTXToolkit Example Usage ===++Example 1: Creating a presentation with various slide types+The PowerPoint presentation titled "CAMEL-AI: The First Multi-Agent Framework"+has been successfully created. You can download it using the link below:++[Download CAMEL-AI Presentation](sandbox:/Users/enrei/Desktop/camel0508/camel/+pptx_outputs/camel_ai_presentation.pptx)+Tool calls: [ToolCallingRecord(tool_name='create_presentation', args=+{'content': '[{"title": "CAMEL-AI","subtitle": "The First Multi-Agent+Framework"},{"heading": "Introduction to CAMEL","bullet_points":[">>+Multi-agent framework for AI research.",">> Focus on the scaling laws of+agents.",">> Insights into behavior, capabilities, and risks."],+"img_keywords":"AI research, agents"},{"heading": "Key Features",+"bullet_points":[">> Collaborative, tool-using agents for real-world+environments.",">> Open-source framework for rapid development and+experimentation.",">> Powered by large language models (LLMs)."],+"img_keywords":"collaboration, technology"},{"heading": "Applications of+CAMEL","bullet_points":[">> Interaction with real-world tools: terminals, web+browsers, APIs.",">> Enterprise automation and simulation applications.",">>+Significant contributions to AI research."],"img_keywords":"application of AI,+technologies"},{"heading": "Community and Impact","bullet_points":[">> Over+200 global contributors or supporters.",">> Community of more than 10,000+active members on Discord and Slack.",">> Over 700 citations in academic+literature."],"img_keywords":"community, collaboration"},{"heading": "Future+of CAMEL","bullet_points":[">> Core infrastructure for multi-agent systems in+agent economy.",">> Positioned for safe and scalable intelligent systems."],+"img_keywords":"future of technology, AI"}]', 'filename':+'camel_ai_presentation.pptx', 'template': '/examples/toolkits/templates/modern.+pptx'}, result='PowerPoint presentation successfully created: /Users/enrei/+Desktop/camel0508/camel/pptx_outputs/camel_ai_presentation.pptx',+tool_call_id='call_DwygLSSBGGG9c6kXgQt3sFO5')]++==================================================++Example 2: Direct toolkit usage with advanced features+Direct toolkit usage:+PowerPoint presentation successfully created: /Users/enrei/Desktop/camel0508/+camel/pptx_outputs/modern_development.pptx++==================================================++Both presentations have been created successfully!+Check the './pptx_outputs' directory for the generated PPTX files.+===============================================================================+"""diff --git a/examples/toolkits/slides_templates/blank.pptx b/examples/toolkits/slides_templates/blank.pptxnew file mode 100644index 000000000..7fc648ecdBinary files /dev/null and b/examples/toolkits/slides_templates/blank.pptx differdiff --git a/examples/toolkits/slides_templates/ion_boardroom.pptx b/examples/toolkits/slides_templates/ion_boardroom.pptxnew file mode 100644index 000000000..fd3e4577eBinary files /dev/null and b/examples/toolkits/slides_templates/ion_boardroom.pptx differdiff --git a/examples/toolkits/slides_templates/minimalist_sales_pitch.pptx b/examples/toolkits/slides_templates/minimalist_sales_pitch.pptxnew file mode 100644index 000000000..98d00518dBinary files /dev/null and b/examples/toolkits/slides_templates/minimalist_sales_pitch.pptx differdiff --git a/examples/toolkits/slides_templates/modern.pptx b/examples/toolkits/slides_templates/modern.pptxnew file mode 100644index 000000000..95b6c4748Binary files /dev/null and b/examples/toolkits/slides_templates/modern.pptx differdiff --git a/examples/toolkits/slides_templates/urban_monochrome.pptx b/examples/toolkits/slides_templates/urban_monochrome.pptxnew file mode 100644index 000000000..07384e652Binary files /dev/null and b/examples/toolkits/slides_templates/urban_monochrome.pptx differdiff --git a/pyproject.toml b/pyproject.tomlindex 851a86d00..3d6cfeadf 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -126,6 +126,7 @@ document_tools = ["markitdown==0.1.1","pylatex>=1.4.2","chunkr-ai>=0.0.50",+ "python-pptx>=1.0.2",]media_tools = ["imageio[pyav]>=2.34.2,<3",@@ -255,6 +256,7 @@ owl = ["aci-sdk>=1.0.0b1","pylatex>=1.4.2","chunkr-ai>=0.0.50",+ "python-pptx>=1.0.2",]all = ["numpy>=1.2,<=2.2",@@ -375,6 +377,7 @@ all = ["aci-sdk>=1.0.0b1","pylatex>=1.4.2","chunkr-ai>=0.0.50",+ "python-pptx>=1.0.2",][project.urls]diff --git a/test/toolkits/test_pptx_toolkit.py b/test/toolkits/test_pptx_toolkit.pynew file mode 100644index 000000000..9c45b3c3d--- /dev/null+++ b/test/toolkits/test_pptx_toolkit.py@@ -0,0 +1,313 @@+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========+# Licensed under the Apache License, Version 2.0 (the "License");+# you may not use this file except in compliance with the License.+# You may obtain a copy of the License at+#+# http://www.apache.org/licenses/LICENSE-2.0+#+# Unless required by applicable law or agreed to in writing, software+# distributed under the License is distributed on an "AS IS" BASIS,+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+# See the License for the specific language governing permissions and+# limitations under the License.+# ========= Copyright 2023-2024 @ CAMEL-AI.org. All Rights Reserved. =========++import os+import tempfile++import pytest++from camel.toolkits.pptx_toolkit import PPTXToolkit+++def pptx_toolkit():+ r"""Fixture that creates a PPTXToolkit instance with a temporary+ directory."""+ with tempfile.TemporaryDirectory() as temp_dir:+ toolkit = PPTXToolkit(output_dir=temp_dir)+ yield toolkit+++def test_pptx_toolkit_initialization(pptx_toolkit):+ r"""Test that PPTXToolkit initializes correctly."""+ assert isinstance(pptx_toolkit, PPTXToolkit)+ assert pptx_toolkit.output_dir.exists()+++def test_get_tools(pptx_toolkit):+ r"""Test that get_tools returns the correct number of tools."""+ tools = pptx_toolkit.get_tools()+ assert len(tools) == 1+ assert tools[0].get_function_name() == "create_presentation"+++def test_create_presentation_basic(pptx_toolkit):+ r"""Test creating a PPTX file with basic slide structure."""+ import json++ content = [+ {+ "title": "Test Presentation",+ "subtitle": "Created by PPTXToolkit",+ },+ {+ "heading": "First Slide",+ "bullet_points": ["This is the content of the first slide."],+ },+ {+ "heading": "Second Slide",+ "bullet_points": ["This is the content of the second slide."],+ },+ ]+ filename = "test_basic.pptx"++ result = pptx_toolkit.create_presentation(json.dumps(content), filename)++ # Check the result message+ assert "successfully created" in result++ # Check the file exists+ file_path = pptx_toolkit._resolve_filepath(filename)+ assert file_path.exists()++ # Verify it's a valid PPTX file by checking we can open it+ try:+ import pptx++ presentation = pptx.Presentation(str(file_path))+ # Should have 3 slides (1 title + 2 content)+ assert len(presentation.slides) == 3+ except ImportError:+ # If python-pptx is not available, just check file exists+ pass+++def test_create_presentation_with_images(pptx_toolkit):+ r"""Test creating a PPTX file with image URLs."""+ import json+ import os+ from unittest.mock import patch++ content = [+ {+ "title": "Presentation with Images",+ "subtitle": "Testing image integration",+ },+ {+ "heading": "Slide with Image",+ "bullet_points": ["This slide contains an image."],+ "img_keywords": "https://via.placeholder.com/300x200.png",+ },+ ]+ filename = "test_images.pptx"++ with patch.dict(os.environ, {"PEXELS_API_KEY": "test_key"}):+ result = pptx_toolkit.create_presentation(+ json.dumps(content), filename+ )++ # Check the result message+ assert "successfully created" in result++ # Check the file exists+ file_path = pptx_toolkit._resolve_filepath(filename)+ assert file_path.exists()+++def test_create_presentation_title_only(pptx_toolkit):+ r"""Test creating a PPTX file with only title slide."""+ import json++ content = [+ {+ "title": "Title Only Presentation",+ "subtitle": "No content slides",+ }+ ]+ filename = "test_title_only.pptx"++ result = pptx_toolkit.create_presentation(json.dumps(content), filename)++ # Check the result message+ assert "successfully created" in result++ # Check the file exists+ file_path = pptx_toolkit._resolve_filepath(filename)+ assert file_path.exists()++ # Verify it's a valid PPTX file with 1 slide+ try:+ import pptx++ presentation = pptx.Presentation(str(file_path))+ assert len(presentation.slides) == 1+ except ImportError:+ # If python-pptx is not available, just check file exists+ pass+++def test_create_presentation_missing_fields(pptx_toolkit):+ r"""Test creating a PPTX file with slides missing optional fields."""+ import json++ content = [+ {+ "title": "Presentation",+ # Missing subtitle+ },+ {+ "heading": "Slide without bullet points",+ "bullet_points": [],+ # Missing img_keywords+ },+ {+ "heading": "Basic slide",+ "bullet_points": ["Slide with text but minimal structure"],+ },+ ]+ filename = "test_missing_fields.pptx"++ result = pptx_toolkit.create_presentation(json.dumps(content), filename)++ # Should handle missing fields gracefully+ assert "successfully created" in result++ # Check the file exists+ file_path = pptx_toolkit._resolve_filepath(filename)+ assert file_path.exists()+++def test_create_presentation_invalid_image_url(pptx_toolkit):+ r"""Test creating a PPTX file with invalid image URL (should continue+ without failing)."""+ import json+ import os+ from unittest.mock import patch++ content = [+ {+ "title": "Test Invalid Image",+ "subtitle": "Should handle gracefully",+ },+ {+ "heading": "Slide with Bad Image",+ "bullet_points": ["This slide has an invalid image URL."],+ "img_keywords": (+ "https://invalid-url-that-does-not-exist.example.com/"+ "image.jpg"+ ),+ },+ ]+ filename = "test_invalid_image.pptx"++ with patch.dict(os.environ, {"PEXELS_API_KEY": "test_key"}):+ result = pptx_toolkit.create_presentation(+ json.dumps(content), filename+ )++ # Should still succeed despite invalid image+ assert "successfully created" in result++ # Check the file exists+ file_path = pptx_toolkit._resolve_filepath(filename)+ assert file_path.exists()+++def test_create_presentation_invalid_content_type(pptx_toolkit):+ r"""Test that creating a PPTX file with invalid content type raises+ ValueError."""+ import json++ filename = "test_invalid.pptx"++ # Test with invalid JSON string+ result = pptx_toolkit.create_presentation("invalid json content", filename)+ assert result == "Failed to parse content as JSON"++ # Test with JSON that's not a list+ result = pptx_toolkit.create_presentation(json.dumps({}), filename)+ assert result == "PPTX content must be a list of dictionaries"+++def test_create_presentation_auto_extension(pptx_toolkit):+ r"""Test that the .pptx extension is automatically added if missing."""+ import json++ content = [+ {+ "title": "Test Auto Extension",+ "subtitle": "Should add .pptx extension",+ }+ ]+ filename = "test_auto_extension" # No .pptx extension++ result = pptx_toolkit.create_presentation(json.dumps(content), filename)++ # Check the result message+ assert "successfully created" in result++ # Check the file exists with .pptx extension+ file_path = pptx_toolkit._resolve_filepath(filename + '.pptx')+ assert file_path.exists()+++def test_sanitize_and_resolve_filepath(pptx_toolkit):+ r"""Test that _resolve_filepath sanitizes filenames with spaces and+ special characters."""+ # Test filename with spaces and special characters+ filename = "test file with spaces & special chars!.pptx"+ resolved_path = pptx_toolkit._resolve_filepath(filename)++ # Should replace special characters with underscores+ assert "test_file_with_spaces_special_chars_.pptx" in str(resolved_path)++ # Should be under the output directory+ assert str(pptx_toolkit.output_dir) in str(resolved_path)+++def test_resolve_filepath_absolute_path(pptx_toolkit):+ r"""Test _resolve_filepath with absolute paths."""+ # Create a temporary file path+ with tempfile.NamedTemporaryFile(+ suffix='.pptx', delete=False+ ) as temp_file:+ temp_path = temp_file.name++ try:+ resolved_path = pptx_toolkit._resolve_filepath(temp_path)++ # Should return the absolute path as-is (after sanitization)+ assert resolved_path.is_absolute()+ assert resolved_path.suffix == '.pptx'+ finally:+ # Clean up+ if os.path.exists(temp_path):+ os.unlink(temp_path)+++def test_create_presentation_empty_content(pptx_toolkit):+ r"""Test creating a PPTX file with empty content list."""+ import json++ content = []+ filename = "test_empty.pptx"++ result = pptx_toolkit.create_presentation(json.dumps(content), filename)++ # Should handle empty content gracefully+ assert "successfully created" in result++ # Check the file exists+ file_path = pptx_toolkit._resolve_filepath(filename)+ assert file_path.exists()++ # Verify it's a valid PPTX file with no slides+ try:+ import pptx++ presentation = pptx.Presentation(str(file_path))+ assert len(presentation.slides) == 0+ except ImportError:+ # If python-pptx is not available, just check file exists+ passdiff --git a/uv.lock b/uv.lockindex 264cbced4..040f95956 100644--- a/uv.lock+++ b/uv.lock@@ -98,7 +98,7 @@ wheels = [[[package]]name = "aiohttp"-version = "3.12.4"+version = "3.12.6"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "aiohappyeyeballs" },@@ -110,59 +110,59 @@ dependencies = [{ name = "propcache" },{ name = "yarl" },]-sdist = { url = "https://files.pythonhosted.org/packages/57/77/92b356837fad83cc5709afc0b6e21dce65a413293fed15e6999bafdf36b0/aiohttp-3.12.4.tar.gz", hash = "sha256:d8229b412121160740f5745583c786f3f494d2416fe5f76aabd815da6ab6b193", size = 7781788 }-wheels = [- { url = "https://files.pythonhosted.org/packages/c1/3b/07a1e596f7abd46f1482f056fe28933e66c98ad9ad695c9f31d9f2b37b22/aiohttp-3.12.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:437b9255b470e9dbeb1475b333297ff35c2ef2d5e60735238b0967572936bafa", size = 694881 },- { url = "https://files.pythonhosted.org/packages/f1/62/a5023b2a2c6a3e9fac4c268a5c7c6fdc6e6e969580d2f11804dea2928140/aiohttp-3.12.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1d3af7a8905c87b585f534e5e33e5ecf1a8264c3531f7436329c11b2e952788a", size = 471251 },- { url = "https://files.pythonhosted.org/packages/8c/15/a43fb3198aa8d6fe7b864057133699be5d42caa670af9f0288341bd7af30/aiohttp-3.12.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:18dead0d68a236a475fb6464f6fcc5330fc5e9ee4156c5846780a88f8b739d18", size = 459019 },- { url = "https://files.pythonhosted.org/packages/db/0d/b25a6a3b3c0fee6fe9471c027239341b81a9ad8f9b0d527e3586f0d76d97/aiohttp-3.12.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:520bb505f13ad3397e28d03e52d7bbbbb196f5bab49276bb264b3ce6f0fb57c0", size = 1641076 },- { url = "https://files.pythonhosted.org/packages/86/b2/894b266ec21d7c18f9ca581ca52c4464c791cf6533e04664728f501ad56c/aiohttp-3.12.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:92cb0f7857fe12d029ee5078d243c59b242f6dfb190a6d46238e375c69bcb797", size = 1615130 },- { url = "https://files.pythonhosted.org/packages/c9/5d/59c810044cbffe70be8b49e8b92fc45949484d9027a4aa200921f972e319/aiohttp-3.12.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4e4354d75d2b3988b50ca366974a448d2ee636085fb3091ce2361f9aad7c0bb7", size = 1687536 },- { url = "https://files.pythonhosted.org/packages/0c/a9/c65aa446dbe281c4b557c30899dd3e4716333f0328d63e65c5e66d6aa206/aiohttp-3.12.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:29cfeb097a025efee3ea6eeb7ce2f75ea90008abac508a37775530c4e71a2d17", size = 1729851 },- { url = "https://files.pythonhosted.org/packages/08/36/13c2b7329e9049acc8d5bb7c237a55622b01148a7727ecb69b050b127f24/aiohttp-3.12.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5b6d4caaba6b1658b1f3cf17348d76b313376cccd5a5892e471e24fefdf5ed59", size = 1634517 },- { url = "https://files.pythonhosted.org/packages/53/f5/b7c4734b783ac5111d748e6057959bb2169ce9b65e225846ad4bb27b3b9c/aiohttp-3.12.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d5750aa8a26d27280ca7db81d426a0b7e7bbb36280f0ad4bfaf0a0ee8a0d4ec0", size = 1574640 },- { url = "https://files.pythonhosted.org/packages/bc/c8/e301552530c43fc0821ba7f00fcbf879180d943d228c5d578dd2ea9c1d3f/aiohttp-3.12.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f4e7b557b41eccc0e5f792bc55f6eed9f669dfd9220babefbf0bddad17980c48", size = 1618488 },- { url = "https://files.pythonhosted.org/packages/79/7a/879405d4bb962c6860ecebb4e34e99387a24712511e75a3142e17b35d7ec/aiohttp-3.12.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:2ce301584f6e90bbb5f19b54a99797511c135f980b083e21d688c3927f9f03a8", size = 1629275 },- { url = "https://files.pythonhosted.org/packages/68/2e/4399734a6d8a194f88ce40f678abee7b9b32adf68c2a9a2977d1e93a433c/aiohttp-3.12.4-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:adff2f5a4aa7e11751b439d0de091f7cb74a3567cae97f91a9e371005e50792f", size = 1604727 },- { url = "https://files.pythonhosted.org/packages/29/eb/a7f4ddd80a934df8dd1e96fbaaaec37c7d314d563660b3df5a2de7f8f65c/aiohttp-3.12.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ee88d58b60ad65c755a11452bf630114f72725f13cd5acb00b183fbbb53bb3ef", size = 1684313 },- { url = "https://files.pythonhosted.org/packages/c1/52/fcd1b59668627e108c6f7195ebfb30ff342ea5ff3d2616005092e4230c0c/aiohttp-3.12.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:68d39e3c8a7368cd2ab0b70ebbd80a2de6860079270f550ded37b597b815a9da", size = 1707551 },- { url = "https://files.pythonhosted.org/packages/87/da/3d7ff2cf8594916e98f4fd13771a33d700f038f330f56d21cbca7e37e54e/aiohttp-3.12.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d22596530780156f3292022ee380c21e37c8f9402b38cc456bcdc17e915632d9", size = 1635892 },- { url = "https://files.pythonhosted.org/packages/71/a7/39beaba9905d653972e4fd3bd6775d62458bc2d0ceed3099d47a35844547/aiohttp-3.12.4-cp310-cp310-win32.whl", hash = "sha256:05c89a13a371dcb938fbffa4b7226df9058d9f73c051b56b68acb499383d0221", size = 420202 },- { url = "https://files.pythonhosted.org/packages/70/97/335c4a7180aec0c9deae862d4d866b978f1bd2179ba8889f480afeb88449/aiohttp-3.12.4-cp310-cp310-win_amd64.whl", hash = "sha256:cae4c77621077a74db3874420b0d2a76bf98ef4c340767752fc7b0766d97cdb4", size = 443411 },- { url = "https://files.pythonhosted.org/packages/e9/5e/bd16acce20e07e01d7db8f9a5102714f90928f87ec9cb248db642893ebdf/aiohttp-3.12.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6cfe7a78ed06047420f7709b9ae438431ea2dc50a9c00960a4b996736f1a70a3", size = 702194 },- { url = "https://files.pythonhosted.org/packages/65/1d/cc50b39ca7a24c28e5e79ec7c5a3682c84af76d814f2e1284e1aa473122c/aiohttp-3.12.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1188186a118a6793b1e510399f5deb2dcab9643af05fd5217f7f5b067b863671", size = 474473 },- { url = "https://files.pythonhosted.org/packages/52/6b/bf1ff91cb6eda30964c29a7fbe2a294db00724ceab344696eeebfe4c9ccf/aiohttp-3.12.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d54362f38f532869553a38328931f5f150f0f4fdbee8e122da447663a86552c5", size = 462734 },- { url = "https://files.pythonhosted.org/packages/7c/c3/846872117cc6db1db1b86d20119a3132b8519144d5e710c2e066d07cac86/aiohttp-3.12.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4299504448f37ea9803e6ec99295d7a84a66e674300daa51ca69cace8b7ae31a", size = 1732930 },- { url = "https://files.pythonhosted.org/packages/d0/bd/df557ee83c3e36945499317b9f51dab642c17c779c939fe2df4c0307b85e/aiohttp-3.12.4-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1972bac2ee5dc283ccee3d58501bba08599d58dad6dbbbf58da566dc1a3ac039", size = 1681599 },- { url = "https://files.pythonhosted.org/packages/1b/b9/e043c06325300644fed7685f904323ecf937adc99971ac229ab97b0769d2/aiohttp-3.12.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a286d40eb51d2908130b4e64ca8ae1a1fdf20657ef564eea2556255d52e2147b", size = 1780391 },- { url = "https://files.pythonhosted.org/packages/6c/98/a43da221916db0b9567914e41de5a7e008904b9301540614feab2a03ee45/aiohttp-3.12.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94650ff81e7370ceb79272914be8250558d595864cb0cc3e9c6932a16738e33b", size = 1819437 },- { url = "https://files.pythonhosted.org/packages/bb/9d/e315bdfc2e8ba0382699e686330b588f135189c51df79689e6a843513eb0/aiohttp-3.12.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03a2ca7b7e9436ae933d89d41f21ef535f21dcdc883820544102ddda63b595c2", size = 1721898 },- { url = "https://files.pythonhosted.org/packages/c1/a4/8250493ab4e540df5a3672e5d01c28ca71fd31b4a9afc217c9678ca350e3/aiohttp-3.12.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea47b02ec80408bed4d59b3b824b44514173e4ebd0bc04a901ffd12084142451", size = 1658974 },- { url = "https://files.pythonhosted.org/packages/94/d3/06c8ba3afb270afa44ffb6cf3fb0a44502be347f0fc7fdce290a60760197/aiohttp-3.12.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:41a6ea58ed974e67d75b39536997d81288a04844d8162194d3947cbff52b093d", size = 1707245 },- { url = "https://files.pythonhosted.org/packages/da/5c/d889d8edca8cdb6bb0ff9cfa58b3977320186050c8cfe2f4ceeee149b498/aiohttp-3.12.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:d563387ae8966b6668162698a66495c5d72ce864405a7dfc6cc9c4bc851a63ce", size = 1702405 },- { url = "https://files.pythonhosted.org/packages/e9/db/809ac0c7fa7ddfad33ab888fe3c83aecbfc7f03e44f387a70c20a0a096b7/aiohttp-3.12.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:b853c7f7664742d48c57f382ebae5c76efa7f323569c6d93866795092485deec", size = 1682593 },- { url = "https://files.pythonhosted.org/packages/35/85/9e1f9c7f0b0f70dfae55932c1f080230f885f84137132efc639e98611347/aiohttp-3.12.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:5d74f5fadbab802c598b440b4aecfeadc99194535d87db5764b732a52a0527fb", size = 1776193 },- { url = "https://files.pythonhosted.org/packages/83/12/b6b7b9c2d08c5346473878575195468a585041daa816ffbd97156c960ed0/aiohttp-3.12.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f5065674d38b4a738f38b344429e3688fdcccc9d2d5ec50ca03af5dbf91307e", size = 1796654 },- { url = "https://files.pythonhosted.org/packages/b7/09/0500ae6b1174abc74ab1a7a36033ecffc11e46e47a23487d75fa00d04b46/aiohttp-3.12.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:567db7411a004acd82be2499c10a22e06d4acb51929ce353a62f02f61d005e1c", size = 1709713 },- { url = "https://files.pythonhosted.org/packages/7b/55/8f5faa6e13c51609430081b42c39eb12006c9fb9111eeaedca0f3f574d3b/aiohttp-3.12.4-cp311-cp311-win32.whl", hash = "sha256:4bc000b0eee7c4b8fdc13349ab106c4ff15e6f6c1afffb04a8f5af96f1b89af3", size = 419713 },- { url = "https://files.pythonhosted.org/packages/6a/a9/97e318bfb3fc7a0cffc9dee9f0ec77db5339207887f5f4ebe1a11ecd5f32/aiohttp-3.12.4-cp311-cp311-win_amd64.whl", hash = "sha256:44f1cb869916ba52b7876243b6bb7841430846b66b61933b8e96cfaf44515b78", size = 444103 },- { url = "https://files.pythonhosted.org/packages/6c/9a/767c8f6520d0ad023d6b975f8fda71b506f64ad597bb7bd16fa5ac1562ca/aiohttp-3.12.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:7947933c67eb33f51076cabf99f9977260329759d66c4d779c6b8e35c71a96bf", size = 693297 },- { url = "https://files.pythonhosted.org/packages/82/a1/21eddeee169306c974095183c8820a807c3f05dbefcd6b674a52d18e4090/aiohttp-3.12.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bb046723c90db9ecba67549ab5614707168ba7424742cfab40c198d8d75176e4", size = 467909 },- { url = "https://files.pythonhosted.org/packages/0d/fc/17093fe2d7e4287218fb99b18a6106b0e1fad8a95f974066f8b5fefb0fbc/aiohttp-3.12.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5fe52157c5e160eac99bb3589c2f29186d233fc83f6f42315c828f7e115f87f5", size = 460750 },- { url = "https://files.pythonhosted.org/packages/f8/4f/6ea71dd61725bdaa9437f1a9f032781c5d869046651ad43a93d769855298/aiohttp-3.12.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f5bf2015822cf7177957b8573a5997c3a00b93cd2f40aa8f5155649014563bd8", size = 1707546 },- { url = "https://files.pythonhosted.org/packages/cc/79/a91f52b0d4e4462ebf37b176164d0f26b065f80f7db1dfe9b44fd9e8f8ac/aiohttp-3.12.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:db28a058b837c2a8cbebd0fae78299a41691694e536bb2ad77377bd4978b8372", size = 1690196 },- { url = "https://files.pythonhosted.org/packages/d5/e2/5682bfb2583b55f23d785084bf2237339ebebe73cc0734fa8848d33a270c/aiohttp-3.12.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac155f380e100825fe2ae59b5d4e297fea98d90f5b7df5b27a9096992d8672dd", size = 1745291 },- { url = "https://files.pythonhosted.org/packages/90/1d/5016430fa2ed0d58ca6d6b0f4a1f929c353f72996c95ec33882cd18ed867/aiohttp-3.12.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2de98a1fa249d35f05a6a7525e5823260e8b0c252d72c9cf39d0f945c38da0c7", size = 1791444 },- { url = "https://files.pythonhosted.org/packages/2b/49/33fd3f82ff187b6d982633962afad24bb459ee1cd357399b7545c8e6ed98/aiohttp-3.12.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4c2de2077ee70b93015b4a74493964d891e730d238371c8d4b70413be36b0cf", size = 1710885 },- { url = "https://files.pythonhosted.org/packages/d5/11/e895cb33fca34cec9aa375615ba0d4810a3be601962066444b07a90bc306/aiohttp-3.12.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:058199018d700883c86c473814fb0ecabb4e3ae39bafcbc77ed2c94199e5affb", size = 1626686 },- { url = "https://files.pythonhosted.org/packages/b2/e9/3c98778dbda7cb4c94ddada97cb9ea6d7d5140b487a0444817f8b6a94697/aiohttp-3.12.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b6586aaccf46bc5ae05598fcd09a26fbc9186284eb2551d3262f31a8ec79a463", size = 1687746 },- { url = "https://files.pythonhosted.org/packages/45/7b/fdb43d32ac2819e181e1339aae1bc7acb87e47452af64409181a2bce2426/aiohttp-3.12.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ededddd6fcc8f4403135609d7fb4bc1c1300464ff8fd57fb097b08cc136f18ea", size = 1709199 },- { url = "https://files.pythonhosted.org/packages/bb/d9/b7a37bed158bd4aced1585b89082a8642e516f5b08637d7d15971f61ba31/aiohttp-3.12.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:158495f1d1858c07cc691624ccc92498410edfa57900452948f7eb6bc1be4c39", size = 1649853 },- { url = "https://files.pythonhosted.org/packages/42/4f/7e4d1c52f6e15c59e2f3154d9431a029aab558735e94fec85602207fee8a/aiohttp-3.12.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:41c064200045c344850688b4d7723ebf163b92bfc7c216c29a938d1051385c1c", size = 1729413 },- { url = "https://files.pythonhosted.org/packages/94/83/2987339271a4d8915370614d0bd6b26b7e50d905adf7398636a278ca059a/aiohttp-3.12.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:0834ec8491451780a2a05b0f3a83675911bb0804273ceafcd282bff2548ed962", size = 1757386 },- { url = "https://files.pythonhosted.org/packages/d2/27/3d0fc578531820d166e51024e86b8d35feaa828aa961909396f7cce7a191/aiohttp-3.12.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2a81e4ebbc8d9fb6748046577525ada0c5292606ced068ec9ab3aa6d653bf5d9", size = 1716999 },- { url = "https://files.pythonhosted.org/packages/a9/87/1b5466145a55ebf6145eea5e58e5311653946e518e6e04d971acbae81b09/aiohttp-3.12.4-cp312-cp312-win32.whl", hash = "sha256:73cf6ed61849769dce058a6945d7c63da0798e409494c9ca3fddf5b526f7aee4", size = 414443 },- { url = "https://files.pythonhosted.org/packages/70/0c/c11464953fff9c005e700e060b98436960d85bb60104af868bf5ebec6ace/aiohttp-3.12.4-cp312-cp312-win_amd64.whl", hash = "sha256:1e29de2afbe9c777ff8c58900e19654bf435069535a3a182a50256c8cd3eea17", size = 440544 },+sdist = { url = "https://files.pythonhosted.org/packages/23/28/2d96dffe4deb40faa7f5615b4aa96c87528e65837d8cb5385da4aecf1c07/aiohttp-3.12.6.tar.gz", hash = "sha256:37b1c6034a1e14764adad1829cd710543b1699d7985e1d336f0aa52a2dd76ba9", size = 7784449 }+wheels = [+ { url = "https://files.pythonhosted.org/packages/06/7a/5e64694fb5955e94b96e231a26da1ab14fba22aa64e4138b264d2126cec4/aiohttp-3.12.6-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:77ba53286c89486e8b02fb47352a5a8270bab1084e2a43fe8e35eb261befda13", size = 695321 },+ { url = "https://files.pythonhosted.org/packages/10/1c/ebc577220c3e583e08b10f2a12018e82e975aff8f65d77e38cdf760099af/aiohttp-3.12.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:93f207a64989346bbd0a9d3b31ebaa3934ea6e0242b555491af7eb97ad1c0a5a", size = 471686 },+ { url = "https://files.pythonhosted.org/packages/dd/f9/4fd911875ddbb6e049c3fbbb84f1d1b2fa62e44cc5845e239d3eaf03c4d6/aiohttp-3.12.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ce6673b73352edb17c2db86a9586dc7744e0b5009709152a1e75379f16af19e0", size = 459457 },+ { url = "https://files.pythonhosted.org/packages/ee/af/4855ef83585e2e88dc364307f1d3f162064e3fda7840cbd89d96393162d5/aiohttp-3.12.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:128603479bf13479661d763e77e254139f066914227b5f2ff3284d19e416ad75", size = 1641513 },+ { url = "https://files.pythonhosted.org/packages/68/90/0489400ea0510f9f1c71ae0dcdc036517721fdcfa674d7bef455c5c763c4/aiohttp-3.12.6-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:93a0887cea23f76e9354235b0e79b3c9922ad66529e11637940b6439849105cb", size = 1615568 },+ { url = "https://files.pythonhosted.org/packages/2d/76/8de52ecddeb74bfde4df1149ad92f805c874a672a721409af40f0daabe47/aiohttp-3.12.6-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5fe1d74ab6cd1f16c3c2f0e3c3230481dcedc0d3ad9f0b82b1e43f44a4980aca", size = 1687975 },+ { url = "https://files.pythonhosted.org/packages/ee/c9/6baa9a2afe6acefb1e5cd0d85f8169825cd8ec1d9749a8e401f36d975118/aiohttp-3.12.6-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9aecb4ce110c9d321860a00b4f9ec72bef691d045f54c983fa678606f3f918b0", size = 1730286 },+ { url = "https://files.pythonhosted.org/packages/25/cb/56698b3168efc5b7d8951e8a8cb27e2c8dbb061944f184a3f0dd2e330f9f/aiohttp-3.12.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d5f698e7b5b57aa4dc646c8f13ccd965c694199595d7a45cecefaf0e5c392890", size = 1634954 },+ { url = "https://files.pythonhosted.org/packages/3a/1e/6ae22ea1c30bc0870f0d87522e24b6d9ad377a930806bda111c7eefc4dc7/aiohttp-3.12.6-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e5c6869319c0a5f4150959e065c40836b18a99e02493c3b4c73b25378aa0f0cc", size = 1575075 },+ { url = "https://files.pythonhosted.org/packages/c3/07/460c49e04089ede997510e915989f541b0c0c3cc22b9e1758e5d73f17831/aiohttp-3.12.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:71905d34b3bb1a6be44e986f08404987bb317d890746e71f320cd10cf3222b46", size = 1618925 },+ { url = "https://files.pythonhosted.org/packages/38/14/5cddfe3e797731f8303c43016fdb157a12287dd56ae0a93aab21ddfde5c3/aiohttp-3.12.6-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:d590b36c3497ecfba4aca71ab9342fb2c07e1b69baf4e28ad4227440c128bb22", size = 1629711 },+ { url = "https://files.pythonhosted.org/packages/37/a0/0049025f03558d8e3382d4e4e884507221ff3dab5eee54d76735acd43346/aiohttp-3.12.6-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:a90b6f2d5ca4d3ad56034863237b59b4a5fab270eb6d11b5c0326b4501448b51", size = 1605167 },+ { url = "https://files.pythonhosted.org/packages/73/ee/9733eac5d47259687c78d522215a67aa8df4f77725670373ce24b9538d06/aiohttp-3.12.6-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:7f22a0d9a995c12bb20247334b414edaf65ce8f22a1e838b90210238f9b57571", size = 1684752 },+ { url = "https://files.pythonhosted.org/packages/0b/7d/53f8887bda11cd2b12d7d9991d28f7b01107304ce391d482b70e4f83a112/aiohttp-3.12.6-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:30511c5e66ac4399d46b4bec57a3d56bc16cfb649255fa798ee95d8b45f97a4b", size = 1707987 },+ { url = "https://files.pythonhosted.org/packages/f9/6b/b7393c492555b2b69a9ce876c77d753771ae1d25837d88bb7cd8d9496e8c/aiohttp-3.12.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c05776d1854ae9d8132d7ced7ac0067f602d66589797788ed3902d5c68686db5", size = 1636330 },+ { url = "https://files.pythonhosted.org/packages/04/28/85c16859b3ba1a3061429e0fe48e14ec74a5cba37be88db6a59164a289fa/aiohttp-3.12.6-cp310-cp310-win32.whl", hash = "sha256:8885da8ae99bbe6ce43b79e284ef8e6bc5285dea297fe2a163552f09435c8069", size = 420629 },+ { url = "https://files.pythonhosted.org/packages/0b/57/bfc204636b0758bc178849398fa9adc88f7f3506e904d53331992b6ed73d/aiohttp-3.12.6-cp310-cp310-win_amd64.whl", hash = "sha256:a1532ea3f41a818d4f50db96306a1975bf31f29787802bec4c63c58f61b6e682", size = 443843 },+ { url = "https://files.pythonhosted.org/packages/07/f0/313bd623a40638ed65eddd930fbee3a81efd9c87441ea117067beb66b7e8/aiohttp-3.12.6-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ed4db015494a6d0acaadce035531f9fb321afab2075a4b348811e4f7795e87e6", size = 702633 },+ { url = "https://files.pythonhosted.org/packages/07/59/cd70b7798b5f6c13c65a692dbbbeacf4c085a9ce05a34363c4413384d895/aiohttp-3.12.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:59e19517abef2af49cff79b8a863497036ff401051c79d6a3b6149a48213a7be", size = 474917 },+ { url = "https://files.pythonhosted.org/packages/74/89/fe980184d1313669f731d7f32ce824a3ee1af50b4fe83fe723fcb56ca425/aiohttp-3.12.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d557918fefb29884335e1a257df6c961f35ba1caf8eddaabad762b3436cf87ff", size = 463178 },+ { url = "https://files.pythonhosted.org/packages/cb/2a/abe1c72f9b6959b5459f8b99bcdb661a7c2de7901b0c541c26996dd70006/aiohttp-3.12.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e4fb0d7f221c36ed8469c1d2d9a2bb6a27b543cf90aa46ca701f63fb83dd7ed", size = 1733367 },+ { url = "https://files.pythonhosted.org/packages/61/e2/992378c6b1e1b4beed78044ce5b70b749c269cc6e42472fc878339f90f4e/aiohttp-3.12.6-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:deddf6b1c83ce518a156b7597a0d7a1a7ec5c1d2c973ba3f1a23f18fa2b7d65e", size = 1682037 },+ { url = "https://files.pythonhosted.org/packages/64/11/620be3270f913c8d5ae4e9a88fa5ce80b7a7848324506da8b2916053f5f0/aiohttp-3.12.6-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eefd98dd043c33c45123c56a79c6c39acb628304337c90f16f33569cc3aa4ba6", size = 1780829 },+ { url = "https://files.pythonhosted.org/packages/c7/92/475e7c1781aa0907671b66355ae414f0d479f0bcf0929469ea44678b72c1/aiohttp-3.12.6-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:efbbde2297e4ab10d187103aba9b565277c85ac7d24d98cae201c033ce885504", size = 1819873 },+ { url = "https://files.pythonhosted.org/packages/70/04/9f4ad736af830d68dbd376db17f7294c648af393ec24a148bcd5cc2112c1/aiohttp-3.12.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2a74a566872f41247774980334e5b0309dac11b402e188bde6db8a57de4506cd", size = 1722335 },+ { url = "https://files.pythonhosted.org/packages/76/da/5ec4f8deacc4107bf95590d285879f4054d62ff9300a96d8abb4b1143384/aiohttp-3.12.6-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:24d19cbd1d21d207ee855500d2033f1852b4d2113a741246ff62eb16a3921306", size = 1659410 },+ { url = "https://files.pythonhosted.org/packages/85/38/30df9eedcfe28265f1efb1bfe9b19cc94c5a37aea5d2cd246dde8c8080e3/aiohttp-3.12.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:86fb0a5762f936606dcab1ca248f5053587a598ed44825f4744ce3c53ae9a2e9", size = 1707684 },+ { url = "https://files.pythonhosted.org/packages/e9/4c/c8d375fa9b6ea5c381747e5e56bc0249d33bb12c5d7171d4c1b4fcae02b4/aiohttp-3.12.6-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:d7ff55a38fc9851fa5cff41b30605534dfe4d57d02f79447abfed01499fe31d3", size = 1702843 },+ { url = "https://files.pythonhosted.org/packages/1e/3c/73b6e184df80ebc5ec07c6e9d398713c40091f6cf4a5e75eb93972ee35d6/aiohttp-3.12.6-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:545f89c389a47bac024655b5676658f35f80b0d007e4c3c7ff865d9aa3bf343a", size = 1683031 },+ { url = "https://files.pythonhosted.org/packages/9d/5a/827ca828af26ceeda69459c2848fc58e76adbbea0ad9994429ae885d1a33/aiohttp-3.12.6-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:25dac87ee297e2b5826ce8e96c7615ebe7a1613856b1614a207e3376b776021b", size = 1776629 },+ { url = "https://files.pythonhosted.org/packages/d6/07/8b9081655c08807fa49134b209eddc823e7501bbcf6b044f48a01f30a504/aiohttp-3.12.6-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c1d8a4a5a7e28d8b9ec815ffecca8712b71130a4eee1c5b45e9f2cc4975f3f7c", size = 1797092 },+ { url = "https://files.pythonhosted.org/packages/5d/18/c761b934543512077c3de8d8f383bcafd94ada30c83273ea6ceeeda8aa2c/aiohttp-3.12.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bc4be1d8d68a62859f74f9ada9e174791895366601ce66342f54478d3518c8b3", size = 1710149 },+ { url = "https://files.pythonhosted.org/packages/e0/ba/730f75a17b613f2ecc336b698259140bbd439d8f7b14eae10aea14158085/aiohttp-3.12.6-cp311-cp311-win32.whl", hash = "sha256:a057680218430231eb6ab644d166b7ef398b3ffbac0232f4f789cdce9391400e", size = 420141 },+ { url = "https://files.pythonhosted.org/packages/df/71/8aaff029d07b15f7f79c484ca9b10f34cf8466d8dc4b13ecf32cc46b8de0/aiohttp-3.12.6-cp311-cp311-win_amd64.whl", hash = "sha256:8a88046a5adddf5d99f15a1920f6b8f659f46a4cfb5bfabbd668d06df045df7a", size = 444534 },+ { url = "https://files.pythonhosted.org/packages/e2/71/d4534c305623ba4e759caa381a5902713284f1ee52163d14894e60b3d254/aiohttp-3.12.6-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:cfbf8ed94b57e3b5a886bfe2a530c8eb067064cc4419fd94431a2cbeeddec54c", size = 693736 },+ { url = "https://files.pythonhosted.org/packages/0c/f4/0e4c010b669ef7418fcd5249edc1671bd07492be7989699b92cbc65e19c2/aiohttp-3.12.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:012ea107092d4465aeeb681d5b2fb8b51a847a72f0b71906f40876419fba1355", size = 468347 },+ { url = "https://files.pythonhosted.org/packages/b0/6e/6bc969bab1d4790548220b7bd061b711f246b708d7d8a6d88a0ecb04154c/aiohttp-3.12.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cdb03da5ecf74a331511604f3cf91563bf29127eabb28f4e16d390a73cb826da", size = 461191 },+ { url = "https://files.pythonhosted.org/packages/0a/56/de7ac8b49ce179618ede56f01f0050f75a270f3d9eb5d6905793e331a7d7/aiohttp-3.12.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ca81cb1e41d251cc193164409c0bbb0175e696a9997491a10db9171a2f70603", size = 1707982 },+ { url = "https://files.pythonhosted.org/packages/43/dd/74d8f791bf7832077ce5f7592126a64c6de57849182f730bb75dc7030ee7/aiohttp-3.12.6-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15817882d25e840aba85d1f5706a7128350b81050f8ca9dabfc25a5f521a792c", size = 1690630 },+ { url = "https://files.pythonhosted.org/packages/10/f2/c5e96be25dd3efd0fe4b21a0c583fffadbadfc85f039cc0dd013e08bdc07/aiohttp-3.12.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:db5c402ea0aed10af2e54e5946bf32f3ebb02a7604eaaa4c41a608053889de4a", size = 1745727 },+ { url = "https://files.pythonhosted.org/packages/ad/19/6fb117cf46a99d302405012f05faf67e7ebae925e8ba5a0948f5c046a7b4/aiohttp-3.12.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8ea77675818fd8cac28491d0d59582e5e2e5b14dbf5e21bef797aa5b23b5ca8b", size = 1791881 },+ { url = "https://files.pythonhosted.org/packages/78/2f/cdde703cbfd281aca8679b75289c3cde865a541efc593354e50c5c6b7c01/aiohttp-3.12.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c232720190ca4240c15abefc7b765e987ef88df44d2384612890db87b33898f3", size = 1711323 },+ { url = "https://files.pythonhosted.org/packages/e8/a1/edfdfe7ea9160f1bbf7bd00964da45ac290a5d19661761098eefa95ac400/aiohttp-3.12.6-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a2f3c974874bd0c76dfdcc60db5a6f96ca023a85318a5ac401603baa7e299272", size = 1627125 },+ { url = "https://files.pythonhosted.org/packages/5e/f0/de34cad1d44c6a7e4bffef9d42f982a28a4cdce8815733134aceb542be1d/aiohttp-3.12.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:25de52753386b0c16d5acd2153e7819f52c9e7fc05f5eca804adc174e99b735d", size = 1688185 },+ { url = "https://files.pythonhosted.org/packages/c7/46/e486289bc0a52d2cc4b87091de7428c4c4ddc76465c1aaa22eb953b8bcb7/aiohttp-3.12.6-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:3cc06a99e065ed7e766d2cd574671428261c1b8f30fedfbd91ab3c738fd9c08d", size = 1709637 },+ { url = "https://files.pythonhosted.org/packages/1f/f2/fe3d3955a2c9e78c308783ef0b1b53e5a3b56beb87133a52584e8dda52c0/aiohttp-3.12.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:aac87d78f55057ab48ddcc43055620546d40bbc0888d2658d8705d183c98f901", size = 1650291 },+ { url = "https://files.pythonhosted.org/packages/1c/68/2b425bd8031666be7db81e37918a9b3a9898e02b8d7e672737b05c55e2c5/aiohttp-3.12.6-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:de83f567e31418fd7bc22c5a03526a2b0a82e68c7a7fec23ef91a398228f559b", size = 1729852 },+ { url = "https://files.pythonhosted.org/packages/10/40/a14b0cf78531d504391a311c3e7c190f230cbf7dba5d4ccfbf53a5d121e5/aiohttp-3.12.6-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fd1d6116c1364ab00ffed1654a01091dc7f897d315c5103bcc6e5ab7f70172c7", size = 1757824 },+ { url = "https://files.pythonhosted.org/packages/25/1d/250baf6961354772bf7447bb280dffa2df15c08875e535cf6a735a41373e/aiohttp-3.12.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:58f79b376a426961418df1d08656ec3a01494b7ba81824ae629e6636deddfff7", size = 1717436 },+ { url = "https://files.pythonhosted.org/packages/dc/43/9b9204284c08c244d89c69e3e556dfd7757e0393d4ef20a9238bf2643795/aiohttp-3.12.6-cp312-cp312-win32.whl", hash = "sha256:561f545dc062e6c31fc53535d8584c06516bda2fc37821a67a61b69202061e71", size = 414878 },+ { url = "https://files.pythonhosted.org/packages/fe/c1/8561f01a6386a7ecdc54aefff155aae51a349c98c04b1325619e12049fbc/aiohttp-3.12.6-cp312-cp312-win_amd64.whl", hash = "sha256:d83ab494eb583ba691af9d4d7c073987526bb9f73aa5a19907258ef3a1e39e8a", size = 440981 },][[package]]@@ -536,16 +536,16 @@ css = [[[package]]name = "botocore"-version = "1.38.25"+version = "1.38.27"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "jmespath" },{ name = "python-dateutil" },{ name = "urllib3" },]-sdist = { url = "https://files.pythonhosted.org/packages/6b/00/bed5bf325d1fdb98d6212d106bd44cd0bbe65563e3a2c3f87b64cc4d75c2/botocore-1.38.25.tar.gz", hash = "sha256:8c73e97d9662a6c92be33dab66cd1e2b59797154c7ec379ce3bb5d6779d9d78c", size = 13914295 }+sdist = { url = "https://files.pythonhosted.org/packages/36/5e/67899214ad57f7f26af5bd776ac5eb583dc4ecf5c1e52e2cbfdc200e487a/botocore-1.38.27.tar.gz", hash = "sha256:9788f7efe974328a38cbade64cc0b1e67d27944b899f88cb786ae362973133b6", size = 13919963 }wheels = [- { url = "https://files.pythonhosted.org/packages/2f/ae/3b52634df58cbd506ad804315a1c979ea06942cf88b591dcd671f45adf63/botocore-1.38.25-py3-none-any.whl", hash = "sha256:5a960bd990a11cdb78865e908a58ed712d87d9b419f55ad21c99d7d21f0d6726", size = 13574906 },+ { url = "https://files.pythonhosted.org/packages/7e/83/a753562020b69fa90cebc39e8af2c753b24dcdc74bee8355ee3f6cefdf34/botocore-1.38.27-py3-none-any.whl", hash = "sha256:a785d5e9a5eda88ad6ab9ed8b87d1f2ac409d0226bba6ff801c55359e94d91a8", size = 13580545 },][[package]]@@ -632,7 +632,8 @@ all = [{ name = "mypy" },{ name = "nebula3-python" },{ name = "neo4j" },- { name = "networkx" },+ { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },+ { name = "networkx", version = "3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },{ name = "newspaper3k" },{ name = "notion-client" },{ name = "numpy" },@@ -658,6 +659,7 @@ all = [{ name = "pytest" },{ name = "pytest-asyncio" },{ name = "pytest-cov" },+ { name = "python-pptx" },{ name = "pytidb-experimental" },{ name = "qdrant-client" },{ name = "rank-bm25" },@@ -709,7 +711,8 @@ data-tools = [{ name = "datacommons" },{ name = "datacommons-pandas" },{ name = "math-verify" },- { name = "networkx" },+ { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },+ { name = "networkx", version = "3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },{ name = "numpy" },{ name = "pandas" },{ name = "rouge" },@@ -770,6 +773,7 @@ document-tools = [{ name = "prance" },{ name = "pylatex" },{ name = "pymupdf" },+ { name = "python-pptx" },{ name = "tabulate" },{ name = "unstructured" },{ name = "xls2xlsx" },@@ -832,6 +836,7 @@ owl = [{ name = "pylatex" },{ name = "pymupdf" },{ name = "python-dotenv" },+ { name = "python-pptx" },{ name = "requests-oauthlib" },{ name = "rouge" },{ name = "scenedetect" },@@ -1138,6 +1143,9 @@ requires-dist = [{ name = "pytest-cov", marker = "extra == 'all'", specifier = ">=4,<5" },{ name = "pytest-cov", marker = "extra == 'dev'", specifier = ">=4,<5" },{ name = "python-dotenv", marker = "extra == 'owl'", specifier = ">=1.0.0,<2" },+ { name = "python-pptx", marker = "extra == 'all'", specifier = ">=1.0.2" },+ { name = "python-pptx", marker = "extra == 'document-tools'", specifier = ">=1.0.2" },+ { name = "python-pptx", marker = "extra == 'owl'", specifier = ">=1.0.2" },{ name = "pytidb-experimental", marker = "extra == 'all'", specifier = "==0.0.1.dev4" },{ name = "pytidb-experimental", marker = "extra == 'rag'", specifier = "==0.0.1.dev4" },{ name = "pytidb-experimental", marker = "extra == 'storage'", specifier = "==0.0.1.dev4" },@@ -2574,7 +2582,7 @@ wheels = [[[package]]name = "google-genai"-version = "1.17.0"+version = "1.18.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "anyio" },@@ -2585,9 +2593,9 @@ dependencies = [{ name = "typing-extensions" },{ name = "websockets" },]-sdist = { url = "https://files.pythonhosted.org/packages/51/93/4ad189184db21539c625bba432faa3a36e1e5eeb0b3a0b52fbdc9bdac324/google_genai-1.17.0.tar.gz", hash = "sha256:2cf0ff1218290efe6fad80d586cc4aed5a1ca6d38407d1ae221cf10e308c299b", size = 197180 }+sdist = { url = "https://files.pythonhosted.org/packages/d2/c2/4dac4192aa3f1273d117b54002bde9df565becd0fb5489ec1f58777ce2a3/google_genai-1.18.0.tar.gz", hash = "sha256:242a02df3248e291f03e37019ce5a1c8a21a14ec245b59668c9f2b4d8965295e", size = 197394 }wheels = [- { url = "https://files.pythonhosted.org/packages/57/e8/6cc81b481d71f64896964d6aa105f17f13a974627da5d22a3e676fb056b6/google_genai-1.17.0-py3-none-any.whl", hash = "sha256:0a5ba765cc9900a5fa7e71ed4520a1560a857754e72db32765009e2e9fe75333", size = 199245 },+ { url = "https://files.pythonhosted.org/packages/94/db/dce044ddf3f272248aa517fb8e525b31685b483210a8e08773596dbcc611/google_genai-1.18.0-py3-none-any.whl", hash = "sha256:3527bb93c8306e725401aca0a0a684610bbf1ef9aa61c2ed3333a695f43dc9af", size = 199485 },][[package]]@@ -2879,7 +2887,7 @@ wheels = [[[package]]name = "huggingface-hub"-version = "0.32.2"+version = "0.32.3"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "filelock" },@@ -2891,9 +2899,9 @@ dependencies = [{ name = "tqdm" },{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/d0/76/44f7025d1b3f29336aeb7324a57dd7c19f7c69f6612b7637b39ac7c17302/huggingface_hub-0.32.2.tar.gz", hash = "sha256:64a288b1eadad6b60bbfd50f0e52fd6cfa2ef77ab13c3e8a834a038ae929de54", size = 422847 }+sdist = { url = "https://files.pythonhosted.org/packages/59/74/c4961b31e0f142a032ea24f477c3a7524dfabfd8126398a968b3cc6bf804/huggingface_hub-0.32.3.tar.gz", hash = "sha256:752c889ebf3a63cbd39803f6d87ccc135a463bbcb36abfa2faff0ccbf1cec087", size = 424525 }wheels = [- { url = "https://files.pythonhosted.org/packages/32/30/532fe57467a6cc7ff2e39f088db1cb6d6bf522f724a4a5c7beda1282d5a6/huggingface_hub-0.32.2-py3-none-any.whl", hash = "sha256:f8fcf14603237eadf96dbe577d30b330f8c27b4a0a31e8f6c94fdc25e021fdb8", size = 509968 },+ { url = "https://files.pythonhosted.org/packages/df/dc/4f4d8080cbce7a38c1d0f1ba4932f9134480b9761af8ef4c65d49254b2bd/huggingface_hub-0.32.3-py3-none-any.whl", hash = "sha256:e46f7ea7fe2b5e5f67cc4e37eb201140091946a314d7c2b134a9673dadd80b6a", size = 512094 },][[package]]@@ -3451,15 +3459,15 @@ wheels = [[[package]]name = "linkup-sdk"-version = "0.2.5"+version = "0.2.6"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "httpx" },{ name = "pydantic" },]-sdist = { url = "https://files.pythonhosted.org/packages/8a/85/153ed43354d13be9d677a10b76c1a192125ac39919c8edc72da9c3551fb9/linkup_sdk-0.2.5.tar.gz", hash = "sha256:d19174ff1e1d80f294d13043203e7dbacdc27f65880dcc7bffeef6d2830c42f5", size = 9413 }+sdist = { url = "https://files.pythonhosted.org/packages/23/d0/524a2c07863579299e09bda303f5e1d4a11b176b8153cd7af05d163ce5af/linkup_sdk-0.2.6.tar.gz", hash = "sha256:7b438f4208c04c2cc79843e5b6435b55b0ad718bae1084e1ef569b3b4657e495", size = 9530 }wheels = [- { url = "https://files.pythonhosted.org/packages/ea/41/8c8d224046a11555b87248e5c9af40f185214223f3b5f5b21f2cb363a8cc/linkup_sdk-0.2.5-py3-none-any.whl", hash = "sha256:43c00788fb8b92a959b4a468a87eb625a0b92652f8db89e1180eb9cd65148411", size = 8368 },+ { url = "https://files.pythonhosted.org/packages/64/df/25b5723a2659f2454526f550666ea29e9e66120d01048917519aec8e7a7c/linkup_sdk-0.2.6-py3-none-any.whl", hash = "sha256:63b1039bf3f2a705c59e7ca055be0bfc4bce6a98a641b1d5d606c741c07a6433", size = 8523 },][[package]]@@ -3744,7 +3752,7 @@ wheels = [[[package]]name = "mcp"-version = "1.9.1"+version = "1.9.2"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "anyio" },@@ -3757,9 +3765,9 @@ dependencies = [{ name = "starlette" },{ name = "uvicorn", marker = "sys_platform != 'emscripten'" },]-sdist = { url = "https://files.pythonhosted.org/packages/e7/bc/54aec2c334698cc575ca3b3481eed627125fb66544152fa1af927b1a495c/mcp-1.9.1.tar.gz", hash = "sha256:19879cd6dde3d763297617242888c2f695a95dfa854386a6a68676a646ce75e4", size = 316247 }+sdist = { url = "https://files.pythonhosted.org/packages/ea/03/77c49cce3ace96e6787af624611b627b2828f0dca0f8df6f330a10eea51e/mcp-1.9.2.tar.gz", hash = "sha256:3c7651c053d635fd235990a12e84509fe32780cd359a5bbef352e20d4d963c05", size = 333066 }wheels = [- { url = "https://files.pythonhosted.org/packages/a6/c0/4ac795585a22a0a2d09cd2b1187b0252d2afcdebd01e10a68bbac4d34890/mcp-1.9.1-py3-none-any.whl", hash = "sha256:2900ded8ffafc3c8a7bfcfe8bc5204037e988e753ec398f371663e6a06ecd9a9", size = 130261 },+ { url = "https://files.pythonhosted.org/packages/5d/a6/8f5ee9da9f67c0fd8933f63d6105f02eabdac8a8c0926728368ffbb6744d/mcp-1.9.2-py3-none-any.whl", hash = "sha256:bc29f7fd67d157fef378f89a4210384f5fecf1168d0feb12d22929818723f978", size = 131083 },][[package]]@@ -3995,34 +4003,35 @@ wheels = [[[package]]name = "mypy"-version = "1.15.0"+version = "1.16.0"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "mypy-extensions" },+ { name = "pathspec" },{ name = "tomli", marker = "python_full_version < '3.11'" },{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/ce/43/d5e49a86afa64bd3839ea0d5b9c7103487007d728e1293f52525d6d5486a/mypy-1.15.0.tar.gz", hash = "sha256:404534629d51d3efea5c800ee7c42b72a6554d6c400e6a79eafe15d11341fd43", size = 3239717 }-wheels = [- { url = "https://files.pythonhosted.org/packages/68/f8/65a7ce8d0e09b6329ad0c8d40330d100ea343bd4dd04c4f8ae26462d0a17/mypy-1.15.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:979e4e1a006511dacf628e36fadfecbcc0160a8af6ca7dad2f5025529e082c13", size = 10738433 },- { url = "https://files.pythonhosted.org/packages/b4/95/9c0ecb8eacfe048583706249439ff52105b3f552ea9c4024166c03224270/mypy-1.15.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c4bb0e1bd29f7d34efcccd71cf733580191e9a264a2202b0239da95984c5b559", size = 9861472 },- { url = "https://files.pythonhosted.org/packages/84/09/9ec95e982e282e20c0d5407bc65031dfd0f0f8ecc66b69538296e06fcbee/mypy-1.15.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be68172e9fd9ad8fb876c6389f16d1c1b5f100ffa779f77b1fb2176fcc9ab95b", size = 11611424 },- { url = "https://files.pythonhosted.org/packages/78/13/f7d14e55865036a1e6a0a69580c240f43bc1f37407fe9235c0d4ef25ffb0/mypy-1.15.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7be1e46525adfa0d97681432ee9fcd61a3964c2446795714699a998d193f1a3", size = 12365450 },- { url = "https://files.pythonhosted.org/packages/48/e1/301a73852d40c241e915ac6d7bcd7fedd47d519246db2d7b86b9d7e7a0cb/mypy-1.15.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2e2c2e6d3593f6451b18588848e66260ff62ccca522dd231cd4dd59b0160668b", size = 12551765 },- { url = "https://files.pythonhosted.org/packages/77/ba/c37bc323ae5fe7f3f15a28e06ab012cd0b7552886118943e90b15af31195/mypy-1.15.0-cp310-cp310-win_amd64.whl", hash = "sha256:6983aae8b2f653e098edb77f893f7b6aca69f6cffb19b2cc7443f23cce5f4828", size = 9274701 },- { url = "https://files.pythonhosted.org/packages/03/bc/f6339726c627bd7ca1ce0fa56c9ae2d0144604a319e0e339bdadafbbb599/mypy-1.15.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2922d42e16d6de288022e5ca321cd0618b238cfc5570e0263e5ba0a77dbef56f", size = 10662338 },- { url = "https://files.pythonhosted.org/packages/e2/90/8dcf506ca1a09b0d17555cc00cd69aee402c203911410136cd716559efe7/mypy-1.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2ee2d57e01a7c35de00f4634ba1bbf015185b219e4dc5909e281016df43f5ee5", size = 9787540 },- { url = "https://files.pythonhosted.org/packages/05/05/a10f9479681e5da09ef2f9426f650d7b550d4bafbef683b69aad1ba87457/mypy-1.15.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:973500e0774b85d9689715feeffcc980193086551110fd678ebe1f4342fb7c5e", size = 11538051 },- { url = "https://files.pythonhosted.org/packages/e9/9a/1f7d18b30edd57441a6411fcbc0c6869448d1a4bacbaee60656ac0fc29c8/mypy-1.15.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a95fb17c13e29d2d5195869262f8125dfdb5c134dc8d9a9d0aecf7525b10c2c", size = 12286751 },- { url = "https://files.pythonhosted.org/packages/72/af/19ff499b6f1dafcaf56f9881f7a965ac2f474f69f6f618b5175b044299f5/mypy-1.15.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1905f494bfd7d85a23a88c5d97840888a7bd516545fc5aaedff0267e0bb54e2f", size = 12421783 },- { url = "https://files.pythonhosted.org/packages/96/39/11b57431a1f686c1aed54bf794870efe0f6aeca11aca281a0bd87a5ad42c/mypy-1.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:c9817fa23833ff189db061e6d2eff49b2f3b6ed9856b4a0a73046e41932d744f", size = 9265618 },- { url = "https://files.pythonhosted.org/packages/98/3a/03c74331c5eb8bd025734e04c9840532226775c47a2c39b56a0c8d4f128d/mypy-1.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:aea39e0583d05124836ea645f412e88a5c7d0fd77a6d694b60d9b6b2d9f184fd", size = 10793981 },- { url = "https://files.pythonhosted.org/packages/f0/1a/41759b18f2cfd568848a37c89030aeb03534411eef981df621d8fad08a1d/mypy-1.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2f2147ab812b75e5b5499b01ade1f4a81489a147c01585cda36019102538615f", size = 9749175 },- { url = "https://files.pythonhosted.org/packages/12/7e/873481abf1ef112c582db832740f4c11b2bfa510e829d6da29b0ab8c3f9c/mypy-1.15.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce436f4c6d218a070048ed6a44c0bbb10cd2cc5e272b29e7845f6a2f57ee4464", size = 11455675 },- { url = "https://files.pythonhosted.org/packages/b3/d0/92ae4cde706923a2d3f2d6c39629134063ff64b9dedca9c1388363da072d/mypy-1.15.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8023ff13985661b50a5928fc7a5ca15f3d1affb41e5f0a9952cb68ef090b31ee", size = 12410020 },- { url = "https://files.pythonhosted.org/packages/46/8b/df49974b337cce35f828ba6fda228152d6db45fed4c86ba56ffe442434fd/mypy-1.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1124a18bc11a6a62887e3e137f37f53fbae476dc36c185d549d4f837a2a6a14e", size = 12498582 },- { url = "https://files.pythonhosted.org/packages/13/50/da5203fcf6c53044a0b699939f31075c45ae8a4cadf538a9069b165c1050/mypy-1.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:171a9ca9a40cd1843abeca0e405bc1940cd9b305eaeea2dda769ba096932bb22", size = 9366614 },- { url = "https://files.pythonhosted.org/packages/09/4e/a7d65c7322c510de2c409ff3828b03354a7c43f5a8ed458a7a131b41c7b9/mypy-1.15.0-py3-none-any.whl", hash = "sha256:5469affef548bd1895d86d3bf10ce2b44e33d86923c29e4d675b3e323437ea3e", size = 2221777 },+sdist = { url = "https://files.pythonhosted.org/packages/d4/38/13c2f1abae94d5ea0354e146b95a1be9b2137a0d506728e0da037c4276f6/mypy-1.16.0.tar.gz", hash = "sha256:84b94283f817e2aa6350a14b4a8fb2a35a53c286f97c9d30f53b63620e7af8ab", size = 3323139 }+wheels = [+ { url = "https://files.pythonhosted.org/packages/64/5e/a0485f0608a3d67029d3d73cec209278b025e3493a3acfda3ef3a88540fd/mypy-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7909541fef256527e5ee9c0a7e2aeed78b6cda72ba44298d1334fe7881b05c5c", size = 10967416 },+ { url = "https://files.pythonhosted.org/packages/4b/53/5837c221f74c0d53a4bfc3003296f8179c3a2a7f336d7de7bbafbe96b688/mypy-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e71d6f0090c2256c713ed3d52711d01859c82608b5d68d4fa01a3fe30df95571", size = 10087654 },+ { url = "https://files.pythonhosted.org/packages/29/59/5fd2400352c3093bed4c09017fe671d26bc5bb7e6ef2d4bf85f2a2488104/mypy-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:936ccfdd749af4766be824268bfe22d1db9eb2f34a3ea1d00ffbe5b5265f5491", size = 11875192 },+ { url = "https://files.pythonhosted.org/packages/ad/3e/4bfec74663a64c2012f3e278dbc29ffe82b121bc551758590d1b6449ec0c/mypy-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4086883a73166631307fdd330c4a9080ce24913d4f4c5ec596c601b3a4bdd777", size = 12612939 },+ { url = "https://files.pythonhosted.org/packages/88/1f/fecbe3dcba4bf2ca34c26ca016383a9676711907f8db4da8354925cbb08f/mypy-1.16.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:feec38097f71797da0231997e0de3a58108c51845399669ebc532c815f93866b", size = 12874719 },+ { url = "https://files.pythonhosted.org/packages/f3/51/c2d280601cd816c43dfa512a759270d5a5ef638d7ac9bea9134c8305a12f/mypy-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:09a8da6a0ee9a9770b8ff61b39c0bb07971cda90e7297f4213741b48a0cc8d93", size = 9487053 },+ { url = "https://files.pythonhosted.org/packages/24/c4/ff2f79db7075c274fe85b5fff8797d29c6b61b8854c39e3b7feb556aa377/mypy-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9f826aaa7ff8443bac6a494cf743f591488ea940dd360e7dd330e30dd772a5ab", size = 10884498 },+ { url = "https://files.pythonhosted.org/packages/02/07/12198e83006235f10f6a7808917376b5d6240a2fd5dce740fe5d2ebf3247/mypy-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:82d056e6faa508501af333a6af192c700b33e15865bda49611e3d7d8358ebea2", size = 10011755 },+ { url = "https://files.pythonhosted.org/packages/f1/9b/5fd5801a72b5d6fb6ec0105ea1d0e01ab2d4971893076e558d4b6d6b5f80/mypy-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:089bedc02307c2548eb51f426e085546db1fa7dd87fbb7c9fa561575cf6eb1ff", size = 11800138 },+ { url = "https://files.pythonhosted.org/packages/2e/81/a117441ea5dfc3746431e51d78a4aca569c677aa225bca2cc05a7c239b61/mypy-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6a2322896003ba66bbd1318c10d3afdfe24e78ef12ea10e2acd985e9d684a666", size = 12533156 },+ { url = "https://files.pythonhosted.org/packages/3f/38/88ec57c6c86014d3f06251e00f397b5a7daa6888884d0abf187e4f5f587f/mypy-1.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:021a68568082c5b36e977d54e8f1de978baf401a33884ffcea09bd8e88a98f4c", size = 12742426 },+ { url = "https://files.pythonhosted.org/packages/bd/53/7e9d528433d56e6f6f77ccf24af6ce570986c2d98a5839e4c2009ef47283/mypy-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:54066fed302d83bf5128632d05b4ec68412e1f03ef2c300434057d66866cea4b", size = 9478319 },+ { url = "https://files.pythonhosted.org/packages/70/cf/158e5055e60ca2be23aec54a3010f89dcffd788732634b344fc9cb1e85a0/mypy-1.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c5436d11e89a3ad16ce8afe752f0f373ae9620841c50883dc96f8b8805620b13", size = 11062927 },+ { url = "https://files.pythonhosted.org/packages/94/34/cfff7a56be1609f5d10ef386342ce3494158e4d506516890142007e6472c/mypy-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f2622af30bf01d8fc36466231bdd203d120d7a599a6d88fb22bdcb9dbff84090", size = 10083082 },+ { url = "https://files.pythonhosted.org/packages/b3/7f/7242062ec6288c33d8ad89574df87c3903d394870e5e6ba1699317a65075/mypy-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d045d33c284e10a038f5e29faca055b90eee87da3fc63b8889085744ebabb5a1", size = 11828306 },+ { url = "https://files.pythonhosted.org/packages/6f/5f/b392f7b4f659f5b619ce5994c5c43caab3d80df2296ae54fa888b3d17f5a/mypy-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b4968f14f44c62e2ec4a038c8797a87315be8df7740dc3ee8d3bfe1c6bf5dba8", size = 12702764 },+ { url = "https://files.pythonhosted.org/packages/9b/c0/7646ef3a00fa39ac9bc0938626d9ff29d19d733011be929cfea59d82d136/mypy-1.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eb14a4a871bb8efb1e4a50360d4e3c8d6c601e7a31028a2c79f9bb659b63d730", size = 12896233 },+ { url = "https://files.pythonhosted.org/packages/6d/38/52f4b808b3fef7f0ef840ee8ff6ce5b5d77381e65425758d515cdd4f5bb5/mypy-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:bd4e1ebe126152a7bbaa4daedd781c90c8f9643c79b9748caa270ad542f12bec", size = 9565547 },+ { url = "https://files.pythonhosted.org/packages/99/a3/6ed10530dec8e0fdc890d81361260c9ef1f5e5c217ad8c9b21ecb2b8366b/mypy-1.16.0-py3-none-any.whl", hash = "sha256:29e1499864a3888bca5c1542f2d7232c6e586295183320caa95758fc84034031", size = 2265773 },][[package]]@@ -4173,11 +4182,33 @@ wheels = [name = "networkx"version = "3.4.2"source = { registry = "https://pypi.org/simple" }+resolution-markers = [+ "python_full_version < '3.11' and sys_platform == 'darwin'",+ "python_full_version < '3.11' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version < '3.11' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version < '3.11' and sys_platform != 'darwin' and sys_platform != 'linux')",+]sdist = { url = "https://files.pythonhosted.org/packages/fd/1d/06475e1cd5264c0b870ea2cc6fdb3e37177c1e565c43f56ff17a10e3937f/networkx-3.4.2.tar.gz", hash = "sha256:307c3669428c5362aab27c8a1260aa8f47c4e91d3891f48be0141738d8d053e1", size = 2151368 }wheels = [{ url = "https://files.pythonhosted.org/packages/b9/54/dd730b32ea14ea797530a4479b2ed46a6fb250f682a9cfb997e968bf0261/networkx-3.4.2-py3-none-any.whl", hash = "sha256:df5d4365b724cf81b8c6a7312509d0c22386097011ad1abe274afd5e9d3bbc5f", size = 1723263 },]+[[package]]+name = "networkx"+version = "3.5"+source = { registry = "https://pypi.org/simple" }+resolution-markers = [+ "python_full_version >= '3.12' and sys_platform == 'darwin'",+ "python_full_version >= '3.12' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version >= '3.12' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version >= '3.12' and sys_platform != 'darwin' and sys_platform != 'linux')",+ "python_full_version == '3.11.*' and sys_platform == 'darwin'",+ "python_full_version == '3.11.*' and platform_machine == 'aarch64' and sys_platform == 'linux'",+ "(python_full_version == '3.11.*' and platform_machine != 'aarch64' and sys_platform == 'linux') or (python_full_version == '3.11.*' and sys_platform != 'darwin' and sys_platform != 'linux')",+]+sdist = { url = "https://files.pythonhosted.org/packages/6c/4f/ccdb8ad3a38e583f214547fd2f7ff1fc160c43a75af88e6aec213404b96a/networkx-3.5.tar.gz", hash = "sha256:d4c6f9cf81f52d69230866796b82afbccdec3db7ae4fbd1b65ea750feed50037", size = 2471065 }+wheels = [+ { url = "https://files.pythonhosted.org/packages/eb/8d/776adee7bbf76365fdd7f2552710282c79a4ead5d2a46408c9043a2b70ba/networkx-3.5-py3-none-any.whl", hash = "sha256:0030d386a9a06dee3565298b4a734b68589749a544acbb6c412dc9e2489ec6ec", size = 2034406 },+]+[[package]]name = "newspaper3k"version = "0.2.8"@@ -4450,7 +4481,7 @@ wheels = [[[package]]name = "openai"-version = "1.82.0"+version = "1.82.1"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "anyio" },@@ -4462,9 +4493,9 @@ dependencies = [{ name = "tqdm" },{ name = "typing-extensions" },]-sdist = { url = "https://files.pythonhosted.org/packages/3f/19/6b09bb3132f7e1a7a2291fd46fb33659bbccca041f863abd682e14ba86d7/openai-1.82.0.tar.gz", hash = "sha256:b0a009b9a58662d598d07e91e4219ab4b1e3d8ba2db3f173896a92b9b874d1a7", size = 461092 }+sdist = { url = "https://files.pythonhosted.org/packages/5e/53/fd5318cd79202744711c120f008d9bd987eacc063b15910a820bc9b9f40e/openai-1.82.1.tar.gz", hash = "sha256:ffc529680018e0417acac85f926f92aa0bbcbc26e82e2621087303c66bc7f95d", size = 461322 }wheels = [- { url = "https://files.pythonhosted.org/packages/51/4b/a59464ee5f77822a81ee069b4021163a0174940a92685efc3cf8b4c443a3/openai-1.82.0-py3-none-any.whl", hash = "sha256:8c40647fea1816516cb3de5189775b30b5f4812777e40b8768f361f232b61b30", size = 720412 },+ { url = "https://files.pythonhosted.org/packages/a8/d9/7ec61c010f0d0b0bc57dab8b8dff398f84230d269e8bfa068ad542ff050c/openai-1.82.1-py3-none-any.whl", hash = "sha256:334eb5006edf59aa464c9e932b9d137468d810b2659e5daea9b3a8c39d052395", size = 720466 },][[package]]@@ -4856,6 +4887,15 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/7d/eb/b6260b31b1a96386c0a880edebe26f89669098acea8e0318bff6adb378fd/pathable-0.4.4-py3-none-any.whl", hash = "sha256:5ae9e94793b6ef5a4cbe0a7ce9dbbefc1eec38df253763fd0aeeacf2762dbbc2", size = 9592 },]+[[package]]+name = "pathspec"+version = "0.12.1"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043 }+wheels = [+ { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191 },+]+[[package]]name = "pdfminer-six"version = "20250506"@@ -5862,6 +5902,21 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/53/67/f56c69a98c7eb244025845506387d0f961681657c9fcd8b2d2edd148f9d2/python_oxmsg-0.0.2-py3-none-any.whl", hash = "sha256:22be29b14c46016bcd05e34abddfd8e05ee82082f53b82753d115da3fc7d0355", size = 31455 },]+[[package]]+name = "python-pptx"+version = "1.0.2"+source = { registry = "https://pypi.org/simple" }+dependencies = [+ { name = "lxml" },+ { name = "pillow" },+ { name = "typing-extensions" },+ { name = "xlsxwriter" },+]+sdist = { url = "https://files.pythonhosted.org/packages/52/a9/0c0db8d37b2b8a645666f7fd8accea4c6224e013c42b1d5c17c93590cd06/python_pptx-1.0.2.tar.gz", hash = "sha256:479a8af0eaf0f0d76b6f00b0887732874ad2e3188230315290cd1f9dd9cc7095", size = 10109297 }+wheels = [+ { url = "https://files.pythonhosted.org/packages/d9/4f/00be2196329ebbff56ce564aa94efb0fbc828d00de250b1980de1a34ab49/python_pptx-1.0.2-py3-none-any.whl", hash = "sha256:160838e0b8565a8b1f67947675886e9fea18aa5e795db7ae531606d68e785cba", size = 472788 },+]+[[package]]name = "python3-xlib"version = "0.15"@@ -6392,14 +6447,14 @@ wheels = [[[package]]name = "ruamel-yaml"-version = "0.18.11"+version = "0.18.12"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "ruamel-yaml-clib", marker = "platform_python_implementation == 'CPython'" },]-sdist = { url = "https://files.pythonhosted.org/packages/9d/8f/dfbab2d5ec83da0605ab935fb43ffa8ab5828455e2c910b7314fdd18e0b8/ruamel.yaml-0.18.11.tar.gz", hash = "sha256:b586a3416676566ed45bf679a0909719f7ea7b58c03a9b6e03f905a1e2cd5076", size = 144299 }+sdist = { url = "https://files.pythonhosted.org/packages/56/2f/5a4dd48a259cb72d6f972abb728d3b219b50980fe3b7c548e0be7c5f56aa/ruamel.yaml-0.18.12.tar.gz", hash = "sha256:5a38fd5ce39d223bebb9e3a6779e86b9427a03fb0bf9f270060f8b149cffe5e2", size = 144847 }wheels = [- { url = "https://files.pythonhosted.org/packages/2e/62/615a16ebbca43fd4434843e9d346d795a134d0a1ff46101c858d93c9778d/ruamel.yaml-0.18.11-py3-none-any.whl", hash = "sha256:eca06c9fce6ee3220845c4c54e58376586e041a6127e4d1958e12a3142084897", size = 118313 },+ { url = "https://files.pythonhosted.org/packages/04/9e/91fe10ea09e2383f0d0531cf3da765fa01b3b9918e85df92081813259cf4/ruamel.yaml-0.18.12-py3-none-any.whl", hash = "sha256:790ba4c48b6a6e6b12b532a7308779eb12d2aaab3a80fdb8389216f28ea2b287", size = 118407 },][[package]]@@ -7032,15 +7087,14 @@ wheels = [[[package]]name = "sse-starlette"-version = "2.3.5"+version = "2.3.6"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "anyio" },- { name = "starlette" },]-sdist = { url = "https://files.pythonhosted.org/packages/10/5f/28f45b1ff14bee871bacafd0a97213f7ec70e389939a80c60c0fb72a9fc9/sse_starlette-2.3.5.tar.gz", hash = "sha256:228357b6e42dcc73a427990e2b4a03c023e2495ecee82e14f07ba15077e334b2", size = 17511 }+sdist = { url = "https://files.pythonhosted.org/packages/8c/f4/989bc70cb8091eda43a9034ef969b25145291f3601703b82766e5172dfed/sse_starlette-2.3.6.tar.gz", hash = "sha256:0382336f7d4ec30160cf9ca0518962905e1b69b72d6c1c995131e0a703b436e3", size = 18284 }wheels = [- { url = "https://files.pythonhosted.org/packages/c8/48/3e49cf0f64961656402c0023edbc51844fe17afe53ab50e958a6dbbbd499/sse_starlette-2.3.5-py3-none-any.whl", hash = "sha256:251708539a335570f10eaaa21d1848a10c42ee6dc3a9cf37ef42266cdb1c52a8", size = 10233 },+ { url = "https://files.pythonhosted.org/packages/81/05/78850ac6e79af5b9508f8841b0f26aa9fd329a1ba00bf65453c2d312bcc8/sse_starlette-2.3.6-py3-none-any.whl", hash = "sha256:d49a8285b182f6e2228e2609c350398b2ca2c36216c2675d875f81e93548f760", size = 10606 },][[package]]@@ -7324,7 +7378,8 @@ dependencies = [{ name = "filelock" },{ name = "fsspec" },{ name = "jinja2" },- { name = "networkx" },+ { name = "networkx", version = "3.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },+ { name = "networkx", version = "3.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },{ name = "nvidia-cublas-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },{ name = "nvidia-cuda-cupti-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },{ name = "nvidia-cuda-nvrtc-cu12", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" },@@ -7401,7 +7456,7 @@ wheels = [[[package]]name = "transformers"-version = "4.52.3"+version = "4.52.4"source = { registry = "https://pypi.org/simple" }dependencies = [{ name = "filelock" },@@ -7415,9 +7470,9 @@ dependencies = [{ name = "tokenizers" },{ name = "tqdm" },]-sdist = { url = "https://files.pythonhosted.org/packages/07/42/271bcf364788337ac24e7f200005ac7142aaf022206bd6119d2daca22c04/transformers-4.52.3.tar.gz", hash = "sha256:2e1de29374f27920aaf6d589d4e6339f33def2fb08809e1a1d792e040e9fbce7", size = 8951324 }+sdist = { url = "https://files.pythonhosted.org/packages/da/a9/275037087f9d846580b02f2d7cae0e0a6955d46f84583d0151d6227bd416/transformers-4.52.4.tar.gz", hash = "sha256:aff3764441c1adc192a08dba49740d3cbbcb72d850586075aed6bd89b98203e6", size = 8945376 }wheels = [- { url = "https://files.pythonhosted.org/packages/36/f8/1f086942bc6a044e4e68dacf6de761a45367795efd5f57ad356765691c79/transformers-4.52.3-py3-none-any.whl", hash = "sha256:cd04059da50e7cf2a617ce3143ba8beffbf119f8c25a0717c3454fd9d0f19609", size = 10460322 },+ { url = "https://files.pythonhosted.org/packages/96/f2/25b27b396af03d5b64e61976b14f7209e2939e9e806c10749b6d277c273e/transformers-4.52.4-py3-none-any.whl", hash = "sha256:203f5c19416d5877e36e88633943761719538a25d9775977a24fe77a1e5adfc7", size = 10460375 },][[package]]@@ -8018,6 +8073,15 @@ wheels = [{ url = "https://files.pythonhosted.org/packages/fc/be/8302d331252974200ff4adb392d1fc67e4ff161c85a3109b915f4cbaa1ca/xls2xlsx-0.2.0-py2.py3-none-any.whl", hash = "sha256:a6b9c6f887d2e366a54d26682d1ec399f5dbf408567d47768ef6178ef587af4e", size = 39191 },]+[[package]]+name = "xlsxwriter"+version = "3.2.3"+source = { registry = "https://pypi.org/simple" }+sdist = { url = "https://files.pythonhosted.org/packages/a7/d1/e026d33dd5d552e5bf3a873dee54dad66b550230df8290d79394f09b2315/xlsxwriter-3.2.3.tar.gz", hash = "sha256:ad6fd41bdcf1b885876b1f6b7087560aecc9ae5a9cc2ba97dcac7ab2e210d3d5", size = 209135 }+wheels = [+ { url = "https://files.pythonhosted.org/packages/37/b1/a252d499f2760b314fcf264d2b36fcc4343a1ecdb25492b210cb0db70a68/XlsxWriter-3.2.3-py3-none-any.whl", hash = "sha256:593f8296e8a91790c6d0378ab08b064f34a642b3feb787cf6738236bd0a4860d", size = 169433 },+]+[[package]]name = "xmltodict"version = "0.14.2"