🐫 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: Add benchmarks API-Bank, APIBench, Nexus (#1136)
HHHHHejia926596ed5f87
diff --git a/camel/benchmarks/__init__.py b/camel/benchmarks/__init__.pyindex e5f93e76d..284e9d7b0 100644--- a/camel/benchmarks/__init__.py+++ b/camel/benchmarks/__init__.py@@ -14,5 +14,15 @@from .base import BaseBenchmarkfrom .gaia import DefaultGAIARetriever, GAIABenchmark+from .nexus import NexusBenchmark+from .apibank import APIBankBenchmark+from .apibench import APIBenchBenchmark-__all__ = ["BaseBenchmark", "GAIABenchmark", "DefaultGAIARetriever"]+__all__ = [+ "BaseBenchmark",+ "GAIABenchmark",+ "DefaultGAIARetriever",+ "NexusBenchmark",+ "APIBenchBenchmark",+ "APIBankBenchmark",+]diff --git a/camel/benchmarks/apibank.py b/camel/benchmarks/apibank.pynew file mode 100644index 000000000..0d802ebf1--- /dev/null+++ b/camel/benchmarks/apibank.py@@ -0,0 +1,556 @@+# ========= 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 json+import logging+import os+import random+import re+import sys+from pathlib import Path+from typing import Any, Dict, List, Literal, Optional++import numpy as np+from rouge import Rouge+from tqdm import tqdm++from camel.agents import ChatAgent+from camel.benchmarks import BaseBenchmark+from camel.messages.base import BaseMessage+from camel.utils import download_github_subdirectory++logger = logging.getLogger(__name__)+++def process_messages(+ chat_history: List[Dict[str, Any]],+ prompt: str,+) -> List[Dict[str, str]]:+ """+ Processes chat history into a structured format for further use.++ Args:+ chat_history (List[Dict[str, Any]):+ A list of dictionaries representing the chat history.+ prompt (str): A propmt to be set as the system message.++ Returns:+ List[Dict[str, str]]: A list of dictionaries representing+ the processed messages, where each dictionary has:+ - 'role': The role of the message ('system', 'user', or 'assistant').+ - 'content': The content of the message, including formatted+ API responses when applicable.+ """+ messages = [{'role': 'system', 'content': prompt}]+ for item in chat_history:+ role_map = {'User': 'user', 'AI': 'assistant', 'API': 'system'}+ chat_role = role_map.get(+ item['role'], 'unknown'+ ) # default role to 'unknown'+ if item['role'] == 'API':+ chat_content = '[{}({})] Response: {}'.format(+ item['api_name'],+ ', '.join(+ [+ '{}=\'{}\''.format(k, v)+ for k, v in item['param_dict'].items()+ ]+ ),+ str(item['result']['output']),+ )+ else:+ chat_content = item['text']+ messages.append({'role': chat_role, 'content': chat_content})+ return messages+++class APIBankBenchmark(BaseBenchmark):+ r"""API-Bank Benchmark adapted from `API-Bank:+ A Comprehensive Benchmark for Tool-Augmented LLMs`+ <https://github.com/AlibabaResearch/DAMO-ConvAI/tree/main/api-bank>.++ Args:+ save_to (str): The file to save the results.+ processes (int, optional): The number of processes to use.+ (default: :obj:`1`)+ """++ def __init__(+ self,+ save_to: str,+ processes: int = 1,+ ):+ r"""Initialize the APIBank benchmark.++ Args:+ save_to (str): The file to save the results.+ processes (int, optional): The number of processes to use for+ parallel processing. (default: :obj:`1`)+ """+ # Predefine data_dir for better import management+ super().__init__("apibank", "api_bank", save_to, processes)+ self._data: Dict[str, List[APIBankSample]] = dict() # type: ignore[assignment]++ def download(self):+ r"""Download APIBank dataset and code from Github."""++ repo = "AlibabaResearch/DAMO-ConvAI"+ subdir = "api-bank"+ data_dir = self.data_dir++ download_github_subdirectory(repo, subdir, data_dir)++ sys.path.insert(0, self.data_dir)+ logger.info("Download completed.")++ def load(self, level: str, force_download: bool = False): # type: ignore[override]+ r"""Load the APIBank Benchmark dataset.++ Args:+ level (str): Level to run benchmark on.+ force_download (bool, optional): Whether to+ force download the data.+ """+ if force_download:+ logger.info("Force downloading data.")+ self.download()++ if level == "level-1":+ file_path = Path("api_bank/lv1-lv2-samples/level-1-given-desc")+ elif level == 'level-2':+ file_path = Path("api_bank/lv1-lv2-samples/level-2-toolsearcher")+ jsonl_files = [+ f for f in os.listdir(file_path) if f.endswith('.jsonl')+ ]+ for file in tqdm(jsonl_files, desc="Processing files"):+ history = []+ with open(file_path / file, 'r') as f:+ for line in f:+ history.append(json.loads(line))+ samples = APIBankSample.from_chat_history(history)+ self._data[file.rsplit('.', 1)[0]] = samples++ # Change import to relative import in the downloaded python files+ def process_files(folder_path, replacements):+ r"""Replace absolute imports in downloaded files with+ relative import."""+ for file in os.listdir(folder_path):+ if file.endswith(".py"):+ file_path = os.path.join(folder_path, file)+ try:+ with open(file_path, "r", encoding="utf-8") as file:+ content = file.read()++ original_content = content++ for pattern, replacement in replacements:+ content = re.sub(pattern, replacement, content)++ if content != original_content:+ with open(+ file_path, "w", encoding="utf-8"+ ) as file:+ file.write(content)+ logger.info(f"Updated file: {file_path}")++ except Exception as e:+ logger.info(f"Error processing file {file_path}: {e}")++ api_bank_folder = "api_bank"+ apis_folder = os.path.join(api_bank_folder, "apis")++ apis_replacements = [+ (r"from apis.api", "from .api"),+ (r"from apis import", "from .api import"),+ ]++ api_bank_replacements = [+ (r"from apis", "from .apis"),+ (r"from api_call_extraction", "from .api_call_extraction"),+ (r"f'{basename}", r"f'api_bank.{basename}"),+ ]++ process_files(apis_folder, apis_replacements)+ process_files(api_bank_folder, api_bank_replacements)++ def run( # type: ignore[override, return]+ self,+ agent: ChatAgent,+ level: Literal["level-1", "level-2"],+ api_test_enabled=True,+ randomize: bool = False,+ subset: Optional[int] = None,+ ) -> Dict[str, Any]:+ r"""Run the benchmark.++ Args:+ agent (ChatAgent): The agent to run the+ benchmark.+ level (Literal['level-1', 'level-2']):+ The level to run the benchmark on.+ randomize (bool, optional): Whether to+ randomize the data.+ api_test_enabled (bool): Whether to test+ API calling (`True`) or response (`False`)+ (default: :obj:`False`)+ subset (Optional[int], optional):+ The subset of data to run.+ (default: :obj:`None`)++ Returns:+ Dict[str, Any]: The results of the benchmark.+ """+ logger.info(f"Running APIBench benchmark on {level}.")+ self.load(level)+ datas = self._data++ # Shuffle and subset data if necessary+ if randomize:+ randomized_items = list(datas.items())+ random.shuffle(randomized_items)+ datas = dict(randomized_items)+ if subset:+ datas = dict(list(datas.items())[:subset])++ logger.info(f"Number of tasks: {len(datas)}")++ # Initialize results storage+ self._results = []++ # The following code are adapted from the evaluator+ # from the original repo:+ tool_search_enabled = level == "level-2"+ dialog_test_enabled = not api_test_enabled+ total_api_calls, correct_api_calls, rougel_scores = 0, 0, []++ with open(self.save_to, "w") as f:+ for test in tqdm(datas, desc="Running"):+ samples = self._data[test]+ evaluator = Evaluator(samples) # type: ignore[arg-type]++ for sample_id in evaluator.get_all_sample_ids():+ # Process sample and generate response+ sample = evaluator.dataset[sample_id]++ if (+ sample.ground_truth['role'] == 'API'+ and api_test_enabled+ ):+ if tool_search_enabled:+ _, chat_history = evaluator.get_model_input(+ sample_id+ )+ api_descriptions = evaluator.get_api_description(+ 'ToolSearcher'+ )+ else:+ api_descriptions, chat_history = (+ evaluator.get_model_input(sample_id)+ )+ messages = process_messages(+ chat_history, API_CALL_PROMPT + api_descriptions+ )+ model_output = agent_call(messages, agent)+ api_call = get_api_call(model_output)++ # Evaluate API call+ if api_call:+ try:+ correct, model_output_result = (+ evaluator.evaluate(sample_id, api_call)+ )+ except AssertionError as e:+ if 'The API name is not correct.' not in str(+ e+ ):+ raise e+ logging.info('AssertionError: {}'.format(e))+ correct = False+ else:+ model_output_result = 'No API call found'+ correct = False+ if correct:+ correct_api_calls += 1+ logging.info(+ 'Correct API call: {} Ground truth: {}'.format(+ api_call, sample.ground_truth+ )+ )+ else:+ logging.info(+ 'Incorrect model output: {} Result: {} \+ Ground truth: {} File: {} Sample ID: {} \+ Messages: {}'.format(+ model_output.replace('\n', ' '),+ model_output_result,+ sample.ground_truth,+ test,+ sample_id,+ messages[1:],+ )+ )+ total_api_calls += 1+ self._results.append(+ {+ 'Role': 'API',+ 'Model_output': model_output,+ 'Model_output_result': model_output_result,+ 'Ground_truth': sample.ground_truth,+ 'Test': test,+ 'Correct': correct,+ }+ )+ f.write(json.dumps(self._results[-1], indent=2) + "\n")++ elif (+ sample.ground_truth['role'] == 'AI'+ and dialog_test_enabled+ ):+ # Process sample and generate response+ api_descriptions, chat_history = (+ evaluator.get_model_input(sample_id)+ )++ messages = process_messages(+ chat_history, RESPONSE_PROMPT + api_descriptions+ )+ model_output = agent_call(messages, agent)++ # Evaluate model response+ if model_output:+ score = evaluator.evaluate(sample_id, model_output)+ else:+ score = 0+ rougel_scores.append(score)+ if score < 0.2:+ logging.info(+ 'Low score: {} Score: {} Ground truth: {} \+ Test: {} Sample ID: {} \+ Messages: {}'.format(+ model_output.replace('\n', ' '),+ score,+ sample.ground_truth,+ test,+ sample_id,+ messages[1:],+ )+ )++ self._results.append(+ {+ 'Role': 'AI',+ 'Model_output': model_output,+ 'Score': score,+ 'Ground_truth': sample.ground_truth,+ 'Test': test,+ }+ )+ f.write(json.dumps(self._results[-1], indent=2) + "\n")++ f.flush()++ if api_test_enabled:+ return {+ 'total': total_api_calls,+ 'correct': correct_api_calls,+ "accuracy": correct_api_calls / total_api_calls+ if total_api_calls+ else 0,+ }+ elif dialog_test_enabled:+ return {'Dialog_score': np.mean(rougel_scores)}+++# The following code are migrated from the original repo:+# https://github.com/AlibabaResearch/DAMO-ConvAI/tree/main/api-bank+def agent_call(messages: List[Dict], agent: ChatAgent):+ r"""Add messages to agent memory and get response."""+ for i, msg in enumerate(messages):+ if msg['role'] == 'user':+ message = BaseMessage.make_user_message(+ role_name="CAMEL User", content=msg['content']+ )+ elif msg['role'] == 'assistant':+ message = BaseMessage.make_assistant_message(+ role_name="CAMEL Assistant", content=msg['content']+ )+ elif msg['role'] == 'system':+ message = BaseMessage.make_assistant_message(+ role_name="System", content=msg['content']+ )+ else:+ raise ValueError(f"Unrecognized role: {msg['role']}")++ if i == len(messages) - 1:+ break+ agent.record_message(message)++ response = agent.step(message)+ model_output = response.msgs[0].content+ agent.reset()+ return model_output+++def calculate_rouge_l_score(reference, hypothesis):+ r"""Calculate rouge l score between hypothesis and reference."""+ rouge = Rouge()+ scores = rouge.get_scores(hypothesis, reference)+ rouge_l_score = scores[0]['rouge-l']['f']+ return rouge_l_score+++def get_api_call(model_output):+ r"""Parse api call from model output."""+ api_call_pattern = r"\[(\w+)\((.*)\)\]"+ api_call_pattern = re.compile(api_call_pattern)+ match = api_call_pattern.search(model_output)+ if match:+ return match.group(0)+ else:+ return None+++class APIBankSample:+ r"""APIBank sample used to load the datasets."""++ def __init__(self, chat_history, apis, ground_truth):+ self.chat_history = chat_history+ self.apis = apis+ self.ground_truth = ground_truth++ def __repr__(self):+ return 'Sample(chat_history={}, apis={}, ground_truth={})'.format(+ self.chat_history, self.apis, self.ground_truth+ )++ @classmethod+ def from_chat_history(cls, chat_history):+ apis = set()+ api_positions = []+ for i, item in enumerate(chat_history):+ if item['role'] == 'API':+ apis.add(item['api_name'])+ api_positions.append(i)++ samples = []+ for i in api_positions:+ sample = cls(chat_history[:i], apis, chat_history[i])+ samples.append(sample)+ sample = cls(chat_history[: i + 1], apis, chat_history[i + 1])+ samples.append(sample)++ return samples+++class Evaluator:+ r"""Evaluator for APIBank benchmark."""++ def __init__(self, samples: List[APIBankSample]):+ # Place holder for import as the import+ # only works after the files have been downloaded+ try:+ from api_bank.tool_manager import ToolManager # type: ignore[import-not-found]+ except Exception as e:+ logger.info(f"{e}, Module will be imported after download.")+ self.dataset = samples+ self.sample_ids = list(range(len(self.dataset)))+ os.chdir("api_bank")+ self.tool_manager = ToolManager("apis")+ os.chdir("..")++ def get_all_sample_ids(self):+ return self.sample_ids++ def get_api_description(self, api_name):+ return self.tool_manager.get_api_description(api_name)++ def get_model_input(self, sample_id: int):+ sample = self.dataset[sample_id]+ apis = sample.apis+ chat_history = sample.chat_history+ api_descriptions = []+ for api_name in apis:+ api_descriptions.append(+ self.tool_manager.get_api_description(api_name)+ )+ api_description = '\n'.join(api_descriptions)+ return api_description, chat_history++ def evaluate(self, sample_id, model_output):+ try:+ from api_bank.api_call_extraction import parse_api_call # type: ignore[import-not-found]+ except Exception as e:+ logger.info(f"{e}, Module will be imported after download.")+ sample = self.dataset[sample_id]+ ground_truth = sample.ground_truth+ if ground_truth['role'] == 'API':+ api_name, param_dict = parse_api_call(model_output)+ if api_name != ground_truth['api_name']:+ return False, 'API Name Mismatch: {} vs {}'.format(+ api_name, ground_truth['api_name']+ )+ try:+ result = self.tool_manager.api_call(api_name, **param_dict)+ except Exception as e:+ return False, str(e)+ api = self.tool_manager.init_tool(api_name)+ try:+ correct = api.check_api_call_correctness(+ result, ground_truth['result']+ )+ except KeyError:+ correct = False+ result = 'KeyError' + str(result)+ return correct, result+ elif ground_truth['role'] == 'AI':+ score = calculate_rouge_l_score(ground_truth['text'], model_output)+ return round(score, 4)+++API_CALL_PROMPT = '''+Based on the given API description and the existing \+conversation history 1..t, please generate the API request \+that the AI should call in step t+1 and output it in the \+format of [ApiName(key1='value1', key2='value2', ...)], \+replace the ApiName with the actual API name, and \+replace the key and value with the actual parameters. \+Your output should start with a square bracket "[" \+and end with a square bracket "]". Do not output any \+other explanation or prompt or the result of the API call in your output.+This year is 2023.+Input:+User: [User's utterence]+AI: [AI's utterence]++Expected output:+[ApiName(key1='value1', key2='value2', ...)]++API descriptions:+'''++RESPONSE_PROMPT = '''+Based on the given API description and the existing \+conversation history 1..t, please generate the next \+dialog that the AI should response after the API call t.+This year is 2023.+Input:+User: [User's utterence]+AI: [AI's utterence]+[ApiName(key1='value1', key2='value2', …)]++Expected output:+AI: [AI's utterence]++API descriptions:+'''diff --git a/camel/benchmarks/apibench.py b/camel/benchmarks/apibench.pynew file mode 100644index 000000000..e71411733--- /dev/null+++ b/camel/benchmarks/apibench.py@@ -0,0 +1,495 @@+# ========= 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 json+import logging+import random+from pathlib import Path+from typing import Any, Dict, Literal, Optional+from tqdm import tqdm+import tree_sitter_python as tspython+from tree_sitter import Language, Parser++from camel.agents import ChatAgent+from camel.benchmarks import BaseBenchmark+from camel.messages.base import BaseMessage+from camel.utils import download_github_subdirectory++logger = logging.getLogger(__name__)++dataset_mapping = {+ "huggingface": {+ "api": "huggingface_api.jsonl",+ "eval": "huggingface_eval.json",+ "train": "huggingface_train.json",+ "questions": "questions_huggingface_0_shot.jsonl",+ },+ "tensorflowhub": {+ "api": "tensorflowhub_api.jsonl",+ "eval": "tensorflow_eval.json",+ "train": "tensorflow_train.json",+ "questions": "questions_tensorflowhub_0_shot.jsonl",+ },+ "torchhub": {+ "api": "torchhub_api.jsonl",+ "eval": "torchhub_eval.json",+ "train": "torchhub_train.json",+ "questions": "questions_torchhub_0_shot.jsonl",+ },+}+++# This function is migrated from the original repo:+# https://github.com/ShishirPatil/gorilla+def encode_question(question: str, dataset_name: str) -> str:+ r"""Encode multiple prompt instructions into a single string."""++ if dataset_name == "torchhub":+ domains = "1. $DOMAIN is inferred from the task description and \+ should include one of {Classification, Semantic Segmentation, \+ Object Detection, Audio Separation, Video Classification, \+ Text-to-Speech}."+ elif dataset_name == "huggingface":+ domains = "1. $DOMAIN should include one of {Multimodal Feature \+ Extraction, Multimodal Text-to-Image, Multimodal \+ Image-to-Text, Multimodal Text-to-Video, \+ Multimodal Visual Question Answering, Multimodal Document \+ Question Answer, Multimodal Graph Machine Learning, \+ Computer Vision Depth Estimation, Computer Vision Image \+ Classification, Computer Vision Object Detection, \+ Computer Vision Image Segmentation, Computer Vision \+ Image-to-Image, Computer Vision Unconditional \+ Image Generation, Computer Vision Video Classification, \+ Computer Vision Zero-Shor Image Classification, \+ Natural Language Processing Text Classification, \+ Natural Language Processing Token Classification, \+ Natural Language Processing Table Question Answering, \+ Natural Language Processing Question Answering, \+ Natural Language Processing, Zero-Shot Classification \+ Natural Language Processing Translation, Natural Language \+ Processing Summarization, Natural Language Processing \+ Conversational, Natural Language Processing Text \+ Generation, Natural Language Processing Fill-Mask, \+ Natural Language Processing Text2Text Generation, \+ Natural Language Processing Sentence Similarity, \+ Audio Text-to-Speech, Audio Automatic Speech Recognition, \+ Audio Audio-to-Audio, Audio Audio Classification, \+ Audio Voice Activity Detection, Tabular Tabular \+ Classification, Tabular Tabular Regression, \+ Reinforcement Learning Reinforcement Learning, \+ Reinforcement Learning Robotics }"+ elif dataset_name == "tensorflowhub":+ domains = "1. $DOMAIN is inferred from the task description \+ and should include one of {text-sequence-alignment, \+ text-embedding, text-language-model, text-preprocessing, \+ text-classification, text-generation, text-question-answering, \+ text-retrieval-question-answering, text-segmentation, \+ text-to-mel, image-classification, image-feature-vector, \+ image-object-detection, image-segmentation, \+ image-generator, image-pose-detection, image-rnn-agent, \+ image-augmentation, image-classifier, image-style-transfer, \+ image-aesthetic-quality, image-depth-estimation, \+ image-super-resolution, image-deblurring, image-extrapolation, \+ image-text-recognition, image-dehazing, image-deraining, \+ image-enhancemenmt, image-classification-logits, \+ image-frame-interpolation, image-text-detection, image-denoising, \+ image-others, video-classification, video-feature-extraction, \+ video-generation, video-audio-text, video-text, \+ audio-embedding, audio-event-classification, audio-command-detection, \+ audio-paralinguists-classification, audio-speech-to-text, \+ audio-speech-synthesis, audio-synthesis, audio-pitch-extraction}"+ else:+ logger.info("Error: API name is not supported.")++ prompt = (+ question+ + "\nWrite a python program in 1 to 2 lines to call API in "+ + dataset_name+ + ".\n\nThe answer should follow the format: <<<domain>>> $DOMAIN, \+ <<<api_call>>>: $API_CALL, <<<api_provider>>>: $API_PROVIDER, \+ <<<explanation>>>: $EXPLANATION, <<<code>>>: $CODE}. \+ Here are the requirements:\n"+ + domains+ + "\n2. The $API_CALL should have only 1 line of code \+ that calls api.\n 3. The $API_PROVIDER should be the \+ programming framework used.\n4. $EXPLANATION should be \+ a step-by-step explanation.\n5. The $CODE is the python code.\n6. \+ Do not repeat the format in your answer."+ )+ return prompt+++class APIBenchBenchmark(BaseBenchmark):+ r"""APIBench Benchmark adopted from `Gorilla: Large Language Model+ Connected with Massive APIs`+ <https://huggingface.co/datasets/gorilla-llm/APIBench>.++ Args:+ data_dir (str): The directory to save the data.+ save_to (str): The file to save the results.+ processes (int, optional): The number of processes to use.+ (default: :obj:`1`)+ """++ # TODO: Integrate retriever (pending)++ def __init__(+ self,+ data_dir: str,+ save_to: str,+ processes: int = 1,+ ):+ r"""Initialize the APIBench benchmark.++ Args:+ data_dir (str): The directory to save the data.+ save_to (str): The file to save the results.+ processes (int, optional): The number of processes to use for+ parallel processing. (default: :obj:`1`)+ """+ super().__init__("apibench", data_dir, save_to, processes)++ def download(self):+ r"""Download the APIBench dataset."""+ from huggingface_hub import snapshot_download++ snapshot_download(+ repo_id="gorilla-llm/APIBench",+ repo_type="dataset",+ local_dir=self.data_dir,+ local_dir_use_symlinks=True,+ )++ repo = "ShishirPatil/gorilla"+ subdir = "eval/eval-data/questions"+ data_dir = self.data_dir++ download_github_subdirectory(repo, subdir, data_dir)++ def load(self, dataset_name: str, force_download: bool = False): # type: ignore[override]+ r"""Load the APIBench Benchmark dataset.++ Args:+ dataset_name (str): Name of the specific dataset to be loaded.+ force_download (bool, optional): Whether to force+ download the data. (default: :obj:`False`)+ """++ if force_download:+ logger.info("Force downloading data.")+ self.download()++ def load_json_lines(file_path: Path):+ r"""Helper function to load JSON lines from a file."""+ try:+ with open(file_path, "r") as f:+ return [json.loads(line) for line in f]+ except FileNotFoundError:+ raise FileNotFoundError(f"File not found: {file_path}")+ except json.JSONDecodeError as e:+ raise ValueError(+ f"Error decoding JSON in file {file_path}: {e}"+ )++ dataset_path = self.data_dir / dataset_name+ if not dataset_path.exists():+ raise FileNotFoundError(+ f"Dataset directory does not exist: {dataset_path}"+ )++ for label in ['api', 'eval', 'questions']:+ file_name = dataset_mapping[dataset_name][label]+ file_path = (+ dataset_path / file_name+ if label == 'questions'+ else self.data_dir / file_name+ )++ # Load data based on label type+ if label in ['api', 'questions', 'eval']:+ data = load_json_lines(file_path)++ if label == 'eval':+ # Extract 'api_data' specifically for eval label+ data = [item['api_data'] for item in data]++ self._data[label] = data+ else:+ raise ValueError(f"Unknown label: {label}")++ ast_database = []+ for data in self._data['api']:+ ast_tree = ast_parse(data['api_call'])+ ast_database.append(ast_tree)+ self._data['ast'] = ast_database++ def run( # type: ignore[override]+ self,+ agent: ChatAgent,+ dataset_name: Literal["huggingface", "tensorflowhub", "torchhub"],+ randomize: bool = False,+ subset: Optional[int] = None,+ ) -> Dict[str, Any]:+ r"""Run the benchmark.++ Args:+ agent (ChatAgent): The agent to run the+ benchmark.+ dataset_name (Literal["huggingface",+ "tensorflowhub", "torchhub"]):+ The dataset to run the benchmark.+ randomize (bool, optional): Whether to randomize the data.+ (default: :obj:`False`)+ subset (Optional[int], optional): The subset of data to run.+ (default: :obj:`None`)+ """++ if dataset_name not in dataset_mapping:+ raise ValueError(f"Invalid value for dataset: {dataset_name}.")++ logger.info(f"Running APIBench benchmark on {dataset_name}.")+ self.load(dataset_name)+ datas = self._data['questions']++ # Shuffle and subset data if necessary+ if randomize:+ random.shuffle(datas)+ if subset:+ datas = datas[:subset]++ logger.info(f"Number of tasks: {len(datas)}")++ # Initialize results storage+ self._results = []++ with open(self.save_to, "w") as f:+ for question in tqdm(datas, desc="Running"):+ prompt = encode_question(question["text"], dataset_name)+ msg = BaseMessage.make_user_message(+ role_name="User", content=prompt+ )+ try:+ # Generate response+ responses = agent.step(msg)+ response = responses.msgs[0].content+ api_database = self._data['api']+ qa_pairs = self._data['eval']+ ast_database = self._data['ast']+ question_id = question['question_id']++ # Evaluate response+ error, correct, hallucination = evaluate_response(+ response,+ question_id,+ dataset_name,+ api_database,+ qa_pairs,+ ast_database,+ )+ self._results.append(+ {+ "question": question,+ "agent_response": response,+ "correct": correct,+ "hallucination": hallucination,+ "error": str(error) if error else None,+ }+ )+ except Exception as e:+ logger.warning(+ f"Error in processing task: {question}: {e}"+ )+ self._results.append(+ {+ "question": question,+ "agent_response": None,+ "correct": False,+ "hallucination": False,+ "error": str(e),+ }+ )++ agent.reset()++ f.write(json.dumps(self._results[-1], indent=2) + "\n")+ f.flush()++ total = len(self._results)+ correct = sum(r["correct"] for r in self.results)+ hallucination = sum(r["hallucination"] for r in self.results)++ return {+ "total": total,+ "correct": correct,+ "hallucination": hallucination,+ "accuracy": correct / total if total else "N/A",+ "hallucination rate": hallucination / total if total else "N/A",+ }+++# This code is modified from the+# evaluators in the original repo+# https://github.com/ShishirPatil/gorilla+# Get all the subtrees given a root_node+def get_all_sub_trees(root_node):+ node_stack = []+ sub_tree_sexp_list = []+ depth = 1+ # text = root_node.text+ node_stack.append([root_node, depth])+ while len(node_stack) != 0:+ cur_node, cur_depth = node_stack.pop()+ if cur_node.child_count > 0:+ sub_tree_sexp_list.append(+ [+ str(cur_node),+ cur_depth,+ cur_node,+ cur_node.children[0].text,+ ]+ )+ else:+ sub_tree_sexp_list.append(+ [str(cur_node), cur_depth, cur_node, None]+ )+ for child_node in cur_node.children:+ if len(child_node.children) != 0:+ depth = cur_depth + 1+ node_stack.append([child_node, depth])+ return sub_tree_sexp_list+++# Parse the program into AST trees+def ast_parse(candidate):+ PY_LANGUAGE = Language(tspython.language())+ parser = Parser(PY_LANGUAGE)++ candidate_tree = parser.parse(bytes(candidate, "utf8")).root_node+ return candidate_tree+++# Get all the arguments in the ast tree+def get_args(node, dataset_name):+ if node.child_count == 0:+ return []+ args_list = []+ if dataset_name == "huggingface":+ for child in node.children[0].children[0].children[1].children:+ if "=" in child.text.decode():+ args_list.append(child.children[2].text)+ elif (+ child.text.decode() != "("+ and child.text.decode() != ")"+ and child.text.decode() != ","+ ):+ args_list.append(child.text)+ elif dataset_name == "tensorflowhub":+ for child in node.children[0].children[0].children[1].children:+ if (+ 'model=' in child.text.decode()+ or 'model =' in child.text.decode()+ ):+ args_list.append(child.children[2].text)+ elif (+ child.text.decode() != "("+ and child.text.decode() != ")"+ and child.text.decode() != ","+ ):+ args_list.append(child.text)+ elif dataset_name == "torchhub":+ for child in node.children[0].children[0].children[1].children:+ if (+ "repo_or_dir" in child.text.decode()+ or "model" in child.text.decode()+ ):+ args_list.append(child.children[2].text)+ return args_list+++# Check if there is an api match+def ast_check(candidate_subtree_list, base_tree_list, dataset_name):+ for idx, base_tree in enumerate(base_tree_list):+ if base_tree.children[0].children[0].child_count == 0:+ continue+ api_name = base_tree.children[0].children[0].children[0].text+ for candidate_tree in candidate_subtree_list:+ if candidate_tree[3] == api_name:+ break+ # Now we have a sub-tree+ candidate_tree = candidate_tree[2]+ args_list = get_args(base_tree, dataset_name)+ if len(args_list) == 0:+ continue+ ast_match = True+ for arg in args_list:+ if (+ arg.decode().lstrip("'").rstrip("'")+ not in candidate_tree.text.decode()+ ):+ ast_match = False+ break+ if ast_match:+ return idx+ return -1+++def evaluate_response(+ response, question_id, dataset_name, api_database, qa_pairs, ast_database+):+ try:+ # Index the "api_call" domain+ output = response.split("api_call")+ if len(output) == 1:+ api_call = output[0]+ else:+ # Parse the output+ output = output[1].split("api_provider")[0]+ if ":" not in output:+ start = 0+ else:+ start = output.index(":")+ if ")" not in output:+ end = -2+ else:+ end = output.rindex(")")+ api_call = output[start + 2 : end + 1]++ try:+ ast_tree = ast_parse(api_call)+ except Exception as parse_error:+ print(f"Error parsing api_call: {api_call}, error: {parse_error}")+ return parse_error, False, False+ # Search for a subtree+ ast_subtree_list = get_all_sub_trees(ast_tree)+ # Check which ast tree is matching+ database_index = ast_check(+ ast_subtree_list, ast_database, dataset_name+ )+ # We cannot index this ast in our database+ if database_index == -1:+ halluncination = True+ correct = False+ # We index our reference api_call+ ref_api_call = api_database[database_index]+ # Check for functionality+ if ref_api_call['domain'] == qa_pairs[question_id - 1]['domain']:+ correct = True+ halluncination = False+ else:+ return None, False, False+ except Exception as e:+ print(f'Error parsing response: {response}, error: {e}')+ return e, False, False++ return None, correct, halluncinationdiff --git a/camel/benchmarks/nexus.py b/camel/benchmarks/nexus.pynew file mode 100644index 000000000..20ab7e6aa--- /dev/null+++ b/camel/benchmarks/nexus.py@@ -0,0 +1,518 @@+# ========= 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 ast+import json+import logging+import os+import random+import textwrap+from dataclasses import dataclass+from pathlib import Path+from typing import Any, Dict, List, Literal, Optional, Tuple, Union++import pandas as pd+from datasets import load_dataset+from tqdm import tqdm++from camel.agents import ChatAgent+from camel.benchmarks import BaseBenchmark+from camel.messages.base import BaseMessage++logger = logging.getLogger(__name__)+++# Define the data class+@dataclass+class NexusSample:+ r"""Nexus benchmark dataset sample."""++ input: str+ output: str+++@dataclass+class NexusTool:+ r"""Nexus benchmark tool"""++ function_calls: str+ descriptions: str+++dataset_mapping = {+ "NVDLibrary": "Nexusflow/NVDLibraryBenchmark",+ "VirusTotal": "Nexusflow/VirusTotalBenchmark",+ "PlacesAPI": "Nexusflow/PlacesAPIBenchmark",+ "ClimateAPI": "Nexusflow/ClimateAPIBenchmark",+ "OTX": "Nexusflow/OTXAPIBenchmark",+ "VirusTotal-NestedCalls": "Nexusflow/vt_multiapi",+ "VirusTotal-ParallelCalls": "Nexusflow/vt_multiapi",+ "NVDLibrary-NestedCalls": "Nexusflow/CVECPEAPIBenchmark",+}++TOOL_CALLING_PROMPT = """+You are given multiple functions and a user query.++Please proceed with generating a function call for the function \+with the proper arguments that best answers the given prompt.++Respond with nothing but the function call ONLY, such that I can \+directly execute your function call without any post processing \+necessary from my end. Do not use variables.+If there are more than two function calls, separate them with a semicolon (;).++{tools}++Question: {input}+"""+++class NexusBenchmark(BaseBenchmark):+ r"""Nexus Function Calling Benchmark adapted from `NexusRaven V2+ Function Calling Benchmark`+ <https://huggingface.co/collections/Nexusflow/nexusraven-v2-function-calling-benchmark-657a597fb84dbe7a09ebfc3e>.++ Args:+ data_dir (str): The directory to save the data.+ save_to (str): The file to save the results.+ processes (int, optional): The number of processes to use.+ (default: :obj:`1`)+ """++ def __init__(+ self,+ data_dir: str,+ save_to: str,+ processes: int = 1,+ ):+ r"""Initialize the Nexus Function Calling benchmark.++ Args:+ data_dir (str): The directory to save the data.+ save_to (str): The file to save the results.+ processes (int, optional): The number of processes to use for+ parallel processing. (default: :obj:`1`)+ """+ super().__init__("nexus", data_dir, save_to, processes)+ self._data: List[NexusSample] = [] # type: ignore[assignment]++ def download(self):+ r"""Download the Nexus Functional Calling Benchmark dataset."""+ from huggingface_hub import snapshot_download++ for dataset_name, repo_id in dataset_mapping.items():+ local_dir = self.data_dir / dataset_name+ snapshot_download(+ repo_id=repo_id,+ repo_type="dataset",+ local_dir=local_dir,+ local_dir_use_symlinks=True,+ )++ def load(self, dataset_name: str, force_download: bool = False): # type: ignore[override]+ r"""Load the Nexus Benchmark dataset.++ Args:+ dataset_name (str): Name of the specific dataset to be loaded.+ force_download (bool): Whether to force download the data.+ """++ def _load_csv_data(dataset_dir: Path) -> List:+ r"""Load datasets from CSV files."""+ dataset = []+ for file_name in os.listdir(dataset_dir):+ file_path = dataset_dir / file_name+ if file_name.endswith(".csv"):+ data = pd.read_csv(file_path)+ for _, sample in data.iterrows():+ dataset.append(+ NexusSample(+ sample["Input"], "".join(sample["Output"])+ )+ )+ continue++ logger.warning(f"Skipping unsupported file: {file_name}")+ return dataset++ def _load_parquet_data(data_dir: Path, dataset_name: str) -> List:+ r"""Load datasets from Parquet files."""+ dataset = []+ if not data_dir.exists():+ raise FileNotFoundError(+ f"Data directory '{data_dir}' does not exist."+ )++ for file_name in os.listdir(data_dir):+ file_path = data_dir / file_name+ if file_name.endswith(".parquet"):+ data = pd.read_parquet(file_path)+ dataset.extend(_process_parquet_data(data, dataset_name))+ continue++ logger.warning(f"Skipping unsupported file: {file_name}")++ return dataset++ def _process_parquet_data(+ data: pd.DataFrame, dataset_name: str+ ) -> List:+ r"""Process data from Parquet files based on dataset name."""+ dataset: List = []+ dataset_handlers = {+ "NVDLibrary": _process_nvdlibrary,+ "VirusTotal": _process_simple,+ "PlacesAPI": _process_simple,+ "ClimateAPI": _process_simple,+ "OTX": _process_simple,+ "VirusTotal-NestedCalls": _process_nested_calls,+ "VirusTotal-ParallelCalls": _process_parallel_calls,+ }++ if dataset_name not in dataset_handlers:+ logger.warning(+ f"No specific handler for dataset: {dataset_name}"+ )+ return dataset++ handler = dataset_handlers[dataset_name]+ for _, sample in data.iterrows():+ processed_sample = handler(sample)+ if processed_sample:+ dataset.append(processed_sample)+ return dataset++ def _process_nvdlibrary(sample) -> NexusSample:+ r"""Process samples for the NVDLibrary dataset."""+ return NexusSample(+ sample["Input"], sample["Output"].replace("r = nvdlib.", "")+ )++ def _process_simple(sample) -> NexusSample:+ r"""Process samples for simple datasets (e.g., VirusTotal)."""+ return NexusSample(sample["Input"], sample["Output"])++ def _process_nested_calls(sample) -> Union[NexusSample, None]:+ r"""Process samples for VirusTotal-NestedCalls dataset."""+ if len(sample["fncall"]) == 1:+ return NexusSample(+ sample["generated_question"], "".join(sample["fncall"])+ )+ return None++ def _process_parallel_calls(sample) -> Union[NexusSample, None]:+ r"""Process samples for VirusTotal-ParallelCalls dataset."""+ if len(sample["fncall"]) > 1:+ return NexusSample(+ sample["generated_question"], "; ".join(sample["fncall"])+ )+ return None++ if force_download:+ logger.info("Force downloading data.")+ self.download()++ # Validate dataset name+ if dataset_name not in dataset_mapping:+ available_datasets = list(dataset_mapping.keys())+ raise ValueError(+ f"Dataset '{dataset_name}' is not recognized. "+ f"Available datasets: {available_datasets}"+ )++ # Get the dataset directory+ dataset_dir = self.data_dir / dataset_name+ if not dataset_dir.exists():+ raise FileNotFoundError(+ f"The dataset directory for '{dataset_name}' \+ does not exist at {dataset_dir}. "+ "Please download it first."+ )++ # Load the dataset+ if dataset_name == "NVDLibrary-NestedCalls":+ self._data = _load_csv_data(dataset_dir)+ else:+ self._data = _load_parquet_data(dataset_dir / "data", dataset_name)++ @property+ def train(self):+ r"""Get the training set."""+ raise NotImplementedError(+ "Nexus Functional Calling has only a single 'train' set."+ )++ def run( # type: ignore[override, return]+ self,+ agent: ChatAgent,+ task: Literal[+ "NVDLibrary",+ "VirusTotal",+ "OTX",+ "PlacesAPI",+ "ClimateAPI",+ "VirusTotal-ParallelCalls",+ "VirusTotal-NestedCalls",+ "NVDLibrary-NestedCalls",+ ],+ randomize: bool = False,+ subset: Optional[int] = None,+ ) -> Dict[str, Any]:+ r"""Run the benchmark.++ Args:+ agent (ChatAgent): The agent to run the benchmark.+ task (Literal["NVDLibrary", "VirusTotal", "OTX",+ "PlacesAPI", "ClimateAPI", "VirusTotal-ParallelCalls",+ "VirusTotal-NestedCalls",+ "NVDLibrary-NestedCalls"]): The task to run the benchmark.+ randomize (bool, optional): Whether to randomize the data.+ (default: :obj:`False`)+ subset (Optional[int], optional): The subset of data to run.+ (default: :obj:`None`)++ Returns:+ Dict[str, Any]: The results of the benchmark.+ """++ if task not in dataset_mapping:+ raise ValueError(f"Invalid value for dataset: {task}.")++ logger.info(f"Running Nexus Function Calling benchmark on {task}.")+ self.load(task)+ datas = self._data++ # Shuffle and subset data if necessary+ if randomize:+ random.shuffle(datas)+ if subset:+ datas = datas[:subset]++ logger.info(f"Number of tasks: {len(datas)}")++ # Initialize results storage+ self._results = []++ # Process samples+ tools = construct_tool_descriptions(task)+ with open(self.save_to, "w") as f:+ for sample in tqdm(datas, desc="Running"):+ prompt = construct_prompt(input=sample.input, tools=tools)+ msg = BaseMessage.make_user_message(+ role_name="User", content=prompt+ )+ ground_truth_call = sample.output+ try:+ # Generate response+ response = agent.step(msg)+ agent_call = response.msgs[0].content++ # Evaluate response+ if agent_call:+ result = compare_function_calls(+ agent_call=agent_call,+ ground_truth_call=ground_truth_call,+ )+ self._results.append(+ {+ "input": sample.input,+ "agent_call": agent_call,+ "ground_truth_call": ground_truth_call,+ "result": result,+ "error": None,+ }+ )+ except Exception as e:+ logger.warning(f"Error in processing task: {sample.input}")+ self._results.append(+ {+ "input": sample.input,+ "agent_call": None,+ "ground_truth_call": ground_truth_call,+ "result": 0,+ "error": str(e),+ }+ )++ agent.reset()++ f.write(json.dumps(self._results[-1], indent=2) + "\n")+ f.flush()++ total = len(self._results)+ correct = sum(r["result"] for r in self._results)++ return {+ "total": total,+ "correct": correct,+ "accuracy": correct / total,+ }+++# Utility functions+def construct_tool_descriptions(dataset_name: str) -> str:+ r"""Construct tool descriptions from function definitions and+ descriptions."""+ tool_dataset_mapping = {+ "NVDLibrary": "CVECPE",+ "VirusTotal": "VirusTotal",+ "PlacesAPI": "Places",+ "ClimateAPI": "Climate",+ "OTX": "OTX",+ "VirusTotal-NestedCalls": "VT_Multi (Nested)",+ "VirusTotal-ParallelCalls": "VT_Multi (Parallel)",+ "NVDLibrary-NestedCalls": "CVECPE_Multi (Nested)",+ }++ if dataset_name not in tool_dataset_mapping:+ raise ValueError(+ f"Dataset '{dataset_name}' is not recognized. "+ f"Available datasets: {list(dataset_mapping.keys())}"+ )++ # Load the dataset based on the dataset name+ dataset = load_dataset(+ "Nexusflow/Function_Call_Definitions",+ name=tool_dataset_mapping[dataset_name],+ )["train"]++ # Construct tool descriptions+ tools = [+ NexusTool(tool["function_calls"], tool["descriptions"])+ for tool in dataset+ ]++ # Generate the tool prompt+ tool_prompt = "".join(+ f"Function:\ndef {tool.function_calls}:\n"+ + "\"\"\"\n"+ + f"{tool.descriptions}\n"+ + "\"\"\"\n"+ for tool in tools+ )++ return tool_prompt+++def construct_prompt(input: str, tools: str) -> str:+ r"Construct prompt from tools and input."+ return TOOL_CALLING_PROMPT.format(tools=tools, input=input)+++# Functions for function call evaluation+def parse_function_call(+ call: str,+) -> Tuple[Optional[str], Optional[List[Any]], Optional[Dict[str, Any]]]:+ r"""Parse a function call string to extract the function name,+ positional arguments, and keyword arguments, including+ nested function calls.++ Args:+ call (str): A string in the format `func(arg1, arg2, kwarg=value)`.++ Returns:+ tuple: (function_name (str), positional_args (list),+ keyword_args (dict)) or (None, None, None).+ """++ def preprocess_input(call: str) -> str:+ r"""Remove formatting like code blocks and whitespace."""+ if call.strip().startswith("```python"):+ call = call.strip().removeprefix("```python").removesuffix("```")+ return textwrap.dedent(call).strip()++ def evaluate_arg(arg):+ r"""Recursively evaluate arguments, including nested calls."""+ if isinstance(arg, ast.Call):+ # Recursively parse nested calls+ func_name, args, kwargs = parse_function_call(ast.unparse(arg))+ return func_name, args, kwargs+ elif isinstance(+ arg, ast.Constant+ ): # Handle literals like numbers, strings, etc.+ return arg.value+ elif isinstance(arg, ast.List): # Handle list literals+ return [evaluate_arg(el) for el in arg.elts]+ elif isinstance(arg, ast.Dict): # Handle dictionary literals+ return {+ evaluate_arg(k): evaluate_arg(v)+ for k, v in zip(arg.keys, arg.values)+ }+ elif isinstance(arg, ast.Tuple): # Handle tuple literals+ return tuple(evaluate_arg(el) for el in arg.elts)+ else:+ return ast.literal_eval(arg) # Safely evaluate other types++ call = preprocess_input(call)+ parsed_calls = []++ try:+ # Parse the string into an AST+ parsed_calls = call.split(";")+ for single_call in parsed_calls:+ tree = ast.parse(single_call, mode='eval')++ # Ensure it's a function call+ if isinstance(tree.body, ast.Call):+ # Extract function name+ if isinstance(+ tree.body.func, ast.Name+ ): # Simple function call+ func_name = tree.body.func.id+ elif isinstance(+ tree.body.func, ast.Attribute+ ): # Attribute function call+ func_name = (+ f"{tree.body.func.value.id}.{tree.body.func.attr}" # type: ignore[attr-defined]+ )+ else:+ raise ValueError(f"Unsupported function call: {call}")++ # Extract positional arguments+ args = [evaluate_arg(arg) for arg in tree.body.args]++ # Extract keyword arguments+ kwargs: Dict[str, Any] = {+ kw.arg: evaluate_arg(kw.value)+ for kw in tree.body.keywords+ if kw.arg is not None+ }+ logger.info("Valid call.")+ return func_name, args, kwargs+ else:+ raise ValueError(f"Not a valid function call: {call}")+ except Exception as e:+ logger.info(f"Error parsing call: {call}, {e}")+ return None, None, None+++def compare_function_calls(agent_call: str, ground_truth_call: str) -> bool:+ r"""Compare the function name and arguments of+ agent_call and ground_truth_call.+ Args:+ agent_call (str): Function call by agent.+ ground_truth_call (str): Ground truth function call.++ Returns:+ - `True` if the function names and arguments match.+ - `False` otherwise.+ """+ # Parse both calls+ agent_parsed = parse_function_call(agent_call)+ gt_parsed = parse_function_call(ground_truth_call)++ if agent_parsed and gt_parsed:+ return agent_parsed == gt_parsed+ else:+ return Falsediff --git a/camel/utils/__init__.py b/camel/utils/__init__.pyindex 3fd595667..2215d0d73 100644--- a/camel/utils/__init__.py+++ b/camel/utils/__init__.py@@ -19,6 +19,7 @@ from .commons import (check_server_running,create_chunks,dependencies_required,+ download_github_subdirectory,download_tasks,func_string_to_callable,generate_prompt_for_structured_output,@@ -79,5 +80,6 @@ __all__ = ["track_agent","handle_http_error","get_pydantic_model",+ "download_github_subdirectory","generate_prompt_for_structured_output",]diff --git a/camel/utils/commons.py b/camel/utils/commons.pyindex 211e33ebd..3dca5de90 100644--- a/camel/utils/commons.py+++ b/camel/utils/commons.py@@ -21,6 +21,7 @@ import timeimport zipfilefrom functools import wrapsfrom http import HTTPStatus+from pathlib import Pathfrom typing import (Any,Callable,@@ -609,6 +610,51 @@ def retry_request(raise+def download_github_subdirectory(+ repo: str, subdir: str, data_dir: Path, branch="main"+):+ r"""Download subdirectory of the Github repo of+ the benchmark.++ This function downloads all files and subdirectories from a+ specified subdirectory of a GitHub repository and+ saves them to a local directory.++ Args:+ repo (str): The name of the GitHub repository+ in the format "owner/repo".+ subdir (str): The path to the subdirectory+ within the repository to download.+ data_dir (Path): The local directory where+ the files will be saved.+ branch (str, optional): The branch of the repository to use.+ Defaults to "main".+ """+ from tqdm import tqdm++ api_url = (+ f"https://api.github.com/repos/{repo}/contents/{subdir}?ref={branch}"+ )+ headers = {"Accept": "application/vnd.github.v3+json"}+ response = requests.get(api_url, headers=headers)+ response.raise_for_status()+ files = response.json()+ os.makedirs(data_dir, exist_ok=True)++ for file in tqdm(files, desc="Downloading"):+ file_path = data_dir / file["name"]++ if file["type"] == "file":+ file_url = file["download_url"]+ file_response = requests.get(file_url)+ with open(file_path, "wb") as f:+ f.write(file_response.content)+ elif file["type"] == "dir":+ download_github_subdirectory(+ repo, f'{subdir}/{file["name"]}', file_path, branch+ )++def generate_prompt_for_structured_output(response_format: Optional[Type[BaseModel]],user_message: str,diff --git a/examples/benchmarks/apibank.py b/examples/benchmarks/apibank.pynew file mode 100644index 000000000..036849c9a--- /dev/null+++ b/examples/benchmarks/apibank.py@@ -0,0 +1,25 @@+# ========= 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. =========++from camel.agents import ChatAgent+from camel.benchmarks import APIBankBenchmark++agent = ChatAgent()++benchmark = APIBankBenchmark(+ data_dir="./APIBankDatasets", save_to="./APIBankResults.jsonl"+)+benchmark.download()+results = benchmark.run(agent, "level-1", api_test_enabled=True)+print(results)diff --git a/examples/benchmarks/apibench.py b/examples/benchmarks/apibench.pynew file mode 100644index 000000000..e4ded379d--- /dev/null+++ b/examples/benchmarks/apibench.py@@ -0,0 +1,24 @@+# ========= 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. =========++from camel.agents import ChatAgent+from camel.benchmarks import APIBenchBenchmark++agent = ChatAgent()++benchmark = APIBenchBenchmark(+ data_dir="./APIBenchDatasets", save_to="./APIBench.jsonl"+)+result = benchmark.run(agent, 'torchhub')+print(result)diff --git a/examples/benchmarks/nexus.py b/examples/benchmarks/nexus.pynew file mode 100644index 000000000..e0bdb47ce--- /dev/null+++ b/examples/benchmarks/nexus.py@@ -0,0 +1,25 @@+# ========= 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. =========++from camel.agents import ChatAgent+from camel.benchmarks import NexusBenchmark++agent = ChatAgent()++benchmark = NexusBenchmark(+ data_dir="./NexusDatasets", save_to="./NexusResults.jsonl"+)+benchmark.download()+results = benchmark.run(agent, "OTX")+print(results)diff --git a/poetry.lock b/poetry.lockindex 8eace9753..46c7dba84 100644--- a/poetry.lock+++ b/poetry.lock@@ -75,20 +75,20 @@ langchain = ["langchain (==0.2.14)"][[package]]name = "aiofiles"-version = "24.1.0"+version = "23.2.1"description = "File support for asyncio."optional = false-python-versions = ">=3.8"+python-versions = ">=3.7"files = [- {file = "aiofiles-24.1.0-py3-none-any.whl", hash = "sha256:b4ec55f4195e3eb5d7abd1bf7e061763e864dd4954231fb8539a0ef8bb8260e5"},- {file = "aiofiles-24.1.0.tar.gz", hash = "sha256:22a075c9e5a3810f0c2e48f3008c94d68c65d763b9b03857924c99e57355166c"},+ {file = "aiofiles-23.2.1-py3-none-any.whl", hash = "sha256:19297512c647d4b27a2cf7c34caa7e405c0d60b5560618a29a9fe027b18b0107"},+ {file = "aiofiles-23.2.1.tar.gz", hash = "sha256:84ec2218d8419404abcb9f0c02df3f34c6e0a68ed41072acfb1cef5cbc29051a"},][[package]]name = "aiohappyeyeballs"version = "2.4.4"description = "Happy Eyeballs for asyncio"-optional = false+optional = truepython-versions = ">=3.8"files = [{file = "aiohappyeyeballs-2.4.4-py3-none-any.whl", hash = "sha256:a980909d50efcd44795c4afeca523296716d50cd756ddca6af8c65b996e27de8"},@@ -99,7 +99,7 @@ files = [name = "aiohttp"version = "3.11.11"description = "Async http client/server framework (asyncio)"-optional = false+optional = truepython-versions = ">=3.9"files = [{file = "aiohttp-3.11.11-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a60804bff28662cbcf340a4d61598891f12eea3a66af48ecfdc975ceec21e3c8"},@@ -197,7 +197,7 @@ speedups = ["Brotli", "aiodns (>=3.2.0)", "brotlicffi"]name = "aiosignal"version = "1.3.2"description = "aiosignal: a list of registered asynchronous callbacks"-optional = false+optional = truepython-versions = ">=3.9"files = [{file = "aiosignal-1.3.2-py2.py3-none-any.whl", hash = "sha256:45cde58e409a301715980c2b01d0c28bdde3770d8290b5eb2173759d9acb31a5"},@@ -465,7 +465,7 @@ test = ["astroid (>=2,<4)", "pytest", "pytest-cov", "pytest-xdist"]name = "async-timeout"version = "5.0.1"description = "Timeout context manager for asyncio programs"-optional = false+optional = truepython-versions = ">=3.8"files = [{file = "async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c"},@@ -1310,45 +1310,45 @@ six = "*"[[package]]name = "datasets"-version = "2.14.4"+version = "3.2.0"description = "HuggingFace community-driven open-source library of datasets"optional = true-python-versions = ">=3.8.0"+python-versions = ">=3.9.0"files = [- {file = "datasets-2.14.4-py3-none-any.whl", hash = "sha256:29336bd316a7d827ccd4da2236596279b20ca2ac78f64c04c9483da7cbc2459b"},- {file = "datasets-2.14.4.tar.gz", hash = "sha256:ef29c2b5841de488cd343cfc26ab979bff77efa4d2285af51f1ad7db5c46a83b"},+ {file = "datasets-3.2.0-py3-none-any.whl", hash = "sha256:f3d2ba2698b7284a4518019658596a6a8bc79f31e51516524249d6c59cf0fe2a"},+ {file = "datasets-3.2.0.tar.gz", hash = "sha256:9a6e1a356052866b5dbdd9c9eedb000bf3fc43d986e3584d9b028f4976937229"},][package.dependencies]aiohttp = "*"-dill = ">=0.3.0,<0.3.8"-fsspec = {version = ">=2021.11.1", extras = ["http"]}-huggingface-hub = ">=0.14.0,<1.0.0"-multiprocess = "*"+dill = ">=0.3.0,<0.3.9"+filelock = "*"+fsspec = {version = ">=2023.1.0,<=2024.9.0", extras = ["http"]}+huggingface-hub = ">=0.23.0"+multiprocess = "<0.70.17"numpy = ">=1.17"packaging = "*"pandas = "*"-pyarrow = ">=8.0.0"+pyarrow = ">=15.0.0"pyyaml = ">=5.1"-requests = ">=2.19.0"-tqdm = ">=4.62.1"+requests = ">=2.32.2"+tqdm = ">=4.66.3"xxhash = "*"[package.extras]-apache-beam = ["apache-beam (>=2.26.0,<2.44.0)"]-audio = ["librosa", "soundfile (>=0.12.1)"]+audio = ["librosa", "soundfile (>=0.12.1)", "soxr (>=0.4.0)"]benchmarks = ["tensorflow (==2.12.0)", "torch (==2.0.1)", "transformers (==4.30.1)"]-dev = ["Pillow (>=6.2.1)", "absl-py", "apache-beam (>=2.26.0,<2.44.0)", "black (>=23.1,<24.0)", "elasticsearch (<8.0.0)", "faiss-cpu (>=1.6.4)", "joblib (<1.3.0)", "joblibspark", "librosa", "lz4", "py7zr", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "pyyaml (>=5.3.1)", "rarfile (>=4.0)", "ruff (>=0.0.241)", "s3fs", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "sqlalchemy (<2.0.0)", "tensorflow (>=2.2.0,!=2.6.0,!=2.6.1)", "tensorflow (>=2.3,!=2.6.0,!=2.6.1)", "tensorflow-macos", "tiktoken", "torch", "transformers", "zstandard"]-docs = ["s3fs", "tensorflow (>=2.2.0,!=2.6.0,!=2.6.1)", "tensorflow-macos", "torch", "transformers"]-jax = ["jax (>=0.2.8,!=0.3.2,<=0.3.25)", "jaxlib (>=0.1.65,<=0.3.25)"]-metrics-tests = ["Werkzeug (>=1.0.1)", "accelerate", "bert-score (>=0.3.6)", "jiwer", "langdetect", "mauve-text", "nltk", "requests-file (>=1.5.1)", "rouge-score", "sacrebleu", "sacremoses", "scikit-learn", "scipy", "sentencepiece", "seqeval", "six (>=1.15.0,<1.16.0)", "spacy (>=3.0.0)", "texttable (>=1.6.3)", "tldextract", "tldextract (>=3.1.0)", "toml (>=0.10.1)", "typer (<0.5.0)"]-quality = ["black (>=23.1,<24.0)", "pyyaml (>=5.3.1)", "ruff (>=0.0.241)"]+dev = ["Pillow (>=9.4.0)", "absl-py", "decorator", "decord (==0.6.0)", "elasticsearch (>=7.17.12,<8.0.0)", "faiss-cpu (>=1.8.0.post1)", "jax (>=0.3.14)", "jaxlib (>=0.3.14)", "joblib (<1.3.0)", "joblibspark", "librosa", "lz4", "moto[server]", "polars[timezone] (>=0.20.0)", "protobuf (<4.0.0)", "py7zr", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "ruff (>=0.3.0)", "s3fs", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "soxr (>=0.4.0)", "sqlalchemy", "tensorflow (>=2.16.0)", "tensorflow (>=2.6.0)", "tensorflow (>=2.6.0)", "tiktoken", "torch", "torch (>=2.0.0)", "torchdata", "transformers", "transformers (>=4.42.0)", "zstandard"]+docs = ["s3fs", "tensorflow (>=2.6.0)", "torch", "transformers"]+jax = ["jax (>=0.3.14)", "jaxlib (>=0.3.14)"]+quality = ["ruff (>=0.3.0)"]s3 = ["s3fs"]-tensorflow = ["tensorflow (>=2.2.0,!=2.6.0,!=2.6.1)", "tensorflow-macos"]-tensorflow-gpu = ["tensorflow-gpu (>=2.2.0,!=2.6.0,!=2.6.1)"]-tests = ["Pillow (>=6.2.1)", "absl-py", "apache-beam (>=2.26.0,<2.44.0)", "elasticsearch (<8.0.0)", "faiss-cpu (>=1.6.4)", "joblib (<1.3.0)", "joblibspark", "librosa", "lz4", "py7zr", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "sqlalchemy (<2.0.0)", "tensorflow (>=2.3,!=2.6.0,!=2.6.1)", "tensorflow-macos", "tiktoken", "torch", "transformers", "zstandard"]+tensorflow = ["tensorflow (>=2.6.0)"]+tensorflow-gpu = ["tensorflow (>=2.6.0)"]+tests = ["Pillow (>=9.4.0)", "absl-py", "decorator", "decord (==0.6.0)", "elasticsearch (>=7.17.12,<8.0.0)", "faiss-cpu (>=1.8.0.post1)", "jax (>=0.3.14)", "jaxlib (>=0.3.14)", "joblib (<1.3.0)", "joblibspark", "librosa", "lz4", "moto[server]", "polars[timezone] (>=0.20.0)", "protobuf (<4.0.0)", "py7zr", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "soxr (>=0.4.0)", "sqlalchemy", "tensorflow (>=2.16.0)", "tensorflow (>=2.6.0)", "tiktoken", "torch (>=2.0.0)", "torchdata", "transformers (>=4.42.0)", "zstandard"]+tests-numpy2 = ["Pillow (>=9.4.0)", "absl-py", "decorator", "decord (==0.6.0)", "elasticsearch (>=7.17.12,<8.0.0)", "jax (>=0.3.14)", "jaxlib (>=0.3.14)", "joblib (<1.3.0)", "joblibspark", "lz4", "moto[server]", "polars[timezone] (>=0.20.0)", "protobuf (<4.0.0)", "py7zr", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "soxr (>=0.4.0)", "sqlalchemy", "tiktoken", "torch (>=2.0.0)", "torchdata", "transformers (>=4.42.0)", "zstandard"]torch = ["torch"]-vision = ["Pillow (>=6.2.1)"]+vision = ["Pillow (>=9.4.0)"][[package]]name = "debugpy"@@ -1456,17 +1456,18 @@ training = ["Jinja2", "accelerate (>=0.31.0)", "datasets", "peft (>=0.6.0)", "pr[[package]]name = "dill"-version = "0.3.7"+version = "0.3.8"description = "serialize all of Python"optional = true-python-versions = ">=3.7"+python-versions = ">=3.8"files = [- {file = "dill-0.3.7-py3-none-any.whl", hash = "sha256:76b122c08ef4ce2eedcd4d1abd8e641114bfc6c2867f49f3c41facf65bf19f5e"},- {file = "dill-0.3.7.tar.gz", hash = "sha256:cc1c8b182eb3013e24bd475ff2e9295af86c1a38eb1aff128dac8962a9ce3c03"},+ {file = "dill-0.3.8-py3-none-any.whl", hash = "sha256:c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7"},+ {file = "dill-0.3.8.tar.gz", hash = "sha256:3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca"},][package.extras]graph = ["objgraph (>=1.7.2)"]+profile = ["gprof2dot (>=2022.7.29)"][[package]]name = "discord-py"@@ -2026,7 +2027,7 @@ requests = "*"name = "frozenlist"version = "1.5.0"description = "A list-like structure which implements collections.abc.MutableSequence"-optional = false+optional = truepython-versions = ">=3.8"files = [{file = "frozenlist-1.5.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:5b6a66c18b5b9dd261ca98dffcb826a525334b2f29e7caa54e182255c5f6a65a"},@@ -2125,13 +2126,13 @@ files = [[[package]]name = "fsspec"-version = "2024.12.0"+version = "2024.9.0"description = "File-system specification"optional = falsepython-versions = ">=3.8"files = [- {file = "fsspec-2024.12.0-py3-none-any.whl", hash = "sha256:b520aed47ad9804237ff878b504267a3b0b441e97508bd6d2d8774e3db85cee2"},- {file = "fsspec-2024.12.0.tar.gz", hash = "sha256:670700c977ed2fb51e0d9f9253177ed20cbde4a3e5c0283cc5385b5870c8533f"},+ {file = "fsspec-2024.9.0-py3-none-any.whl", hash = "sha256:a0947d552d8a6efa72cc2c730b12c41d043509156966cca4fb157b0f2a0c574b"},+ {file = "fsspec-2024.9.0.tar.gz", hash = "sha256:4b0afb90c2f21832df142f292649035d80b421f60a9e1c027802e5a0da2b04e8"},][package.dependencies]@@ -2461,42 +2462,80 @@ files = [[package.dependencies]requests = ">=2.20.0,<3.0"+[[package]]+name = "googletrans-py"+version = "4.0.0"+description = "Free Google Translate API for Python. Translates totally free of charge."+optional = false+python-versions = ">=3.7"+files = [+ {file = "googletrans-py-4.0.0.tar.gz", hash = "sha256:487963819ced88f1f81d848786e2d3e02544833d161cc5edb178a1f74bde6d98"},+]++[package.dependencies]+h2 = ">=4,<5"+httpx = ">=0.22.0"+[[package]]name = "gradio"-version = "3.18.0"+version = "3.50.2"description = "Python library for easily interacting with trained machine learning models"optional = false-python-versions = ">=3.7"+python-versions = ">=3.8"files = [- {file = "gradio-3.18.0-py3-none-any.whl", hash = "sha256:de608f310584d1b16c9554015352adfa4804e6319d20a6b66e271377d2bbb31d"},- {file = "gradio-3.18.0.tar.gz", hash = "sha256:f66d19c651c740da6cfa2b411b0e19942579532e0ffc5c41f71a2adbf0bc5c30"},+ {file = "gradio-3.50.2-py3-none-any.whl", hash = "sha256:dffc070955225dbc3af0cf4ce93a169267485bb6972ee76ff7a0f31be77346a0"},+ {file = "gradio-3.50.2.tar.gz", hash = "sha256:c6c81320566ba3e5688a1a58201d0729565a97b828b2bf6895e54f7bf25c01de"},][package.dependencies]-aiofiles = "*"-aiohttp = "*"-altair = ">=4.2.0"+aiofiles = ">=22.0,<24.0"+altair = ">=4.2.0,<6.0"fastapi = "*"ffmpy = "*"-fsspec = "*"+gradio-client = "0.6.1"httpx = "*"-jinja2 = "*"-markdown-it-py = {version = ">=2.0.0", extras = ["linkify", "plugins"]}-markupsafe = "*"-matplotlib = "*"-numpy = "*"-orjson = "*"-pandas = "*"-pillow = "*"-pycryptodome = "*"-pydantic = "*"+huggingface-hub = ">=0.14.0"+importlib-resources = ">=1.3,<7.0"+jinja2 = "<4.0"+markupsafe = ">=2.0,<3.0"+matplotlib = ">=3.0,<4.0"+numpy = ">=1.0,<2.0"+orjson = ">=3.0,<4.0"+packaging = "*"+pandas = ">=1.0,<3.0"+pillow = ">=8.0,<11.0"+pydantic = ">=1.7.4,<1.8 || >1.8,<1.8.1 || >1.8.1,<2.0.0 || >2.0.0,<2.0.1 || >2.0.1,<3.0.0"pydub = "*"python-multipart = "*"-pyyaml = "*"-requests = "*"-typing-extensions = "*"-uvicorn = "*"-websockets = ">=10.0"+pyyaml = ">=5.0,<7.0"+requests = ">=2.0,<3.0"+semantic-version = ">=2.0,<3.0"+typing-extensions = ">=4.0,<5.0"+uvicorn = ">=0.14.0"+websockets = ">=10.0,<12.0"++[package.extras]+oauth = ["authlib", "itsdangerous"]++[[package]]+name = "gradio-client"+version = "0.6.1"+description = "Python library for easily interacting with trained machine learning models"+optional = false+python-versions = ">=3.8"+files = [+ {file = "gradio_client-0.6.1-py3-none-any.whl", hash = "sha256:ee530fb3437f24943e51da70335909cc9b4f1e3e1ab1d219071b8ce9c1969777"},+ {file = "gradio_client-0.6.1.tar.gz", hash = "sha256:2f36a8467622f748539c84d142f1a71df6b83666d017ee4fb6ef8a2696f70f66"},+]++[package.dependencies]+fsspec = "*"+httpx = "*"+huggingface-hub = ">=0.13.0"+packaging = "*"+requests = ">=2.0,<3.0"+typing-extensions = ">=4.0,<5.0"+websockets = ">=10.0,<12.0"[[package]]name = "grpcio"@@ -2658,7 +2697,7 @@ files = [name = "h2"version = "4.1.0"description = "HTTP/2 State-Machine based protocol implementation"-optional = true+optional = falsepython-versions = ">=3.6.1"files = [{file = "h2-4.1.0-py3-none-any.whl", hash = "sha256:03a46bcf682256c95b5fd9e9a99c1323584c3eec6440d379b9903d709476bc6d"},@@ -2673,7 +2712,7 @@ hyperframe = ">=6.0,<7"name = "hpack"version = "4.0.0"description = "Pure-Python HPACK header compression"-optional = true+optional = falsepython-versions = ">=3.6.1"files = [{file = "hpack-4.0.0-py3-none-any.whl", hash = "sha256:84a076fad3dc9a9f8063ccb8041ef100867b1878b25ef0ee63847a5d53818a6c"},@@ -2794,7 +2833,7 @@ wsproto = "*"name = "huggingface-hub"version = "0.27.0"description = "Client library to download and publish models, datasets and other repos on the huggingface.co hub"-optional = true+optional = falsepython-versions = ">=3.8.0"files = [{file = "huggingface_hub-0.27.0-py3-none-any.whl", hash = "sha256:8f2e834517f1f1ddf1ecc716f91b120d7333011b7485f665a9a412eacb1a2a81"},@@ -2842,7 +2881,7 @@ pyreadline3 = {version = "*", markers = "sys_platform == \"win32\" and python_vename = "hyperframe"version = "6.0.1"description = "HTTP/2 framing layer for Python"-optional = true+optional = falsepython-versions = ">=3.6.1"files = [{file = "hyperframe-6.0.1-py3-none-any.whl", hash = "sha256:0ec6bafd80d8ad2195c4f03aacba3a8265e57bc4cff261e802bf39970ed02a15"},@@ -2941,6 +2980,25 @@ doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linkeperf = ["ipython"]test = ["flufl.flake8", "importlib-resources (>=1.3)", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-perf (>=0.9.2)", "pytest-ruff (>=0.2.1)"]+[[package]]+name = "importlib-resources"+version = "6.4.5"+description = "Read resources from Python packages"+optional = false+python-versions = ">=3.8"+files = [+ {file = "importlib_resources-6.4.5-py3-none-any.whl", hash = "sha256:ac29d5f956f01d5e4bb63102a5a19957f1b9175e45649977264a1416783bb717"},+ {file = "importlib_resources-6.4.5.tar.gz", hash = "sha256:980862a1d16c9e147a59603677fa2aa5fd82b87f223b6cb870695bcfce830065"},+]++[package.extras]+check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1)"]+cover = ["pytest-cov"]+doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"]+enabler = ["pytest-enabler (>=2.2)"]+test = ["jaraco.test (>=5.4)", "pytest (>=6,!=8.1.*)", "zipp (>=3.17)"]+type = ["pytest-mypy"]+[[package]]name = "iniconfig"version = "2.0.0"@@ -3546,41 +3604,6 @@ files = [{file = "lazy_object_proxy-1.10.0-pp310.pp311.pp312.pp38.pp39-none-any.whl", hash = "sha256:80fa48bd89c8f2f456fc0765c11c23bf5af827febacd2f523ca5bc1893fcc09d"},]-[[package]]-name = "linkify-it-py"-version = "2.0.3"-description = "Links recognition library with FULL unicode support."-optional = false-python-versions = ">=3.7"-files = [- {file = "linkify-it-py-2.0.3.tar.gz", hash = "sha256:68cda27e162e9215c17d786649d1da0021a451bdc436ef9e0fa0ba5234b9b048"},- {file = "linkify_it_py-2.0.3-py3-none-any.whl", hash = "sha256:6bcbc417b0ac14323382aef5c5192c0075bf8a9d6b41820a2b66371eac6b6d79"},-]--[package.dependencies]-uc-micro-py = "*"--[package.extras]-benchmark = ["pytest", "pytest-benchmark"]-dev = ["black", "flake8", "isort", "pre-commit", "pyproject-flake8"]-doc = ["myst-parser", "sphinx", "sphinx-book-theme"]-test = ["coverage", "pytest", "pytest-cov"]--[[package]]-name = "linkup-sdk"-version = "0.2.1"-description = "A Python Client SDK for the Linkup API"-optional = true-python-versions = ">=3.9"-files = [- {file = "linkup_sdk-0.2.1-py3-none-any.whl", hash = "sha256:bf50c88e659c6d9291cbd5e3e99b6a20a14c9b1eb2dc7acca763a3ae6f84b26e"},- {file = "linkup_sdk-0.2.1.tar.gz", hash = "sha256:b00ba7cb0117358e975d50196501ac49b247509fd236121e40abe40e6a2a3e9a"},-]--[package.dependencies]-httpx = "*"-pydantic = "*"-[[package]]name = "litellm"version = "1.56.4"@@ -3790,8 +3813,6 @@ files = [][package.dependencies]-linkify-it-py = {version = ">=1,<3", optional = true, markers = "extra == \"linkify\""}-mdit-py-plugins = {version = "*", optional = true, markers = "extra == \"plugins\""}mdurl = ">=0.1,<1.0"[package.extras]@@ -3806,72 +3827,71 @@ testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"][[package]]name = "markupsafe"-version = "3.0.2"+version = "2.1.5"description = "Safely add untrusted strings to HTML/XML markup."optional = false-python-versions = ">=3.9"+python-versions = ">=3.7"files = [- {file = "MarkupSafe-3.0.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7e94c425039cde14257288fd61dcfb01963e658efbc0ff54f5306b06054700f8"},- {file = "MarkupSafe-3.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9e2d922824181480953426608b81967de705c3cef4d1af983af849d7bd619158"},- {file = "MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38a9ef736c01fccdd6600705b09dc574584b89bea478200c5fbf112a6b0d5579"},- {file = "MarkupSafe-3.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bbcb445fa71794da8f178f0f6d66789a28d7319071af7a496d4d507ed566270d"},- {file = "MarkupSafe-3.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:57cb5a3cf367aeb1d316576250f65edec5bb3be939e9247ae594b4bcbc317dfb"},- {file = "MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3809ede931876f5b2ec92eef964286840ed3540dadf803dd570c3b7e13141a3b"},- {file = "MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e07c3764494e3776c602c1e78e298937c3315ccc9043ead7e685b7f2b8d47b3c"},- {file = "MarkupSafe-3.0.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b424c77b206d63d500bcb69fa55ed8d0e6a3774056bdc4839fc9298a7edca171"},- {file = "MarkupSafe-3.0.2-cp310-cp310-win32.whl", hash = "sha256:fcabf5ff6eea076f859677f5f0b6b5c1a51e70a376b0579e0eadef8db48c6b50"},- {file = "MarkupSafe-3.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:6af100e168aa82a50e186c82875a5893c5597a0c1ccdb0d8b40240b1f28b969a"},- {file = "MarkupSafe-3.0.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9025b4018f3a1314059769c7bf15441064b2207cb3f065e6ea1e7359cb46db9d"},- {file = "MarkupSafe-3.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93335ca3812df2f366e80509ae119189886b0f3c2b81325d39efdb84a1e2ae93"},- {file = "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cb8438c3cbb25e220c2ab33bb226559e7afb3baec11c4f218ffa7308603c832"},- {file = "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a123e330ef0853c6e822384873bef7507557d8e4a082961e1defa947aa59ba84"},- {file = "MarkupSafe-3.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1e084f686b92e5b83186b07e8a17fc09e38fff551f3602b249881fec658d3eca"},- {file = "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d8213e09c917a951de9d09ecee036d5c7d36cb6cb7dbaece4c71a60d79fb9798"},- {file = "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:5b02fb34468b6aaa40dfc198d813a641e3a63b98c2b05a16b9f80b7ec314185e"},- {file = "MarkupSafe-3.0.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0bff5e0ae4ef2e1ae4fdf2dfd5b76c75e5c2fa4132d05fc1b0dabcd20c7e28c4"},- {file = "MarkupSafe-3.0.2-cp311-cp311-win32.whl", hash = "sha256:6c89876f41da747c8d3677a2b540fb32ef5715f97b66eeb0c6b66f5e3ef6f59d"},- {file = "MarkupSafe-3.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:70a87b411535ccad5ef2f1df5136506a10775d267e197e4cf531ced10537bd6b"},- {file = "MarkupSafe-3.0.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:9778bd8ab0a994ebf6f84c2b949e65736d5575320a17ae8984a77fab08db94cf"},- {file = "MarkupSafe-3.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:846ade7b71e3536c4e56b386c2a47adf5741d2d8b94ec9dc3e92e5e1ee1e2225"},- {file = "MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1c99d261bd2d5f6b59325c92c73df481e05e57f19837bdca8413b9eac4bd8028"},- {file = "MarkupSafe-3.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e17c96c14e19278594aa4841ec148115f9c7615a47382ecb6b82bd8fea3ab0c8"},- {file = "MarkupSafe-3.0.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88416bd1e65dcea10bc7569faacb2c20ce071dd1f87539ca2ab364bf6231393c"},- {file = "MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2181e67807fc2fa785d0592dc2d6206c019b9502410671cc905d132a92866557"},- {file = "MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:52305740fe773d09cffb16f8ed0427942901f00adedac82ec8b67752f58a1b22"},- {file = "MarkupSafe-3.0.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ad10d3ded218f1039f11a75f8091880239651b52e9bb592ca27de44eed242a48"},- {file = "MarkupSafe-3.0.2-cp312-cp312-win32.whl", hash = "sha256:0f4ca02bea9a23221c0182836703cbf8930c5e9454bacce27e767509fa286a30"},- {file = "MarkupSafe-3.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:8e06879fc22a25ca47312fbe7c8264eb0b662f6db27cb2d3bbbc74b1df4b9b87"},- {file = "MarkupSafe-3.0.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ba9527cdd4c926ed0760bc301f6728ef34d841f405abf9d4f959c478421e4efd"},- {file = "MarkupSafe-3.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f8b3d067f2e40fe93e1ccdd6b2e1d16c43140e76f02fb1319a05cf2b79d99430"},- {file = "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569511d3b58c8791ab4c2e1285575265991e6d8f8700c7be0e88f86cb0672094"},- {file = "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15ab75ef81add55874e7ab7055e9c397312385bd9ced94920f2802310c930396"},- {file = "MarkupSafe-3.0.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3818cb119498c0678015754eba762e0d61e5b52d34c8b13d770f0719f7b1d79"},- {file = "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cdb82a876c47801bb54a690c5ae105a46b392ac6099881cdfb9f6e95e4014c6a"},- {file = "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cabc348d87e913db6ab4aa100f01b08f481097838bdddf7c7a84b7575b7309ca"},- {file = "MarkupSafe-3.0.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:444dcda765c8a838eaae23112db52f1efaf750daddb2d9ca300bcae1039adc5c"},- {file = "MarkupSafe-3.0.2-cp313-cp313-win32.whl", hash = "sha256:bcf3e58998965654fdaff38e58584d8937aa3096ab5354d493c77d1fdd66d7a1"},- {file = "MarkupSafe-3.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:e6a2a455bd412959b57a172ce6328d2dd1f01cb2135efda2e4576e8a23fa3b0f"},- {file = "MarkupSafe-3.0.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b5a6b3ada725cea8a5e634536b1b01c30bcdcd7f9c6fff4151548d5bf6b3a36c"},- {file = "MarkupSafe-3.0.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:a904af0a6162c73e3edcb969eeeb53a63ceeb5d8cf642fade7d39e7963a22ddb"},- {file = "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4aa4e5faecf353ed117801a068ebab7b7e09ffb6e1d5e412dc852e0da018126c"},- {file = "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0ef13eaeee5b615fb07c9a7dadb38eac06a0608b41570d8ade51c56539e509d"},- {file = "MarkupSafe-3.0.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d16a81a06776313e817c951135cf7340a3e91e8c1ff2fac444cfd75fffa04afe"},- {file = "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6381026f158fdb7c72a168278597a5e3a5222e83ea18f543112b2662a9b699c5"},- {file = "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:3d79d162e7be8f996986c064d1c7c817f6df3a77fe3d6859f6f9e7be4b8c213a"},- {file = "MarkupSafe-3.0.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:131a3c7689c85f5ad20f9f6fb1b866f402c445b220c19fe4308c0b147ccd2ad9"},- {file = "MarkupSafe-3.0.2-cp313-cp313t-win32.whl", hash = "sha256:ba8062ed2cf21c07a9e295d5b8a2a5ce678b913b45fdf68c32d95d6c1291e0b6"},- {file = "MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f"},- {file = "MarkupSafe-3.0.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:eaa0a10b7f72326f1372a713e73c3f739b524b3af41feb43e4921cb529f5929a"},- {file = "MarkupSafe-3.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:48032821bbdf20f5799ff537c7ac3d1fba0ba032cfc06194faffa8cda8b560ff"},- {file = "MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a9d3f5f0901fdec14d8d2f66ef7d035f2157240a433441719ac9a3fba440b13"},- {file = "MarkupSafe-3.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88b49a3b9ff31e19998750c38e030fc7bb937398b1f78cfa599aaef92d693144"},- {file = "MarkupSafe-3.0.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cfad01eed2c2e0c01fd0ecd2ef42c492f7f93902e39a42fc9ee1692961443a29"},- {file = "MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:1225beacc926f536dc82e45f8a4d68502949dc67eea90eab715dea3a21c1b5f0"},- {file = "MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:3169b1eefae027567d1ce6ee7cae382c57fe26e82775f460f0b2778beaad66c0"},- {file = "MarkupSafe-3.0.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:eb7972a85c54febfb25b5c4b4f3af4dcc731994c7da0d8a0b4a6eb0640e1d178"},- {file = "MarkupSafe-3.0.2-cp39-cp39-win32.whl", hash = "sha256:8c4e8c3ce11e1f92f6536ff07154f9d49677ebaaafc32db9db4620bc11ed480f"},- {file = "MarkupSafe-3.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:6e296a513ca3d94054c2c881cc913116e90fd030ad1c656b3869762b754f5f8a"},- {file = "markupsafe-3.0.2.tar.gz", hash = "sha256:ee55d3edf80167e48ea11a923c7386f4669df67d7994554387f84e7d8b0a2bf0"},+ {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"},+ {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"},+ {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"},+ {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"},+ {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"},+ {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"},+ {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"},+ {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"},+ {file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"},+ {file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"},+ {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"},+ {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"},+ {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"},+ {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"},+ {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"},+ {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"},+ {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"},+ {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"},+ {file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"},+ {file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"},+ {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"},+ {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"},+ {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"},+ {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"},+ {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"},+ {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"},+ {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"},+ {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"},+ {file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"},+ {file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"},+ {file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"},+ {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"},+ {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"},+ {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"},+ {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"},+ {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"},+ {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"},+ {file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"},+ {file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"},+ {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"},+ {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"},+ {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"},+ {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"},+ {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"},+ {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"},+ {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"},+ {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"},+ {file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"},+ {file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"},+ {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"},+ {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"},+ {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"},+ {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"},+ {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"},+ {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"},+ {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"},+ {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"},+ {file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"},+ {file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"},+ {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"},][[package]]@@ -4003,6 +4023,7 @@ python-versions = ">=3.7"files = [{file = "milvus_lite-2.4.10-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:fc4246d3ed7d1910847afce0c9ba18212e93a6e9b8406048436940578dfad5cb"},{file = "milvus_lite-2.4.10-py3-none-macosx_11_0_arm64.whl", hash = "sha256:74a8e07c5e3b057df17fbb46913388e84df1dc403a200f4e423799a58184c800"},+ {file = "milvus_lite-2.4.10-py3-none-manylinux2014_aarch64.whl", hash = "sha256:240c7386b747bad696ecb5bd1f58d491e86b9d4b92dccee3315ed7256256eddc"},{file = "milvus_lite-2.4.10-py3-none-manylinux2014_x86_64.whl", hash = "sha256:211d2e334a043f9282bdd9755f76b9b2d93b23bffa7af240919ffce6a8dfe325"},]@@ -4090,7 +4111,7 @@ tests = ["pytest (>=4.6)"]name = "multidict"version = "6.1.0"description = "multidict implementation"-optional = false+optional = truepython-versions = ">=3.8"files = [{file = "multidict-6.1.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3380252550e372e8511d49481bd836264c009adb826b23fefcc5dd3c69692f60"},@@ -4192,31 +4213,27 @@ typing-extensions = {version = ">=4.1.0", markers = "python_version < \"3.11\""}[[package]]name = "multiprocess"-version = "0.70.15"+version = "0.70.16"description = "better multiprocessing and multithreading in Python"optional = true-python-versions = ">=3.7"+python-versions = ">=3.8"files = [- {file = "multiprocess-0.70.15-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:aa36c7ed16f508091438687fe9baa393a7a8e206731d321e443745e743a0d4e5"},- {file = "multiprocess-0.70.15-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:20e024018c46d0d1602024c613007ac948f9754659e3853b0aa705e83f6931d8"},- {file = "multiprocess-0.70.15-pp37-pypy37_pp73-manylinux_2_24_i686.whl", hash = "sha256:e576062981c91f0fe8a463c3d52506e598dfc51320a8dd8d78b987dfca91c5db"},- {file = "multiprocess-0.70.15-pp37-pypy37_pp73-manylinux_2_24_x86_64.whl", hash = "sha256:e73f497e6696a0f5433ada2b3d599ae733b87a6e8b008e387c62ac9127add177"},- {file = "multiprocess-0.70.15-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:73db2e7b32dcc7f9b0f075c2ffa45c90b6729d3f1805f27e88534c8d321a1be5"},- {file = "multiprocess-0.70.15-pp38-pypy38_pp73-manylinux_2_24_i686.whl", hash = "sha256:4271647bd8a49c28ecd6eb56a7fdbd3c212c45529ad5303b40b3c65fc6928e5f"},- {file = "multiprocess-0.70.15-pp38-pypy38_pp73-manylinux_2_24_x86_64.whl", hash = "sha256:cf981fb998d6ec3208cb14f0cf2e9e80216e834f5d51fd09ebc937c32b960902"},- {file = "multiprocess-0.70.15-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:18f9f2c7063346d1617bd1684fdcae8d33380ae96b99427260f562e1a1228b67"},- {file = "multiprocess-0.70.15-pp39-pypy39_pp73-manylinux_2_24_i686.whl", hash = "sha256:0eac53214d664c49a34695e5824872db4006b1a465edd7459a251809c3773370"},- {file = "multiprocess-0.70.15-pp39-pypy39_pp73-manylinux_2_24_x86_64.whl", hash = "sha256:1a51dd34096db47fb21fa2b839e615b051d51b97af9a67afbcdaa67186b44883"},- {file = "multiprocess-0.70.15-py310-none-any.whl", hash = "sha256:7dd58e33235e83cf09d625e55cffd7b0f0eede7ee9223cdd666a87624f60c21a"},- {file = "multiprocess-0.70.15-py311-none-any.whl", hash = "sha256:134f89053d82c9ed3b73edd3a2531eb791e602d4f4156fc92a79259590bd9670"},- {file = "multiprocess-0.70.15-py37-none-any.whl", hash = "sha256:f7d4a1629bccb433114c3b4885f69eccc200994323c80f6feee73b0edc9199c5"},- {file = "multiprocess-0.70.15-py38-none-any.whl", hash = "sha256:bee9afba476c91f9ebee7beeee0601face9eff67d822e893f9a893725fbd6316"},- {file = "multiprocess-0.70.15-py39-none-any.whl", hash = "sha256:3e0953f5d52b4c76f1c973eaf8214554d146f2be5decb48e928e55c7a2d19338"},- {file = "multiprocess-0.70.15.tar.gz", hash = "sha256:f20eed3036c0ef477b07a4177cf7c1ba520d9a2677870a4f47fe026f0cd6787e"},+ {file = "multiprocess-0.70.16-pp310-pypy310_pp73-macosx_10_13_x86_64.whl", hash = "sha256:476887be10e2f59ff183c006af746cb6f1fd0eadcfd4ef49e605cbe2659920ee"},+ {file = "multiprocess-0.70.16-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:d951bed82c8f73929ac82c61f01a7b5ce8f3e5ef40f5b52553b4f547ce2b08ec"},+ {file = "multiprocess-0.70.16-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:37b55f71c07e2d741374998c043b9520b626a8dddc8b3129222ca4f1a06ef67a"},+ {file = "multiprocess-0.70.16-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:ba8c31889abf4511c7308a8c52bb4a30b9d590e7f58523302ba00237702ca054"},+ {file = "multiprocess-0.70.16-pp39-pypy39_pp73-macosx_10_13_x86_64.whl", hash = "sha256:0dfd078c306e08d46d7a8d06fb120313d87aa43af60d66da43ffff40b44d2f41"},+ {file = "multiprocess-0.70.16-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e7b9d0f307cd9bd50851afaac0dba2cb6c44449efff697df7c7645f7d3f2be3a"},+ {file = "multiprocess-0.70.16-py310-none-any.whl", hash = "sha256:c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02"},+ {file = "multiprocess-0.70.16-py311-none-any.whl", hash = "sha256:af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a"},+ {file = "multiprocess-0.70.16-py312-none-any.whl", hash = "sha256:fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e"},+ {file = "multiprocess-0.70.16-py38-none-any.whl", hash = "sha256:a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435"},+ {file = "multiprocess-0.70.16-py39-none-any.whl", hash = "sha256:a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3"},+ {file = "multiprocess-0.70.16.tar.gz", hash = "sha256:161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1"},][package.dependencies]-dill = ">=0.3.7"+dill = ">=0.3.8"[[package]]name = "mypy"@@ -5667,90 +5684,95 @@ test = ["attrs (>=20.2.0)", "coverage[toml]", "hypothesis (>=6.36)", "numpy (>=1[[package]]name = "pillow"-version = "11.0.0"+version = "10.4.0"description = "Python Imaging Library (Fork)"optional = false-python-versions = ">=3.9"+python-versions = ">=3.8"files = [- {file = "pillow-11.0.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:6619654954dc4936fcff82db8eb6401d3159ec6be81e33c6000dfd76ae189947"},- {file = "pillow-11.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b3c5ac4bed7519088103d9450a1107f76308ecf91d6dabc8a33a2fcfb18d0fba"},- {file = "pillow-11.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a65149d8ada1055029fcb665452b2814fe7d7082fcb0c5bed6db851cb69b2086"},- {file = "pillow-11.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88a58d8ac0cc0e7f3a014509f0455248a76629ca9b604eca7dc5927cc593c5e9"},- {file = "pillow-11.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:c26845094b1af3c91852745ae78e3ea47abf3dbcd1cf962f16b9a5fbe3ee8488"},- {file = "pillow-11.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:1a61b54f87ab5786b8479f81c4b11f4d61702830354520837f8cc791ebba0f5f"},- {file = "pillow-11.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:674629ff60030d144b7bca2b8330225a9b11c482ed408813924619c6f302fdbb"},- {file = "pillow-11.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:598b4e238f13276e0008299bd2482003f48158e2b11826862b1eb2ad7c768b97"},- {file = "pillow-11.0.0-cp310-cp310-win32.whl", hash = "sha256:9a0f748eaa434a41fccf8e1ee7a3eed68af1b690e75328fd7a60af123c193b50"},- {file = "pillow-11.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:a5629742881bcbc1f42e840af185fd4d83a5edeb96475a575f4da50d6ede337c"},- {file = "pillow-11.0.0-cp310-cp310-win_arm64.whl", hash = "sha256:ee217c198f2e41f184f3869f3e485557296d505b5195c513b2bfe0062dc537f1"},- {file = "pillow-11.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1c1d72714f429a521d8d2d018badc42414c3077eb187a59579f28e4270b4b0fc"},- {file = "pillow-11.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:499c3a1b0d6fc8213519e193796eb1a86a1be4b1877d678b30f83fd979811d1a"},- {file = "pillow-11.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c8b2351c85d855293a299038e1f89db92a2f35e8d2f783489c6f0b2b5f3fe8a3"},- {file = "pillow-11.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f4dba50cfa56f910241eb7f883c20f1e7b1d8f7d91c750cd0b318bad443f4d5"},- {file = "pillow-11.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:5ddbfd761ee00c12ee1be86c9c0683ecf5bb14c9772ddbd782085779a63dd55b"},- {file = "pillow-11.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:45c566eb10b8967d71bf1ab8e4a525e5a93519e29ea071459ce517f6b903d7fa"},- {file = "pillow-11.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b4fd7bd29610a83a8c9b564d457cf5bd92b4e11e79a4ee4716a63c959699b306"},- {file = "pillow-11.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:cb929ca942d0ec4fac404cbf520ee6cac37bf35be479b970c4ffadf2b6a1cad9"},- {file = "pillow-11.0.0-cp311-cp311-win32.whl", hash = "sha256:006bcdd307cc47ba43e924099a038cbf9591062e6c50e570819743f5607404f5"},- {file = "pillow-11.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:52a2d8323a465f84faaba5236567d212c3668f2ab53e1c74c15583cf507a0291"},- {file = "pillow-11.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:16095692a253047fe3ec028e951fa4221a1f3ed3d80c397e83541a3037ff67c9"},- {file = "pillow-11.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d2c0a187a92a1cb5ef2c8ed5412dd8d4334272617f532d4ad4de31e0495bd923"},- {file = "pillow-11.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:084a07ef0821cfe4858fe86652fffac8e187b6ae677e9906e192aafcc1b69903"},- {file = "pillow-11.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8069c5179902dcdce0be9bfc8235347fdbac249d23bd90514b7a47a72d9fecf4"},- {file = "pillow-11.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f02541ef64077f22bf4924f225c0fd1248c168f86e4b7abdedd87d6ebaceab0f"},- {file = "pillow-11.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:fcb4621042ac4b7865c179bb972ed0da0218a076dc1820ffc48b1d74c1e37fe9"},- {file = "pillow-11.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:00177a63030d612148e659b55ba99527803288cea7c75fb05766ab7981a8c1b7"},- {file = "pillow-11.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8853a3bf12afddfdf15f57c4b02d7ded92c7a75a5d7331d19f4f9572a89c17e6"},- {file = "pillow-11.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3107c66e43bda25359d5ef446f59c497de2b5ed4c7fdba0894f8d6cf3822dafc"},- {file = "pillow-11.0.0-cp312-cp312-win32.whl", hash = "sha256:86510e3f5eca0ab87429dd77fafc04693195eec7fd6a137c389c3eeb4cfb77c6"},- {file = "pillow-11.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:8ec4a89295cd6cd4d1058a5e6aec6bf51e0eaaf9714774e1bfac7cfc9051db47"},- {file = "pillow-11.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:27a7860107500d813fcd203b4ea19b04babe79448268403172782754870dac25"},- {file = "pillow-11.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bcd1fb5bb7b07f64c15618c89efcc2cfa3e95f0e3bcdbaf4642509de1942a699"},- {file = "pillow-11.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0e038b0745997c7dcaae350d35859c9715c71e92ffb7e0f4a8e8a16732150f38"},- {file = "pillow-11.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ae08bd8ffc41aebf578c2af2f9d8749d91f448b3bfd41d7d9ff573d74f2a6b2"},- {file = "pillow-11.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d69bfd8ec3219ae71bcde1f942b728903cad25fafe3100ba2258b973bd2bc1b2"},- {file = "pillow-11.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:61b887f9ddba63ddf62fd02a3ba7add935d053b6dd7d58998c630e6dbade8527"},- {file = "pillow-11.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:c6a660307ca9d4867caa8d9ca2c2658ab685de83792d1876274991adec7b93fa"},- {file = "pillow-11.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:73e3a0200cdda995c7e43dd47436c1548f87a30bb27fb871f352a22ab8dcf45f"},- {file = "pillow-11.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fba162b8872d30fea8c52b258a542c5dfd7b235fb5cb352240c8d63b414013eb"},- {file = "pillow-11.0.0-cp313-cp313-win32.whl", hash = "sha256:f1b82c27e89fffc6da125d5eb0ca6e68017faf5efc078128cfaa42cf5cb38798"},- {file = "pillow-11.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ba470552b48e5835f1d23ecb936bb7f71d206f9dfeee64245f30c3270b994de"},- {file = "pillow-11.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:846e193e103b41e984ac921b335df59195356ce3f71dcfd155aa79c603873b84"},- {file = "pillow-11.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4ad70c4214f67d7466bea6a08061eba35c01b1b89eaa098040a35272a8efb22b"},- {file = "pillow-11.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6ec0d5af64f2e3d64a165f490d96368bb5dea8b8f9ad04487f9ab60dc4bb6003"},- {file = "pillow-11.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c809a70e43c7977c4a42aefd62f0131823ebf7dd73556fa5d5950f5b354087e2"},- {file = "pillow-11.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:4b60c9520f7207aaf2e1d94de026682fc227806c6e1f55bba7606d1c94dd623a"},- {file = "pillow-11.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:1e2688958a840c822279fda0086fec1fdab2f95bf2b717b66871c4ad9859d7e8"},- {file = "pillow-11.0.0-cp313-cp313t-win32.whl", hash = "sha256:607bbe123c74e272e381a8d1957083a9463401f7bd01287f50521ecb05a313f8"},- {file = "pillow-11.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5c39ed17edea3bc69c743a8dd3e9853b7509625c2462532e62baa0732163a904"},- {file = "pillow-11.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:75acbbeb05b86bc53cbe7b7e6fe00fbcf82ad7c684b3ad82e3d711da9ba287d3"},- {file = "pillow-11.0.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2e46773dc9f35a1dd28bd6981332fd7f27bec001a918a72a79b4133cf5291dba"},- {file = "pillow-11.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2679d2258b7f1192b378e2893a8a0a0ca472234d4c2c0e6bdd3380e8dfa21b6a"},- {file = "pillow-11.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eda2616eb2313cbb3eebbe51f19362eb434b18e3bb599466a1ffa76a033fb916"},- {file = "pillow-11.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ec184af98a121fb2da42642dea8a29ec80fc3efbaefb86d8fdd2606619045d"},- {file = "pillow-11.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:8594f42df584e5b4bb9281799698403f7af489fba84c34d53d1c4bfb71b7c4e7"},- {file = "pillow-11.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:c12b5ae868897c7338519c03049a806af85b9b8c237b7d675b8c5e089e4a618e"},- {file = "pillow-11.0.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:70fbbdacd1d271b77b7721fe3cdd2d537bbbd75d29e6300c672ec6bb38d9672f"},- {file = "pillow-11.0.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5178952973e588b3f1360868847334e9e3bf49d19e169bbbdfaf8398002419ae"},- {file = "pillow-11.0.0-cp39-cp39-win32.whl", hash = "sha256:8c676b587da5673d3c75bd67dd2a8cdfeb282ca38a30f37950511766b26858c4"},- {file = "pillow-11.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:94f3e1780abb45062287b4614a5bc0874519c86a777d4a7ad34978e86428b8dd"},- {file = "pillow-11.0.0-cp39-cp39-win_arm64.whl", hash = "sha256:290f2cc809f9da7d6d622550bbf4c1e57518212da51b6a30fe8e0a270a5b78bd"},- {file = "pillow-11.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1187739620f2b365de756ce086fdb3604573337cc28a0d3ac4a01ab6b2d2a6d2"},- {file = "pillow-11.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:fbbcb7b57dc9c794843e3d1258c0fbf0f48656d46ffe9e09b63bbd6e8cd5d0a2"},- {file = "pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d203af30149ae339ad1b4f710d9844ed8796e97fda23ffbc4cc472968a47d0b"},- {file = "pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21a0d3b115009ebb8ac3d2ebec5c2982cc693da935f4ab7bb5c8ebe2f47d36f2"},- {file = "pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:73853108f56df97baf2bb8b522f3578221e56f646ba345a372c78326710d3830"},- {file = "pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e58876c91f97b0952eb766123bfef372792ab3f4e3e1f1a2267834c2ab131734"},- {file = "pillow-11.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:224aaa38177597bb179f3ec87eeefcce8e4f85e608025e9cfac60de237ba6316"},- {file = "pillow-11.0.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:5bd2d3bdb846d757055910f0a59792d33b555800813c3b39ada1829c372ccb06"},- {file = "pillow-11.0.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:375b8dd15a1f5d2feafff536d47e22f69625c1aa92f12b339ec0b2ca40263273"},- {file = "pillow-11.0.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:daffdf51ee5db69a82dd127eabecce20729e21f7a3680cf7cbb23f0829189790"},- {file = "pillow-11.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7326a1787e3c7b0429659e0a944725e1b03eeaa10edd945a86dead1913383944"},- {file = "pillow-11.0.0.tar.gz", hash = "sha256:72bacbaf24ac003fea9bff9837d1eedb6088758d41e100c1552930151f677739"},-]--[package.extras]-docs = ["furo", "olefile", "sphinx (>=8.1)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinxext-opengraph"]+ {file = "pillow-10.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:4d9667937cfa347525b319ae34375c37b9ee6b525440f3ef48542fcf66f2731e"},+ {file = "pillow-10.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d"},+ {file = "pillow-10.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7928ecbf1ece13956b95d9cbcfc77137652b02763ba384d9ab508099a2eca856"},+ {file = "pillow-10.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f"},+ {file = "pillow-10.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:6c762a5b0997f5659a5ef2266abc1d8851ad7749ad9a6a5506eb23d314e4f46b"},+ {file = "pillow-10.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a985e028fc183bf12a77a8bbf36318db4238a3ded7fa9df1b9a133f1cb79f8fc"},+ {file = "pillow-10.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:812f7342b0eee081eaec84d91423d1b4650bb9828eb53d8511bcef8ce5aecf1e"},+ {file = "pillow-10.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ac1452d2fbe4978c2eec89fb5a23b8387aba707ac72810d9490118817d9c0b46"},+ {file = "pillow-10.4.0-cp310-cp310-win32.whl", hash = "sha256:bcd5e41a859bf2e84fdc42f4edb7d9aba0a13d29a2abadccafad99de3feff984"},+ {file = "pillow-10.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141"},+ {file = "pillow-10.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:ff337c552345e95702c5fde3158acb0625111017d0e5f24bf3acdb9cc16b90d1"},+ {file = "pillow-10.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0a9ec697746f268507404647e531e92889890a087e03681a3606d9b920fbee3c"},+ {file = "pillow-10.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be"},+ {file = "pillow-10.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dc6761a6efc781e6a1544206f22c80c3af4c8cf461206d46a1e6006e4429ff3"},+ {file = "pillow-10.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6"},+ {file = "pillow-10.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:bbc527b519bd3aa9d7f429d152fea69f9ad37c95f0b02aebddff592688998abe"},+ {file = "pillow-10.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:76a911dfe51a36041f2e756b00f96ed84677cdeb75d25c767f296c1c1eda1319"},+ {file = "pillow-10.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59291fb29317122398786c2d44427bbd1a6d7ff54017075b22be9d21aa59bd8d"},+ {file = "pillow-10.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:416d3a5d0e8cfe4f27f574362435bc9bae57f679a7158e0096ad2beb427b8696"},+ {file = "pillow-10.4.0-cp311-cp311-win32.whl", hash = "sha256:7086cc1d5eebb91ad24ded9f58bec6c688e9f0ed7eb3dbbf1e4800280a896496"},+ {file = "pillow-10.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91"},+ {file = "pillow-10.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:f5f0c3e969c8f12dd2bb7e0b15d5c468b51e5017e01e2e867335c81903046a22"},+ {file = "pillow-10.4.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:673655af3eadf4df6b5457033f086e90299fdd7a47983a13827acf7459c15d94"},+ {file = "pillow-10.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597"},+ {file = "pillow-10.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29dbdc4207642ea6aad70fbde1a9338753d33fb23ed6956e706936706f52dd80"},+ {file = "pillow-10.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca"},+ {file = "pillow-10.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f5b92f4d70791b4a67157321c4e8225d60b119c5cc9aee8ecf153aace4aad4ef"},+ {file = "pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:86dcb5a1eb778d8b25659d5e4341269e8590ad6b4e8b44d9f4b07f8d136c414a"},+ {file = "pillow-10.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:780c072c2e11c9b2c7ca37f9a2ee8ba66f44367ac3e5c7832afcfe5104fd6d1b"},+ {file = "pillow-10.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:37fb69d905be665f68f28a8bba3c6d3223c8efe1edf14cc4cfa06c241f8c81d9"},+ {file = "pillow-10.4.0-cp312-cp312-win32.whl", hash = "sha256:7dfecdbad5c301d7b5bde160150b4db4c659cee2b69589705b6f8a0c509d9f42"},+ {file = "pillow-10.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a"},+ {file = "pillow-10.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:e553cad5179a66ba15bb18b353a19020e73a7921296a7979c4a2b7f6a5cd57f9"},+ {file = "pillow-10.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8bc1a764ed8c957a2e9cacf97c8b2b053b70307cf2996aafd70e91a082e70df3"},+ {file = "pillow-10.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6209bb41dc692ddfee4942517c19ee81b86c864b626dbfca272ec0f7cff5d9fb"},+ {file = "pillow-10.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bee197b30783295d2eb680b311af15a20a8b24024a19c3a26431ff83eb8d1f70"},+ {file = "pillow-10.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ef61f5dd14c300786318482456481463b9d6b91ebe5ef12f405afbba77ed0be"},+ {file = "pillow-10.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:297e388da6e248c98bc4a02e018966af0c5f92dfacf5a5ca22fa01cb3179bca0"},+ {file = "pillow-10.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e4db64794ccdf6cb83a59d73405f63adbe2a1887012e308828596100a0b2f6cc"},+ {file = "pillow-10.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd2880a07482090a3bcb01f4265f1936a903d70bc740bfcb1fd4e8a2ffe5cf5a"},+ {file = "pillow-10.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b35b21b819ac1dbd1233317adeecd63495f6babf21b7b2512d244ff6c6ce309"},+ {file = "pillow-10.4.0-cp313-cp313-win32.whl", hash = "sha256:551d3fd6e9dc15e4c1eb6fc4ba2b39c0c7933fa113b220057a34f4bb3268a060"},+ {file = "pillow-10.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:030abdbe43ee02e0de642aee345efa443740aa4d828bfe8e2eb11922ea6a21ea"},+ {file = "pillow-10.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:5b001114dd152cfd6b23befeb28d7aee43553e2402c9f159807bf55f33af8a8d"},+ {file = "pillow-10.4.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:8d4d5063501b6dd4024b8ac2f04962d661222d120381272deea52e3fc52d3736"},+ {file = "pillow-10.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7c1ee6f42250df403c5f103cbd2768a28fe1a0ea1f0f03fe151c8741e1469c8b"},+ {file = "pillow-10.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b15e02e9bb4c21e39876698abf233c8c579127986f8207200bc8a8f6bb27acf2"},+ {file = "pillow-10.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a8d4bade9952ea9a77d0c3e49cbd8b2890a399422258a77f357b9cc9be8d680"},+ {file = "pillow-10.4.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:43efea75eb06b95d1631cb784aa40156177bf9dd5b4b03ff38979e048258bc6b"},+ {file = "pillow-10.4.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:950be4d8ba92aca4b2bb0741285a46bfae3ca699ef913ec8416c1b78eadd64cd"},+ {file = "pillow-10.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:d7480af14364494365e89d6fddc510a13e5a2c3584cb19ef65415ca57252fb84"},+ {file = "pillow-10.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:73664fe514b34c8f02452ffb73b7a92c6774e39a647087f83d67f010eb9a0cf0"},+ {file = "pillow-10.4.0-cp38-cp38-win32.whl", hash = "sha256:e88d5e6ad0d026fba7bdab8c3f225a69f063f116462c49892b0149e21b6c0a0e"},+ {file = "pillow-10.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:5161eef006d335e46895297f642341111945e2c1c899eb406882a6c61a4357ab"},+ {file = "pillow-10.4.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:0ae24a547e8b711ccaaf99c9ae3cd975470e1a30caa80a6aaee9a2f19c05701d"},+ {file = "pillow-10.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:298478fe4f77a4408895605f3482b6cc6222c018b2ce565c2b6b9c354ac3229b"},+ {file = "pillow-10.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:134ace6dc392116566980ee7436477d844520a26a4b1bd4053f6f47d096997fd"},+ {file = "pillow-10.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:930044bb7679ab003b14023138b50181899da3f25de50e9dbee23b61b4de2126"},+ {file = "pillow-10.4.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:c76e5786951e72ed3686e122d14c5d7012f16c8303a674d18cdcd6d89557fc5b"},+ {file = "pillow-10.4.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:b2724fdb354a868ddf9a880cb84d102da914e99119211ef7ecbdc613b8c96b3c"},+ {file = "pillow-10.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dbc6ae66518ab3c5847659e9988c3b60dc94ffb48ef9168656e0019a93dbf8a1"},+ {file = "pillow-10.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:06b2f7898047ae93fad74467ec3d28fe84f7831370e3c258afa533f81ef7f3df"},+ {file = "pillow-10.4.0-cp39-cp39-win32.whl", hash = "sha256:7970285ab628a3779aecc35823296a7869f889b8329c16ad5a71e4901a3dc4ef"},+ {file = "pillow-10.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:961a7293b2457b405967af9c77dcaa43cc1a8cd50d23c532e62d48ab6cdd56f5"},+ {file = "pillow-10.4.0-cp39-cp39-win_arm64.whl", hash = "sha256:32cda9e3d601a52baccb2856b8ea1fc213c90b340c542dcef77140dfa3278a9e"},+ {file = "pillow-10.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5b4815f2e65b30f5fbae9dfffa8636d992d49705723fe86a3661806e069352d4"},+ {file = "pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da"},+ {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f4727572e2918acaa9077c919cbbeb73bd2b3ebcfe033b72f858fc9fbef0026"},+ {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e"},+ {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dc3e2db6ba09ffd7d02ae9141cfa0ae23393ee7687248d46a7507b75d610f4f5"},+ {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:02a2be69f9c9b8c1e97cf2713e789d4e398c751ecfd9967c18d0ce304efbf885"},+ {file = "pillow-10.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5"},+ {file = "pillow-10.4.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:a02364621fe369e06200d4a16558e056fe2805d3468350df3aef21e00d26214b"},+ {file = "pillow-10.4.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:1b5dea9831a90e9d0721ec417a80d4cbd7022093ac38a568db2dd78363b00908"},+ {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b885f89040bb8c4a1573566bbb2f44f5c505ef6e74cec7ab9068c900047f04b"},+ {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87dd88ded2e6d74d31e1e0a99a726a6765cda32d00ba72dc37f0651f306daaa8"},+ {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:2db98790afc70118bd0255c2eeb465e9767ecf1f3c25f9a1abb8ffc8cfd1fe0a"},+ {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:f7baece4ce06bade126fb84b8af1c33439a76d8a6fd818970215e0560ca28c27"},+ {file = "pillow-10.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:cfdd747216947628af7b259d274771d84db2268ca062dd5faf373639d00113a3"},+ {file = "pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06"},+]++[package.extras]+docs = ["furo", "olefile", "sphinx (>=7.3)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinxext-opengraph"]fpx = ["olefile"]mic = ["olefile"]tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"]@@ -5964,7 +5986,7 @@ wcwidth = "*"name = "propcache"version = "0.2.1"description = "Accelerated property cache"-optional = false+optional = truepython-versions = ">=3.9"files = [{file = "propcache-0.2.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:6b3f39a85d671436ee3d12c017f8fdea38509e4f25b28eb25877293c98c243f6"},@@ -6203,6 +6225,7 @@ description = "Pure-Python implementation of ASN.1 types and DER/BER/CER codecsoptional = truepython-versions = ">=3.8"files = [+ {file = "pyasn1-0.6.1-py3-none-any.whl", hash = "sha256:0d632f46f2ba09143da3a8afe9e33fb6f92fa2320ab7e886e2d0f7672af84629"},{file = "pyasn1-0.6.1.tar.gz", hash = "sha256:6f580d2bdd84365380830acf45550f2511469f673cb4a5ae3857a3170128b034"},]@@ -6213,6 +6236,7 @@ description = "A collection of ASN.1-based protocols modules"optional = truepython-versions = ">=3.8"files = [+ {file = "pyasn1_modules-0.4.1-py3-none-any.whl", hash = "sha256:49bfa96b45a292b711e986f222502c1c9a5e1f4e568fc30e2574a6c7d07838fd"},{file = "pyasn1_modules-0.4.1.tar.gz", hash = "sha256:c28e2dbf9c06ad61c71a075c7e0f9fd0f1b0bb2d2ad4377f240d33ac2ab60a7c"},]@@ -6283,47 +6307,6 @@ files = [{file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"},]-[[package]]-name = "pycryptodome"-version = "3.21.0"-description = "Cryptographic library for Python"-optional = false-python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7"-files = [- {file = "pycryptodome-3.21.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:dad9bf36eda068e89059d1f07408e397856be9511d7113ea4b586642a429a4fd"},- {file = "pycryptodome-3.21.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:a1752eca64c60852f38bb29e2c86fca30d7672c024128ef5d70cc15868fa10f4"},- {file = "pycryptodome-3.21.0-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:3ba4cc304eac4d4d458f508d4955a88ba25026890e8abff9b60404f76a62c55e"},- {file = "pycryptodome-3.21.0-cp27-cp27m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cb087b8612c8a1a14cf37dd754685be9a8d9869bed2ffaaceb04850a8aeef7e"},- {file = "pycryptodome-3.21.0-cp27-cp27m-musllinux_1_1_aarch64.whl", hash = "sha256:26412b21df30b2861424a6c6d5b1d8ca8107612a4cfa4d0183e71c5d200fb34a"},- {file = "pycryptodome-3.21.0-cp27-cp27m-win32.whl", hash = "sha256:cc2269ab4bce40b027b49663d61d816903a4bd90ad88cb99ed561aadb3888dd3"},- {file = "pycryptodome-3.21.0-cp27-cp27m-win_amd64.whl", hash = "sha256:0fa0a05a6a697ccbf2a12cec3d6d2650b50881899b845fac6e87416f8cb7e87d"},- {file = "pycryptodome-3.21.0-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:6cce52e196a5f1d6797ff7946cdff2038d3b5f0aba4a43cb6bf46b575fd1b5bb"},- {file = "pycryptodome-3.21.0-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:a915597ffccabe902e7090e199a7bf7a381c5506a747d5e9d27ba55197a2c568"},- {file = "pycryptodome-3.21.0-cp27-cp27mu-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a4e74c522d630766b03a836c15bff77cb657c5fdf098abf8b1ada2aebc7d0819"},- {file = "pycryptodome-3.21.0-cp27-cp27mu-musllinux_1_1_aarch64.whl", hash = "sha256:a3804675283f4764a02db05f5191eb8fec2bb6ca34d466167fc78a5f05bbe6b3"},- {file = "pycryptodome-3.21.0-cp36-abi3-macosx_10_9_universal2.whl", hash = "sha256:2480ec2c72438430da9f601ebc12c518c093c13111a5c1644c82cdfc2e50b1e4"},- {file = "pycryptodome-3.21.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:de18954104667f565e2fbb4783b56667f30fb49c4d79b346f52a29cb198d5b6b"},- {file = "pycryptodome-3.21.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2de4b7263a33947ff440412339cb72b28a5a4c769b5c1ca19e33dd6cd1dcec6e"},- {file = "pycryptodome-3.21.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0714206d467fc911042d01ea3a1847c847bc10884cf674c82e12915cfe1649f8"},- {file = "pycryptodome-3.21.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7d85c1b613121ed3dbaa5a97369b3b757909531a959d229406a75b912dd51dd1"},- {file = "pycryptodome-3.21.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:8898a66425a57bcf15e25fc19c12490b87bd939800f39a03ea2de2aea5e3611a"},- {file = "pycryptodome-3.21.0-cp36-abi3-musllinux_1_2_i686.whl", hash = "sha256:932c905b71a56474bff8a9c014030bc3c882cee696b448af920399f730a650c2"},- {file = "pycryptodome-3.21.0-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:18caa8cfbc676eaaf28613637a89980ad2fd96e00c564135bf90bc3f0b34dd93"},- {file = "pycryptodome-3.21.0-cp36-abi3-win32.whl", hash = "sha256:280b67d20e33bb63171d55b1067f61fbd932e0b1ad976b3a184303a3dad22764"},- {file = "pycryptodome-3.21.0-cp36-abi3-win_amd64.whl", hash = "sha256:b7aa25fc0baa5b1d95b7633af4f5f1838467f1815442b22487426f94e0d66c53"},- {file = "pycryptodome-3.21.0-pp27-pypy_73-manylinux2010_x86_64.whl", hash = "sha256:2cb635b67011bc147c257e61ce864879ffe6d03342dc74b6045059dfbdedafca"},- {file = "pycryptodome-3.21.0-pp27-pypy_73-win32.whl", hash = "sha256:4c26a2f0dc15f81ea3afa3b0c87b87e501f235d332b7f27e2225ecb80c0b1cdd"},- {file = "pycryptodome-3.21.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:d5ebe0763c982f069d3877832254f64974139f4f9655058452603ff559c482e8"},- {file = "pycryptodome-3.21.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ee86cbde706be13f2dec5a42b52b1c1d1cbb90c8e405c68d0755134735c8dc6"},- {file = "pycryptodome-3.21.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0fd54003ec3ce4e0f16c484a10bc5d8b9bd77fa662a12b85779a2d2d85d67ee0"},- {file = "pycryptodome-3.21.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5dfafca172933506773482b0e18f0cd766fd3920bd03ec85a283df90d8a17bc6"},- {file = "pycryptodome-3.21.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:590ef0898a4b0a15485b05210b4a1c9de8806d3ad3d47f74ab1dc07c67a6827f"},- {file = "pycryptodome-3.21.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f35e442630bc4bc2e1878482d6f59ea22e280d7121d7adeaedba58c23ab6386b"},- {file = "pycryptodome-3.21.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ff99f952db3db2fbe98a0b355175f93ec334ba3d01bbde25ad3a5a33abc02b58"},- {file = "pycryptodome-3.21.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:8acd7d34af70ee63f9a849f957558e49a98f8f1634f86a59d2be62bb8e93f71c"},- {file = "pycryptodome-3.21.0.tar.gz", hash = "sha256:f7787e0d469bdae763b876174cf2e6c0f7be79808af26b1da96f1a64bcf47297"},-]-[[package]]name = "pydantic"version = "2.9.2"@@ -6570,6 +6553,7 @@ python-versions = ">=3.9"files = [{file = "pymupdf-1.25.1-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:793f9f6d51029e97851c711b3f6d9fe912313d95a306fbe8b1866f301d0e2bd3"},{file = "pymupdf-1.25.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:15e6f4013ad0a029a2221920f9d2081f56dc43259dabfdf5cad7fbf1cee4b5a7"},+ {file = "pymupdf-1.25.1-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a39afbd80381f43e30d6eb2ec4613f465f507ac2b76070abdd2da8724f32ef36"},{file = "pymupdf-1.25.1-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b63f8e9e65b0bda48f9217efd4d2a8c6d7a739dd28baf460c1ae78439b9af489"},{file = "pymupdf-1.25.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a687bd387589e30abd810a78a23341f57f43fa16a4d8d8c0b870bb6d89607343"},{file = "pymupdf-1.25.1-cp39-abi3-win32.whl", hash = "sha256:fc7dbc1aa9e298a4c81084e389c9623c26fcaa232c71efaa073af150069e2221"},@@ -6820,13 +6804,13 @@ testing = ["fields", "hunter", "process-tests", "pytest-xdist", "six", "virtuale[[package]]name = "python-dateutil"-version = "2.9.0.post0"+version = "2.8.2"description = "Extensions to the standard Python datetime module"optional = falsepython-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7"files = [- {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"},- {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"},+ {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"},+ {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"},][package.dependencies]@@ -7702,40 +7686,30 @@ files = [{file = "ruamel.yaml.clib-0.2.12-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:a606ef75a60ecf3d924613892cc603b154178ee25abb3055db5062da811fd969"},{file = "ruamel.yaml.clib-0.2.12-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd5415dded15c3822597455bc02bcd66e81ef8b7a48cb71a33628fc9fdde39df"},{file = "ruamel.yaml.clib-0.2.12-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f66efbc1caa63c088dead1c4170d148eabc9b80d95fb75b6c92ac0aad2437d76"},- {file = "ruamel.yaml.clib-0.2.12-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:22353049ba4181685023b25b5b51a574bce33e7f51c759371a7422dcae5402a6"},- {file = "ruamel.yaml.clib-0.2.12-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:932205970b9f9991b34f55136be327501903f7c66830e9760a8ffb15b07f05cd"},{file = "ruamel.yaml.clib-0.2.12-cp310-cp310-win32.whl", hash = "sha256:3eac5a91891ceb88138c113f9db04f3cebdae277f5d44eaa3651a4f573e6a5da"},{file = "ruamel.yaml.clib-0.2.12-cp310-cp310-win_amd64.whl", hash = "sha256:ab007f2f5a87bd08ab1499bdf96f3d5c6ad4dcfa364884cb4549aa0154b13a28"},{file = "ruamel.yaml.clib-0.2.12-cp311-cp311-macosx_13_0_arm64.whl", hash = "sha256:4a6679521a58256a90b0d89e03992c15144c5f3858f40d7c18886023d7943db6"},{file = "ruamel.yaml.clib-0.2.12-cp311-cp311-manylinux2014_aarch64.whl", hash = "sha256:d84318609196d6bd6da0edfa25cedfbabd8dbde5140a0a23af29ad4b8f91fb1e"},{file = "ruamel.yaml.clib-0.2.12-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb43a269eb827806502c7c8efb7ae7e9e9d0573257a46e8e952f4d4caba4f31e"},{file = "ruamel.yaml.clib-0.2.12-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:811ea1594b8a0fb466172c384267a4e5e367298af6b228931f273b111f17ef52"},- {file = "ruamel.yaml.clib-0.2.12-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:cf12567a7b565cbf65d438dec6cfbe2917d3c1bdddfce84a9930b7d35ea59642"},- {file = "ruamel.yaml.clib-0.2.12-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7dd5adc8b930b12c8fc5b99e2d535a09889941aa0d0bd06f4749e9a9397c71d2"},{file = "ruamel.yaml.clib-0.2.12-cp311-cp311-win32.whl", hash = "sha256:bd0a08f0bab19093c54e18a14a10b4322e1eacc5217056f3c063bd2f59853ce4"},{file = "ruamel.yaml.clib-0.2.12-cp311-cp311-win_amd64.whl", hash = "sha256:a274fb2cb086c7a3dea4322ec27f4cb5cc4b6298adb583ab0e211a4682f241eb"},{file = "ruamel.yaml.clib-0.2.12-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:20b0f8dc160ba83b6dcc0e256846e1a02d044e13f7ea74a3d1d56ede4e48c632"},{file = "ruamel.yaml.clib-0.2.12-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:943f32bc9dedb3abff9879edc134901df92cfce2c3d5c9348f172f62eb2d771d"},{file = "ruamel.yaml.clib-0.2.12-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95c3829bb364fdb8e0332c9931ecf57d9be3519241323c5274bd82f709cebc0c"},{file = "ruamel.yaml.clib-0.2.12-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:749c16fcc4a2b09f28843cda5a193e0283e47454b63ec4b81eaa2242f50e4ccd"},- {file = "ruamel.yaml.clib-0.2.12-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bf165fef1f223beae7333275156ab2022cffe255dcc51c27f066b4370da81e31"},- {file = "ruamel.yaml.clib-0.2.12-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:32621c177bbf782ca5a18ba4d7af0f1082a3f6e517ac2a18b3974d4edf349680"},{file = "ruamel.yaml.clib-0.2.12-cp312-cp312-win32.whl", hash = "sha256:e8c4ebfcfd57177b572e2040777b8abc537cdef58a2120e830124946aa9b42c5"},{file = "ruamel.yaml.clib-0.2.12-cp312-cp312-win_amd64.whl", hash = "sha256:0467c5965282c62203273b838ae77c0d29d7638c8a4e3a1c8bdd3602c10904e4"},{file = "ruamel.yaml.clib-0.2.12-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:4c8c5d82f50bb53986a5e02d1b3092b03622c02c2eb78e29bec33fd9593bae1a"},{file = "ruamel.yaml.clib-0.2.12-cp313-cp313-manylinux2014_aarch64.whl", hash = "sha256:e7e3736715fbf53e9be2a79eb4db68e4ed857017344d697e8b9749444ae57475"},{file = "ruamel.yaml.clib-0.2.12-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b7e75b4965e1d4690e93021adfcecccbca7d61c7bddd8e22406ef2ff20d74ef"},{file = "ruamel.yaml.clib-0.2.12-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:96777d473c05ee3e5e3c3e999f5d23c6f4ec5b0c38c098b3a5229085f74236c6"},- {file = "ruamel.yaml.clib-0.2.12-cp313-cp313-musllinux_1_1_i686.whl", hash = "sha256:3bc2a80e6420ca8b7d3590791e2dfc709c88ab9152c00eeb511c9875ce5778bf"},- {file = "ruamel.yaml.clib-0.2.12-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:e188d2699864c11c36cdfdada94d781fd5d6b0071cd9c427bceb08ad3d7c70e1"},{file = "ruamel.yaml.clib-0.2.12-cp313-cp313-win32.whl", hash = "sha256:6442cb36270b3afb1b4951f060eccca1ce49f3d087ca1ca4563a6eb479cb3de6"},{file = "ruamel.yaml.clib-0.2.12-cp313-cp313-win_amd64.whl", hash = "sha256:e5b8daf27af0b90da7bb903a876477a9e6d7270be6146906b276605997c7e9a3"},{file = "ruamel.yaml.clib-0.2.12-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:fc4b630cd3fa2cf7fce38afa91d7cfe844a9f75d7f0f36393fa98815e911d987"},{file = "ruamel.yaml.clib-0.2.12-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:bc5f1e1c28e966d61d2519f2a3d451ba989f9ea0f2307de7bc45baa526de9e45"},{file = "ruamel.yaml.clib-0.2.12-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5a0e060aace4c24dcaf71023bbd7d42674e3b230f7e7b97317baf1e953e5b519"},{file = "ruamel.yaml.clib-0.2.12-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e2f1c3765db32be59d18ab3953f43ab62a761327aafc1594a2a1fbe038b8b8a7"},- {file = "ruamel.yaml.clib-0.2.12-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:d85252669dc32f98ebcd5d36768f5d4faeaeaa2d655ac0473be490ecdae3c285"},- {file = "ruamel.yaml.clib-0.2.12-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:e143ada795c341b56de9418c58d028989093ee611aa27ffb9b7f609c00d813ed"},{file = "ruamel.yaml.clib-0.2.12-cp39-cp39-win32.whl", hash = "sha256:beffaed67936fbbeffd10966a4eb53c402fafd3d6833770516bf7314bc6ffa12"},{file = "ruamel.yaml.clib-0.2.12-cp39-cp39-win_amd64.whl", hash = "sha256:040ae85536960525ea62868b642bdb0c2cc6021c9f9d507810c0c604e66f5a7b"},{file = "ruamel.yaml.clib-0.2.12.tar.gz", hash = "sha256:6c8fbb13ec503f99a91901ab46e0b07ae7941cd527393187039aec586fdfd36f"},@@ -8051,6 +8025,21 @@ typing_extensions = ">=4.9,<5.0"urllib3 = {version = ">=1.26,<3", extras = ["socks"]}websocket-client = ">=1.8,<2.0"+[[package]]+name = "semantic-version"+version = "2.10.0"+description = "A library implementing the 'SemVer' scheme."+optional = false+python-versions = ">=2.7"+files = [+ {file = "semantic_version-2.10.0-py2.py3-none-any.whl", hash = "sha256:de78a3b8e0feda74cabc54aab2da702113e33ac9d9eb9d2389bcf1f58b7d9177"},+ {file = "semantic_version-2.10.0.tar.gz", hash = "sha256:bdabb6d336998cbb378d4b9db3a4b56a1e3235701dc05ea2690d9a997ed5041c"},+]++[package.extras]+dev = ["Django (>=1.11)", "check-manifest", "colorama (<=0.4.1)", "coverage", "flake8", "nose2", "readme-renderer (<25.0)", "tox", "wheel", "zest.releaser[recommended]"]+doc = ["Sphinx", "sphinx-rtd-theme"]+[[package]]name = "sentence-transformers"version = "3.3.1"@@ -9244,6 +9233,80 @@ torchhub = ["filelock", "huggingface-hub (>=0.24.0,<1.0)", "importlib-metadata",video = ["av (==9.2.0)"]vision = ["Pillow (>=10.0.1,<=15.0)"]+[[package]]+name = "tree-sitter"+version = "0.23.2"+description = "Python bindings to the Tree-sitter parsing library"+optional = false+python-versions = ">=3.9"+files = [+ {file = "tree-sitter-0.23.2.tar.gz", hash = "sha256:66bae8dd47f1fed7bdef816115146d3a41c39b5c482d7bad36d9ba1def088450"},+ {file = "tree_sitter-0.23.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3a937f5d8727bc1c74c4bf2a9d1c25ace049e8628273016ad0d45914ae904e10"},+ {file = "tree_sitter-0.23.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2c7eae7fe2af215645a38660d2d57d257a4c461fe3ec827cca99a79478284e80"},+ {file = "tree_sitter-0.23.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3a71d607595270b6870eaf778a1032d146b2aa79bfcfa60f57a82a7b7584a4c7"},+ {file = "tree_sitter-0.23.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fe9b9ea7a0aa23b52fd97354da95d1b2580065bc12a4ac868f9164a127211d6"},+ {file = "tree_sitter-0.23.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d74d00a8021719eae14d10d1b1e28649e15d8b958c01c2b2c3dad7a2ebc4dbae"},+ {file = "tree_sitter-0.23.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:6de18d8d8a7f67ab71f472d1fcb01cc506e080cbb5e13d52929e4b6fdce6bbee"},+ {file = "tree_sitter-0.23.2-cp310-cp310-win_amd64.whl", hash = "sha256:12b60dca70d2282af942b650a6d781be487485454668c7c956338a367b98cdee"},+ {file = "tree_sitter-0.23.2-cp310-cp310-win_arm64.whl", hash = "sha256:3346a4dd0447a42aabb863443b0fd8c92b909baf40ed2344fae4b94b625d5955"},+ {file = "tree_sitter-0.23.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:91fda41d4f8824335cc43c64e2c37d8089c8c563bd3900a512d2852d075af719"},+ {file = "tree_sitter-0.23.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:92b2b489d5ce54b41f94c6f23fbaf592bd6e84dc2877048fd1cb060480fa53f7"},+ {file = "tree_sitter-0.23.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:64859bd4aa1567d0d6016a811b2b49c59d4a4427d096e3d8c84b2521455f62b7"},+ {file = "tree_sitter-0.23.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:614590611636044e071d3a0b748046d52676dbda3bc9fa431216231e11dd98f7"},+ {file = "tree_sitter-0.23.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:08466953c78ae57be61057188fb88c89791b0a562856010228e0ccf60e2ac453"},+ {file = "tree_sitter-0.23.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8a33f03a562de91f7fd05eefcedd8994a06cd44c62f7aabace811ad82bc11cbd"},+ {file = "tree_sitter-0.23.2-cp311-cp311-win_amd64.whl", hash = "sha256:03b70296b569ef64f7b92b42ca5da9bf86d81bee2afd480bea35092687f51dae"},+ {file = "tree_sitter-0.23.2-cp311-cp311-win_arm64.whl", hash = "sha256:7cb4bb953ea7c0b50eeafc4454783e030357179d2a93c3dd5ebed2da5588ddd0"},+ {file = "tree_sitter-0.23.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a014498b6a9e6003fae8c6eb72f5927d62da9dcb72b28b3ce8cd15c6ff6a6572"},+ {file = "tree_sitter-0.23.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:04f8699b131d4bcbe3805c37e4ef3d159ee9a82a0e700587625623999ba0ea53"},+ {file = "tree_sitter-0.23.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4471577df285059c71686ecb208bc50fb472099b38dcc8e849b0e86652891e87"},+ {file = "tree_sitter-0.23.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f342c925290dd4e20ecd5787ef7ae8749981597ab364783a1eb73173efe65226"},+ {file = "tree_sitter-0.23.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a4e9e53d07dd076bede72e4f7d3a0173d7b9ad6576572dd86da008a740a9bb22"},+ {file = "tree_sitter-0.23.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8caebe65bc358759dac2500d8f8feed3aed939c4ade9a684a1783fe07bc7d5db"},+ {file = "tree_sitter-0.23.2-cp312-cp312-win_amd64.whl", hash = "sha256:fc5a72eb50d43485000dbbb309acb350467b7467e66dc747c6bb82ce63041582"},+ {file = "tree_sitter-0.23.2-cp312-cp312-win_arm64.whl", hash = "sha256:a0320eb6c7993359c5f7b371d22719ccd273f440d41cf1bd65dac5e9587f2046"},+ {file = "tree_sitter-0.23.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:eff630dddee7ba05accb439b17e559e15ce13f057297007c246237ceb6306332"},+ {file = "tree_sitter-0.23.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4780ba8f3894f2dea869fad2995c2aceab3fd5ab9e6a27c45475d2acd7f7e84e"},+ {file = "tree_sitter-0.23.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f0b609460b8e3e256361fb12e94fae5b728cb835b16f0f9d590b5aadbf9d109b"},+ {file = "tree_sitter-0.23.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78d070d8eaeaeb36cf535f55e5578fddbfc3bf53c1980f58bf1a99d57466b3b5"},+ {file = "tree_sitter-0.23.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:878580b2ad5054c410ba3418edca4d34c81cc26706114d8f5b5541688bc2d785"},+ {file = "tree_sitter-0.23.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:29224bdc2a3b9af535b7725e249d3ee291b2e90708e82832e73acc175e40dc48"},+ {file = "tree_sitter-0.23.2-cp313-cp313-win_amd64.whl", hash = "sha256:c58d89348162fbc3aea1fe6511a66ee189fc0e4e4bbe937026f29e4ecef17763"},+ {file = "tree_sitter-0.23.2-cp313-cp313-win_arm64.whl", hash = "sha256:0ff2037be5edab7801de3f6a721b9cf010853f612e2008ee454e0e0badb225a6"},+ {file = "tree_sitter-0.23.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a5db8e585205faef8bf219da77d8993e2ef04d08eda2e3c8ad7e4df8297ee344"},+ {file = "tree_sitter-0.23.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9dbd110a30cf28be5da734ae4cd0e9031768228dbf6a79f2973962aa51de4ec7"},+ {file = "tree_sitter-0.23.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:569514b9a996a0fd458b3a891c46ca125298be0c03cf82f2b6f0c13d5d8f25dc"},+ {file = "tree_sitter-0.23.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a357ed98a74e47787b812df99a74a2c35c0fe11e55c2095cc01d1cad144ef552"},+ {file = "tree_sitter-0.23.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:c2dfb8e8f760f4cc67888d03ef9e2dbd3353245f67f5efba375c2a14d944ac0e"},+ {file = "tree_sitter-0.23.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:3ead958df87a21d706903987e665e9e0e5df7b2c5021ff69ea349826840adc6a"},+ {file = "tree_sitter-0.23.2-cp39-cp39-win_amd64.whl", hash = "sha256:611cae16be332213c0e6ece72c0bfca202e30ff320a8b309b1526c6cb79ee4ba"},+ {file = "tree_sitter-0.23.2-cp39-cp39-win_arm64.whl", hash = "sha256:b848e0fdd522fbb8888cdb4f4d93f8fad97ae10d70c122fb922e51363c7febcd"},+]++[package.extras]+docs = ["sphinx (>=7.3,<8.0)", "sphinx-book-theme"]+tests = ["tree-sitter-html (>=0.23.0)", "tree-sitter-javascript (>=0.23.0)", "tree-sitter-json (>=0.23.0)", "tree-sitter-python (>=0.23.0)", "tree-sitter-rust (>=0.23.0)"]++[[package]]+name = "tree-sitter-python"+version = "0.23.6"+description = "Python grammar for tree-sitter"+optional = false+python-versions = ">=3.9"+files = [+ {file = "tree_sitter_python-0.23.6-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:28fbec8f74eeb2b30292d97715e60fac9ccf8a8091ce19b9d93e9b580ed280fb"},+ {file = "tree_sitter_python-0.23.6-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:680b710051b144fedf61c95197db0094f2245e82551bf7f0c501356333571f7a"},+ {file = "tree_sitter_python-0.23.6-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8a9dcef55507b6567207e8ee0a6b053d0688019b47ff7f26edc1764b7f4dc0a4"},+ {file = "tree_sitter_python-0.23.6-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:29dacdc0cd2f64e55e61d96c6906533ebb2791972bec988450c46cce60092f5d"},+ {file = "tree_sitter_python-0.23.6-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:7e048733c36f564b379831689006801feb267d8194f9e793fbb395ef1723335d"},+ {file = "tree_sitter_python-0.23.6-cp39-abi3-win_amd64.whl", hash = "sha256:a24027248399fb41594b696f929f9956828ae7cc85596d9f775e6c239cd0c2be"},+ {file = "tree_sitter_python-0.23.6-cp39-abi3-win_arm64.whl", hash = "sha256:71334371bd73d5fe080aed39fbff49ed8efb9506edebe16795b0c7567ed6a272"},+ {file = "tree_sitter_python-0.23.6.tar.gz", hash = "sha256:354bfa0a2f9217431764a631516f85173e9711af2c13dbd796a8815acfe505d9"},+]++[package.extras]+core = ["tree-sitter (>=0.22,<1.0)"]+[[package]]name = "trio"version = "0.28.0"@@ -9470,20 +9533,6 @@ files = [{file = "tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc"},]-[[package]]-name = "uc-micro-py"-version = "1.0.3"-description = "Micro subset of unicode data files for linkify-it-py projects."-optional = false-python-versions = ">=3.7"-files = [- {file = "uc-micro-py-1.0.3.tar.gz", hash = "sha256:d321b92cff673ec58027c04015fcaa8bb1e005478643ff4a500882eaab88c48a"},- {file = "uc_micro_py-1.0.3-py3-none-any.whl", hash = "sha256:db1dffff340817673d7b466ec86114a9dc0e9d4d9b5ba229d9d60e5c12600cd5"},-]--[package.extras]-test = ["coverage", "pytest", "pytest-cov"]-[[package]]name = "ujson"version = "5.10.0"@@ -9646,17 +9695,16 @@ xlsx = ["networkx", "openpyxl", "pandas", "xlrd"][[package]]name = "unstructured-client"-version = "0.28.1"+version = "0.27.0"description = "Python Client SDK for Unstructured API"optional = truepython-versions = "<4.0,>=3.8"files = [- {file = "unstructured_client-0.28.1-py3-none-any.whl", hash = "sha256:0112688908f544681a67abf314e0d2023dfa120c8e5d9fa6d31390b914a06d72"},- {file = "unstructured_client-0.28.1.tar.gz", hash = "sha256:aac11fe5dd6b8dfdbc15aad3205fe791a3834dac29bb9f499fd515643554f709"},+ {file = "unstructured_client-0.27.0-py3-none-any.whl", hash = "sha256:e6413df1e2a4de36b78701369da83456e3a0b7b7cb9d1995c04ef55a1c9a8def"},+ {file = "unstructured_client-0.27.0.tar.gz", hash = "sha256:6eac20457205d61544d0cb8572a113d83ac61f8dda6fcec20a0a0c6259f256b6"},][package.dependencies]-aiofiles = ">=24.1.0"cryptography = ">=3.1"eval-type-backport = ">=0.2.0,<0.3.0"httpx = ">=0.27.0"@@ -9664,7 +9712,7 @@ jsonpath-python = ">=1.0.6,<2.0.0"nest-asyncio = ">=1.6.0"pydantic = ">=2.9.2,<2.10.0"pypdf = ">=4.0"-python-dateutil = ">=2.8.2,<3.0.0"+python-dateutil = "2.8.2"requests-toolbelt = ">=1.0.0"typing-inspect = ">=0.9.0,<0.10.0"@@ -9837,80 +9885,81 @@ test = ["websockets"][[package]]name = "websockets"-version = "14.1"+version = "11.0.3"description = "An implementation of the WebSocket Protocol (RFC 6455 & 7692)"optional = false-python-versions = ">=3.9"+python-versions = ">=3.7"files = [- {file = "websockets-14.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a0adf84bc2e7c86e8a202537b4fd50e6f7f0e4a6b6bf64d7ccb96c4cd3330b29"},- {file = "websockets-14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:90b5d9dfbb6d07a84ed3e696012610b6da074d97453bd01e0e30744b472c8179"},- {file = "websockets-14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2177ee3901075167f01c5e335a6685e71b162a54a89a56001f1c3e9e3d2ad250"},- {file = "websockets-14.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f14a96a0034a27f9d47fd9788913924c89612225878f8078bb9d55f859272b0"},- {file = "websockets-14.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1f874ba705deea77bcf64a9da42c1f5fc2466d8f14daf410bc7d4ceae0a9fcb0"},- {file = "websockets-14.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9607b9a442392e690a57909c362811184ea429585a71061cd5d3c2b98065c199"},- {file = "websockets-14.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bea45f19b7ca000380fbd4e02552be86343080120d074b87f25593ce1700ad58"},- {file = "websockets-14.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:219c8187b3ceeadbf2afcf0f25a4918d02da7b944d703b97d12fb01510869078"},- {file = "websockets-14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ad2ab2547761d79926effe63de21479dfaf29834c50f98c4bf5b5480b5838434"},- {file = "websockets-14.1-cp310-cp310-win32.whl", hash = "sha256:1288369a6a84e81b90da5dbed48610cd7e5d60af62df9851ed1d1d23a9069f10"},- {file = "websockets-14.1-cp310-cp310-win_amd64.whl", hash = "sha256:e0744623852f1497d825a49a99bfbec9bea4f3f946df6eb9d8a2f0c37a2fec2e"},- {file = "websockets-14.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:449d77d636f8d9c17952628cc7e3b8faf6e92a17ec581ec0c0256300717e1512"},- {file = "websockets-14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a35f704be14768cea9790d921c2c1cc4fc52700410b1c10948511039be824aac"},- {file = "websockets-14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b1f3628a0510bd58968c0f60447e7a692933589b791a6b572fcef374053ca280"},- {file = "websockets-14.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3c3deac3748ec73ef24fc7be0b68220d14d47d6647d2f85b2771cb35ea847aa1"},- {file = "websockets-14.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7048eb4415d46368ef29d32133134c513f507fff7d953c18c91104738a68c3b3"},- {file = "websockets-14.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6cf0ad281c979306a6a34242b371e90e891bce504509fb6bb5246bbbf31e7b6"},- {file = "websockets-14.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cc1fc87428c1d18b643479caa7b15db7d544652e5bf610513d4a3478dbe823d0"},- {file = "websockets-14.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f95ba34d71e2fa0c5d225bde3b3bdb152e957150100e75c86bc7f3964c450d89"},- {file = "websockets-14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9481a6de29105d73cf4515f2bef8eb71e17ac184c19d0b9918a3701c6c9c4f23"},- {file = "websockets-14.1-cp311-cp311-win32.whl", hash = "sha256:368a05465f49c5949e27afd6fbe0a77ce53082185bbb2ac096a3a8afaf4de52e"},- {file = "websockets-14.1-cp311-cp311-win_amd64.whl", hash = "sha256:6d24fc337fc055c9e83414c94e1ee0dee902a486d19d2a7f0929e49d7d604b09"},- {file = "websockets-14.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed907449fe5e021933e46a3e65d651f641975a768d0649fee59f10c2985529ed"},- {file = "websockets-14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:87e31011b5c14a33b29f17eb48932e63e1dcd3fa31d72209848652310d3d1f0d"},- {file = "websockets-14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bc6ccf7d54c02ae47a48ddf9414c54d48af9c01076a2e1023e3b486b6e72c707"},- {file = "websockets-14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9777564c0a72a1d457f0848977a1cbe15cfa75fa2f67ce267441e465717dcf1a"},- {file = "websockets-14.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a655bde548ca98f55b43711b0ceefd2a88a71af6350b0c168aa77562104f3f45"},- {file = "websockets-14.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a3dfff83ca578cada2d19e665e9c8368e1598d4e787422a460ec70e531dbdd58"},- {file = "websockets-14.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6a6c9bcf7cdc0fd41cc7b7944447982e8acfd9f0d560ea6d6845428ed0562058"},- {file = "websockets-14.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:4b6caec8576e760f2c7dd878ba817653144d5f369200b6ddf9771d64385b84d4"},- {file = "websockets-14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eb6d38971c800ff02e4a6afd791bbe3b923a9a57ca9aeab7314c21c84bf9ff05"},- {file = "websockets-14.1-cp312-cp312-win32.whl", hash = "sha256:1d045cbe1358d76b24d5e20e7b1878efe578d9897a25c24e6006eef788c0fdf0"},- {file = "websockets-14.1-cp312-cp312-win_amd64.whl", hash = "sha256:90f4c7a069c733d95c308380aae314f2cb45bd8a904fb03eb36d1a4983a4993f"},- {file = "websockets-14.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3630b670d5057cd9e08b9c4dab6493670e8e762a24c2c94ef312783870736ab9"},- {file = "websockets-14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36ebd71db3b89e1f7b1a5deaa341a654852c3518ea7a8ddfdf69cc66acc2db1b"},- {file = "websockets-14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5b918d288958dc3fa1c5a0b9aa3256cb2b2b84c54407f4813c45d52267600cd3"},- {file = "websockets-14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:00fe5da3f037041da1ee0cf8e308374e236883f9842c7c465aa65098b1c9af59"},- {file = "websockets-14.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8149a0f5a72ca36720981418eeffeb5c2729ea55fa179091c81a0910a114a5d2"},- {file = "websockets-14.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77569d19a13015e840b81550922056acabc25e3f52782625bc6843cfa034e1da"},- {file = "websockets-14.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:cf5201a04550136ef870aa60ad3d29d2a59e452a7f96b94193bee6d73b8ad9a9"},- {file = "websockets-14.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:88cf9163ef674b5be5736a584c999e98daf3aabac6e536e43286eb74c126b9c7"},- {file = "websockets-14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:836bef7ae338a072e9d1863502026f01b14027250a4545672673057997d5c05a"},- {file = "websockets-14.1-cp313-cp313-win32.whl", hash = "sha256:0d4290d559d68288da9f444089fd82490c8d2744309113fc26e2da6e48b65da6"},- {file = "websockets-14.1-cp313-cp313-win_amd64.whl", hash = "sha256:8621a07991add373c3c5c2cf89e1d277e49dc82ed72c75e3afc74bd0acc446f0"},- {file = "websockets-14.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:01bb2d4f0a6d04538d3c5dfd27c0643269656c28045a53439cbf1c004f90897a"},- {file = "websockets-14.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:414ffe86f4d6f434a8c3b7913655a1a5383b617f9bf38720e7c0799fac3ab1c6"},- {file = "websockets-14.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:8fda642151d5affdee8a430bd85496f2e2517be3a2b9d2484d633d5712b15c56"},- {file = "websockets-14.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cd7c11968bc3860d5c78577f0dbc535257ccec41750675d58d8dc66aa47fe52c"},- {file = "websockets-14.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a032855dc7db987dff813583d04f4950d14326665d7e714d584560b140ae6b8b"},- {file = "websockets-14.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b7e7ea2f782408c32d86b87a0d2c1fd8871b0399dd762364c731d86c86069a78"},- {file = "websockets-14.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:39450e6215f7d9f6f7bc2a6da21d79374729f5d052333da4d5825af8a97e6735"},- {file = "websockets-14.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:ceada5be22fa5a5a4cdeec74e761c2ee7db287208f54c718f2df4b7e200b8d4a"},- {file = "websockets-14.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:3fc753451d471cff90b8f467a1fc0ae64031cf2d81b7b34e1811b7e2691bc4bc"},- {file = "websockets-14.1-cp39-cp39-win32.whl", hash = "sha256:14839f54786987ccd9d03ed7f334baec0f02272e7ec4f6e9d427ff584aeea8b4"},- {file = "websockets-14.1-cp39-cp39-win_amd64.whl", hash = "sha256:d9fd19ecc3a4d5ae82ddbfb30962cf6d874ff943e56e0c81f5169be2fda62979"},- {file = "websockets-14.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:e5dc25a9dbd1a7f61eca4b7cb04e74ae4b963d658f9e4f9aad9cd00b688692c8"},- {file = "websockets-14.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:04a97aca96ca2acedf0d1f332c861c5a4486fdcba7bcef35873820f940c4231e"},- {file = "websockets-14.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:df174ece723b228d3e8734a6f2a6febbd413ddec39b3dc592f5a4aa0aff28098"},- {file = "websockets-14.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:034feb9f4286476f273b9a245fb15f02c34d9586a5bc936aff108c3ba1b21beb"},- {file = "websockets-14.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:660c308dabd2b380807ab64b62985eaccf923a78ebc572bd485375b9ca2b7dc7"},- {file = "websockets-14.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5a42d3ecbb2db5080fc578314439b1d79eef71d323dc661aa616fb492436af5d"},- {file = "websockets-14.1-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ddaa4a390af911da6f680be8be4ff5aaf31c4c834c1a9147bc21cbcbca2d4370"},- {file = "websockets-14.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:a4c805c6034206143fbabd2d259ec5e757f8b29d0a2f0bf3d2fe5d1f60147a4a"},- {file = "websockets-14.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:205f672a6c2c671a86d33f6d47c9b35781a998728d2c7c2a3e1cf3333fcb62b7"},- {file = "websockets-14.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5ef440054124728cc49b01c33469de06755e5a7a4e83ef61934ad95fc327fbb0"},- {file = "websockets-14.1-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7591d6f440af7f73c4bd9404f3772bfee064e639d2b6cc8c94076e71b2471c1"},- {file = "websockets-14.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:25225cc79cfebc95ba1d24cd3ab86aaa35bcd315d12fa4358939bd55e9bd74a5"},- {file = "websockets-14.1-py3-none-any.whl", hash = "sha256:4d4fc827a20abe6d544a119896f6b78ee13fe81cbfef416f3f2ddf09a03f0e2e"},- {file = "websockets-14.1.tar.gz", hash = "sha256:398b10c77d471c0aab20a845e7a60076b6390bfdaac7a6d2edb0d2c59d75e8d8"},+ {file = "websockets-11.0.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3ccc8a0c387629aec40f2fc9fdcb4b9d5431954f934da3eaf16cdc94f67dbfac"},+ {file = "websockets-11.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d67ac60a307f760c6e65dad586f556dde58e683fab03323221a4e530ead6f74d"},+ {file = "websockets-11.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:84d27a4832cc1a0ee07cdcf2b0629a8a72db73f4cf6de6f0904f6661227f256f"},+ {file = "websockets-11.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ffd7dcaf744f25f82190856bc26ed81721508fc5cbf2a330751e135ff1283564"},+ {file = "websockets-11.0.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7622a89d696fc87af8e8d280d9b421db5133ef5b29d3f7a1ce9f1a7bf7fcfa11"},+ {file = "websockets-11.0.3-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bceab846bac555aff6427d060f2fcfff71042dba6f5fca7dc4f75cac815e57ca"},+ {file = "websockets-11.0.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:54c6e5b3d3a8936a4ab6870d46bdd6ec500ad62bde9e44462c32d18f1e9a8e54"},+ {file = "websockets-11.0.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:41f696ba95cd92dc047e46b41b26dd24518384749ed0d99bea0a941ca87404c4"},+ {file = "websockets-11.0.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:86d2a77fd490ae3ff6fae1c6ceaecad063d3cc2320b44377efdde79880e11526"},+ {file = "websockets-11.0.3-cp310-cp310-win32.whl", hash = "sha256:2d903ad4419f5b472de90cd2d40384573b25da71e33519a67797de17ef849b69"},+ {file = "websockets-11.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:1d2256283fa4b7f4c7d7d3e84dc2ece74d341bce57d5b9bf385df109c2a1a82f"},+ {file = "websockets-11.0.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:e848f46a58b9fcf3d06061d17be388caf70ea5b8cc3466251963c8345e13f7eb"},+ {file = "websockets-11.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:aa5003845cdd21ac0dc6c9bf661c5beddd01116f6eb9eb3c8e272353d45b3288"},+ {file = "websockets-11.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b58cbf0697721120866820b89f93659abc31c1e876bf20d0b3d03cef14faf84d"},+ {file = "websockets-11.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:660e2d9068d2bedc0912af508f30bbeb505bbbf9774d98def45f68278cea20d3"},+ {file = "websockets-11.0.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c1f0524f203e3bd35149f12157438f406eff2e4fb30f71221c8a5eceb3617b6b"},+ {file = "websockets-11.0.3-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:def07915168ac8f7853812cc593c71185a16216e9e4fa886358a17ed0fd9fcf6"},+ {file = "websockets-11.0.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:b30c6590146e53149f04e85a6e4fcae068df4289e31e4aee1fdf56a0dead8f97"},+ {file = "websockets-11.0.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:619d9f06372b3a42bc29d0cd0354c9bb9fb39c2cbc1a9c5025b4538738dbffaf"},+ {file = "websockets-11.0.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:01f5567d9cf6f502d655151645d4e8b72b453413d3819d2b6f1185abc23e82dd"},+ {file = "websockets-11.0.3-cp311-cp311-win32.whl", hash = "sha256:e1459677e5d12be8bbc7584c35b992eea142911a6236a3278b9b5ce3326f282c"},+ {file = "websockets-11.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:e7837cb169eca3b3ae94cc5787c4fed99eef74c0ab9506756eea335e0d6f3ed8"},+ {file = "websockets-11.0.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:9f59a3c656fef341a99e3d63189852be7084c0e54b75734cde571182c087b152"},+ {file = "websockets-11.0.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2529338a6ff0eb0b50c7be33dc3d0e456381157a31eefc561771ee431134a97f"},+ {file = "websockets-11.0.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:34fd59a4ac42dff6d4681d8843217137f6bc85ed29722f2f7222bd619d15e95b"},+ {file = "websockets-11.0.3-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:332d126167ddddec94597c2365537baf9ff62dfcc9db4266f263d455f2f031cb"},+ {file = "websockets-11.0.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:6505c1b31274723ccaf5f515c1824a4ad2f0d191cec942666b3d0f3aa4cb4007"},+ {file = "websockets-11.0.3-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:f467ba0050b7de85016b43f5a22b46383ef004c4f672148a8abf32bc999a87f0"},+ {file = "websockets-11.0.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:9d9acd80072abcc98bd2c86c3c9cd4ac2347b5a5a0cae7ed5c0ee5675f86d9af"},+ {file = "websockets-11.0.3-cp37-cp37m-win32.whl", hash = "sha256:e590228200fcfc7e9109509e4d9125eace2042fd52b595dd22bbc34bb282307f"},+ {file = "websockets-11.0.3-cp37-cp37m-win_amd64.whl", hash = "sha256:b16fff62b45eccb9c7abb18e60e7e446998093cdcb50fed33134b9b6878836de"},+ {file = "websockets-11.0.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:fb06eea71a00a7af0ae6aefbb932fb8a7df3cb390cc217d51a9ad7343de1b8d0"},+ {file = "websockets-11.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:8a34e13a62a59c871064dfd8ffb150867e54291e46d4a7cf11d02c94a5275bae"},+ {file = "websockets-11.0.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4841ed00f1026dfbced6fca7d963c4e7043aa832648671b5138008dc5a8f6d99"},+ {file = "websockets-11.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a073fc9ab1c8aff37c99f11f1641e16da517770e31a37265d2755282a5d28aa"},+ {file = "websockets-11.0.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:68b977f21ce443d6d378dbd5ca38621755f2063d6fdb3335bda981d552cfff86"},+ {file = "websockets-11.0.3-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1a99a7a71631f0efe727c10edfba09ea6bee4166a6f9c19aafb6c0b5917d09c"},+ {file = "websockets-11.0.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:bee9fcb41db2a23bed96c6b6ead6489702c12334ea20a297aa095ce6d31370d0"},+ {file = "websockets-11.0.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:4b253869ea05a5a073ebfdcb5cb3b0266a57c3764cf6fe114e4cd90f4bfa5f5e"},+ {file = "websockets-11.0.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:1553cb82942b2a74dd9b15a018dce645d4e68674de2ca31ff13ebc2d9f283788"},+ {file = "websockets-11.0.3-cp38-cp38-win32.whl", hash = "sha256:f61bdb1df43dc9c131791fbc2355535f9024b9a04398d3bd0684fc16ab07df74"},+ {file = "websockets-11.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:03aae4edc0b1c68498f41a6772d80ac7c1e33c06c6ffa2ac1c27a07653e79d6f"},+ {file = "websockets-11.0.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:777354ee16f02f643a4c7f2b3eff8027a33c9861edc691a2003531f5da4f6bc8"},+ {file = "websockets-11.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8c82f11964f010053e13daafdc7154ce7385ecc538989a354ccc7067fd7028fd"},+ {file = "websockets-11.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3580dd9c1ad0701169e4d6fc41e878ffe05e6bdcaf3c412f9d559389d0c9e016"},+ {file = "websockets-11.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6f1a3f10f836fab6ca6efa97bb952300b20ae56b409414ca85bff2ad241d2a61"},+ {file = "websockets-11.0.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:df41b9bc27c2c25b486bae7cf42fccdc52ff181c8c387bfd026624a491c2671b"},+ {file = "websockets-11.0.3-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:279e5de4671e79a9ac877427f4ac4ce93751b8823f276b681d04b2156713b9dd"},+ {file = "websockets-11.0.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:1fdf26fa8a6a592f8f9235285b8affa72748dc12e964a5518c6c5e8f916716f7"},+ {file = "websockets-11.0.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:69269f3a0b472e91125b503d3c0b3566bda26da0a3261c49f0027eb6075086d1"},+ {file = "websockets-11.0.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:97b52894d948d2f6ea480171a27122d77af14ced35f62e5c892ca2fae9344311"},+ {file = "websockets-11.0.3-cp39-cp39-win32.whl", hash = "sha256:c7f3cb904cce8e1be667c7e6fef4516b98d1a6a0635a58a57528d577ac18a128"},+ {file = "websockets-11.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:c792ea4eabc0159535608fc5658a74d1a81020eb35195dd63214dcf07556f67e"},+ {file = "websockets-11.0.3-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:f2e58f2c36cc52d41f2659e4c0cbf7353e28c8c9e63e30d8c6d3494dc9fdedcf"},+ {file = "websockets-11.0.3-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:de36fe9c02995c7e6ae6efe2e205816f5f00c22fd1fbf343d4d18c3d5ceac2f5"},+ {file = "websockets-11.0.3-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0ac56b661e60edd453585f4bd68eb6a29ae25b5184fd5ba51e97652580458998"},+ {file = "websockets-11.0.3-pp37-pypy37_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e052b8467dd07d4943936009f46ae5ce7b908ddcac3fda581656b1b19c083d9b"},+ {file = "websockets-11.0.3-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:42cc5452a54a8e46a032521d7365da775823e21bfba2895fb7b77633cce031bb"},+ {file = "websockets-11.0.3-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e6316827e3e79b7b8e7d8e3b08f4e331af91a48e794d5d8b099928b6f0b85f20"},+ {file = "websockets-11.0.3-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8531fdcad636d82c517b26a448dcfe62f720e1922b33c81ce695d0edb91eb931"},+ {file = "websockets-11.0.3-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c114e8da9b475739dde229fd3bc6b05a6537a88a578358bc8eb29b4030fac9c9"},+ {file = "websockets-11.0.3-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e063b1865974611313a3849d43f2c3f5368093691349cf3c7c8f8f75ad7cb280"},+ {file = "websockets-11.0.3-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:92b2065d642bf8c0a82d59e59053dd2fdde64d4ed44efe4870fa816c1232647b"},+ {file = "websockets-11.0.3-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0ee68fe502f9031f19d495dae2c268830df2760c0524cbac5d759921ba8c8e82"},+ {file = "websockets-11.0.3-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dcacf2c7a6c3a84e720d1bb2b543c675bf6c40e460300b628bab1b1efc7c034c"},+ {file = "websockets-11.0.3-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b67c6f5e5a401fc56394f191f00f9b3811fe843ee93f4a70df3c389d1adf857d"},+ {file = "websockets-11.0.3-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1d5023a4b6a5b183dc838808087033ec5df77580485fc533e7dab2567851b0a4"},+ {file = "websockets-11.0.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:ed058398f55163a79bb9f06a90ef9ccc063b204bb346c4de78efc5d15abfe602"},+ {file = "websockets-11.0.3-py3-none-any.whl", hash = "sha256:6681ba9e7f8f3b19440921e99efbb40fc89f26cd71bf539e45d8c8a25c976dc6"},+ {file = "websockets-11.0.3.tar.gz", hash = "sha256:88fc51d9a26b10fc331be344f1781224a375b78488fc343620184e95a4b27016"},][[package]]@@ -10211,7 +10260,7 @@ files = [name = "yarl"version = "1.18.3"description = "Yet another URL library"-optional = false+optional = truepython-versions = ">=3.9"files = [{file = "yarl-1.18.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7df647e8edd71f000a5208fe6ff8c382a1de8edfbccdbbfe649d263de07d8c34"},@@ -10362,4 +10411,4 @@ vector-databases = ["pymilvus", "qdrant-client"][metadata]lock-version = "2.0"python-versions = ">=3.10,<3.13"-content-hash = "be45429126e441b443a151800aef185ff0961142c0a1224421b4c6a1fb808f70"+content-hash = "be45429126e441b443a151800aef185ff0961142c0a1224421b4c6a1fb808f70"\ No newline at end of filediff --git a/pyproject.toml b/pyproject.tomlindex 977280d0f..42cfd7275 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -41,7 +41,10 @@ pydantic = ">=1.9,<2.10"eval-type-backport = "0.2.0"curl_cffi = "0.6.2"pandoc = "*"-pillow = "^11.0.0"+pillow = "^10.2.0"+tree-sitter = "*"+tree-sitter-python = "*"+googletrans-py = "4.0.0"# model-platformslitellm = { version = "^1.38.1", optional = true }@@ -57,7 +60,7 @@ sglang = { version = "^0.4.0", optional = true }transformers = { version = "^4", optional = true }diffusers = { version = "^0", optional = true }accelerate = { version = "^0", optional = true }-datasets = { version = "^2", optional = true }+datasets = { version = "^3", optional = true }torch = [{ version = "^2", optional = true, markers = "platform_system != 'Darwin' or platform_machine == 'arm64'" },# Torch 2.2.1 is used on non-arm64 macOS systems.@@ -189,6 +192,8 @@ encoders = [tools = ["beautifulsoup4",+ "selenium",+ "rouge","docx2txt","functools","PyMuPDF",@@ -416,6 +421,8 @@ ignore = ["C408", # we have used lots of dict(...) instead of literal]+per-file-ignores = { "camel/benchmarks/__init__.py" = ["I001"], "camel/benchmarks/apibank.py" = ["I001"], "camel/benchmarks/apibench.py" = ["I001"] }+[tool.ruff.lint.pydocstyle]convention = "google"@@ -446,7 +453,10 @@ module = ["_pytest.config","_pytest.nodes","numpy",+ "pandas","torch",+ "tree-sitter",+ "tree-sitter-python","sqlalchemy","google.cloud.sql.connector","gradio",@@ -488,6 +498,8 @@ module = ["litellm","pyTelegramBotAPI","discord.py",+ "rouge",+ "datasets","docker.*","google.*","google_generativeai",diff --git a/test/benchmarks/test_apibank_benchmark.py b/test/benchmarks/test_apibank_benchmark.pynew file mode 100644index 000000000..4ed91cbfa--- /dev/null+++ b/test/benchmarks/test_apibank_benchmark.py@@ -0,0 +1,126 @@+# ========= 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 json+from unittest.mock import MagicMock, mock_open, patch++from camel.benchmarks import APIBankBenchmark+from camel.benchmarks.apibank import APIBankSample++# Mock data for the APIBankBenchmark+MOCK_API_DATA = [+ {+ "api_call": "huggingface_api_call_example",+ "domain": "Natural Language Processing Text Classification",+ }+]+MOCK_GROUND_TRUTH = {"role": "API", "output": "huggingface_api_output_example"}+MOCK_CHAT_HISTORY = [+ {+ "role": "User",+ "text": "How do I use the HuggingFace API for text classification?",+ },+ {+ "role": "API",+ "api_name": "huggingface_api",+ "param_dict": {"input": "text"},+ "result": {"output": "huggingface_api_output_example"},+ },+ {+ "role": "AI",+ "text": "You can use the HuggingFace API to classify text using \+ their models.",+ },+]++# Create mock API samples+MOCK_SAMPLE = APIBankSample.from_chat_history(MOCK_CHAT_HISTORY)++# Mock data that the benchmark will load+MOCK_DATA = {+ "level-1-mock": [+ {+ "chat_history": MOCK_CHAT_HISTORY,+ "ground_truth": MOCK_GROUND_TRUTH,+ "api_calls": MOCK_API_DATA,+ }+ ]+}+++def test_apibank_benchmark():+ # Patch necessary functions and classes to prevent real file system access+ with (+ patch("os.listdir", return_value=["level-1-mock.jsonl"]),+ patch("pathlib.Path.mkdir"),+ patch("os.chdir"),+ patch("pathlib.Path.exists", return_value=True),+ patch("pathlib.Path.is_dir", return_value=True),+ patch("builtins.open", mock_open()) as mock_file,+ patch("camel.benchmarks.apibank.Evaluator") as mock_evaluator,+ patch("camel.benchmarks.apibank.agent_call") as mock_agent_call,+ patch("camel.benchmarks.apibank.get_api_call") as mock_get_api_call,+ patch.object(APIBankBenchmark, 'load') as mock_load,+ ):+ # Initialize APIBankBenchmark with mock paths within the patch context+ save_to = "mock_save_to.json"+ benchmark = APIBankBenchmark(save_to=save_to)++ # Mock the agent call to return a fixed API response+ mock_agent_call.return_value = "huggingface_api_output_example"+ # Mock the get_api_call to return a fixed API call+ mock_get_api_call.return_value = "mock_api_call"++ # Mock the evaluator to return correct evaluation+ mock_evaluator.return_value = MagicMock()+ evaluator_instance = mock_evaluator.return_value+ evaluator_instance.evaluate.return_value = (+ True,+ "huggingface_api_output_example",+ )+ evaluator_instance.get_all_sample_ids.return_value = [0]+ evaluator_instance.dataset = (+ MOCK_SAMPLE # Provide mock data as a list of samples+ )+ evaluator_instance.get_model_input.return_value = (+ "mock_api_description",+ MOCK_CHAT_HISTORY,+ )++ # Mock the load method to load mock data directly+ mock_load.return_value = None+ benchmark._data = MOCK_DATA # Manually set mock data for the benchmark++ # Run the benchmark+ result = benchmark.run(+ agent=MagicMock(), level="level-1", randomize=False, subset=1+ )++ # Assert that the benchmark loaded the data correctly+ assert len(benchmark._data["level-1-mock"]) == 1+ assert (+ benchmark._data["level-1-mock"][0]["chat_history"][0]["text"]+ == "How do I use the HuggingFace API for text classification?"+ )++ # Assert the benchmark results+ assert result["total"] == 1+ assert result["correct"] == 1+ assert result["accuracy"] == 1.0++ # Verify that the results were written correctly to the save_to file+ written_data = json.loads(mock_file().write.call_args[0][0])+ print(MOCK_SAMPLE)+ assert written_data["Model_output"] == "huggingface_api_output_example"+ assert written_data["Correct"]diff --git a/test/benchmarks/test_apibench_benchmark.py b/test/benchmarks/test_apibench_benchmark.pynew file mode 100644index 000000000..31bc46a7c--- /dev/null+++ b/test/benchmarks/test_apibench_benchmark.py@@ -0,0 +1,121 @@+# ========= 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 json+from unittest.mock import MagicMock, mock_open, patch++from camel.benchmarks import APIBenchBenchmark++# Mock question, API, eval, and ast data+MOCK_QUESTION_DATA = [+ {+ "question_id": 1,+ "text": "How do I use the HuggingFace API for text classification?",+ "domain": "Natural Language Processing Text Classification",+ },+]+MOCK_API_DATA = [+ {+ "api_call": "huggingface_api_call_example",+ "domain": "Natural Language Processing Text Classification",+ }+]+MOCK_EVAL_DATA = [+ {+ "api_call": "huggingface_api_call_example",+ "eval": "huggingface_api_eval_example",+ }+]+MOCK_AST_DATA = [+ {"type": "ASTNode", "value": "some_ast_1"},+ {"type": "ASTNode", "value": "some_ast_2"},+]+++def test_apibench_benchmark():+ # Patch necessary functions and classes to prevent real file system access+ with (+ patch("os.listdir", return_value=["huggingface_train.json"]),+ patch("pathlib.Path.mkdir"),+ patch("pathlib.Path.exists", return_value=True),+ patch("pathlib.Path.is_dir", return_value=True),+ patch("huggingface_hub.snapshot_download"),+ patch("builtins.open", mock_open()) as mock_file,+ patch(+ "camel.benchmarks.apibench.encode_question"+ ) as mock_encode_question,+ patch(+ "camel.benchmarks.apibench.evaluate_response"+ ) as mock_evaluate_response,+ patch.object(APIBenchBenchmark, 'load'),+ ):+ # Initialize APIBenchBenchmark with mock paths within the patch context+ data_dir = "/mock_data_dir"+ save_to = "mock_save_to.json"+ benchmark = APIBenchBenchmark(data_dir=data_dir, save_to=save_to)++ # Mock the encode_question function to return a fixed prompt+ mock_encode_question.return_value = (+ "How do I use the HuggingFace API for text classification?"+ )++ # Mock the evaluate_response function to return expected results+ mock_evaluate_response.return_value = (None, True, False)++ # Mock the agent's step method to return the expected response+ mock_agent = MagicMock()+ mock_agent.step.return_value.msgs = [+ MagicMock(content="HuggingFace API call here")+ ]++ # Manually set mock data for api, eval, and ast+ benchmark._data = {+ "api": MOCK_API_DATA,+ "ast": MOCK_AST_DATA,+ "questions": MOCK_QUESTION_DATA,+ "eval": MOCK_EVAL_DATA,+ }++ # Run the benchmark+ result = benchmark.run(+ agent=mock_agent,+ dataset_name="huggingface",+ randomize=False,+ subset=1,+ )++ # Assert the benchmark loaded the data correctly+ assert len(benchmark._data["questions"]) == 1+ assert (+ benchmark._data["questions"][0]["text"]+ == "How do I use the HuggingFace API for text classification?"+ )++ # Assert the benchmark results+ assert result["total"] == 1+ assert result["correct"] == 1+ assert result["hallucination"] == 0+ assert result["accuracy"] == 1.0+ assert result["hallucination rate"] == 0.0++ # Verify that the results were written correctly to the save_to file+ written_data = json.loads(mock_file().write.call_args[0][0])+ assert (+ written_data["question"]["text"]+ == "How do I use the HuggingFace API for text classification?"+ )+ assert written_data["agent_response"] == "HuggingFace API call here"+ assert written_data["correct"]+ assert not written_data["hallucination"]+ assert written_data["error"] is Nonediff --git a/test/benchmarks/test_nexus_benchmark.py b/test/benchmarks/test_nexus_benchmark.pynew file mode 100644index 000000000..b8dad2704--- /dev/null+++ b/test/benchmarks/test_nexus_benchmark.py@@ -0,0 +1,86 @@+# ========= 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 json+from unittest.mock import MagicMock, mock_open, patch++from camel.benchmarks import NexusBenchmark++# Sample data for the test+SAMPLE_DATA = [+ {+ "Input": "How do I query the NVD?",+ "Output": "nvdlib.query('CVE-2021-12345')",+ },+]+++def test_nexus_benchmark():+ # Patch necessary functions and classes to prevent real file system access+ with (+ patch("os.listdir", return_value=["data.parquet"]),+ patch("pathlib.Path.mkdir"),+ patch("pathlib.Path.exists", return_value=True),+ patch("pathlib.Path.is_dir", return_value=True),+ patch("pandas.read_parquet") as mock_read_parquet,+ patch("builtins.open", mock_open()) as mock_file,+ patch(+ "camel.benchmarks.nexus.construct_tool_descriptions"+ ) as mock_construct_tools,+ ):+ # Initialize NexusBenchmark with mock paths within the patch context+ data_dir = "/mock_data_dir"+ save_to = "mock_save_to.json"+ benchmark = NexusBenchmark(data_dir=data_dir, save_to=save_to)++ # Setup pandas.read_parquet mock to return SAMPLE_DATA+ mock_df = MagicMock()+ mock_df.iterrows.return_value = [(0, SAMPLE_DATA[0])]+ mock_read_parquet.return_value = mock_df++ # Mock construct_tool_descriptions to return a fixed value+ mock_construct_tools.return_value = r"""Function:\ndef mock_tool():+ \n\"\"\"\nMocked tool description.\n\"\"\"\n"""++ # Mock the ChatAgent's step method to return the expected output+ mock_agent = MagicMock()+ mock_agent.step.return_value.msgs = [+ MagicMock(content="nvdlib.query('CVE-2021-12345')")+ ]++ # Run the benchmark+ result = benchmark.run(+ agent=mock_agent, task="NVDLibrary", randomize=False, subset=1+ )++ # Assert the benchmark loaded the data correctly+ assert len(benchmark._data) == 1+ assert benchmark._data[0].input == "How do I query the NVD?"+ assert benchmark._data[0].output == "nvdlib.query('CVE-2021-12345')"++ # Assert the benchmark results+ assert result["total"] == 1+ assert result["correct"] == 1+ assert result["accuracy"] == 1.0++ # Verify that the results were written correctly to the save_to file+ written_data = json.loads(mock_file().write.call_args[0][0])+ assert written_data["input"] == "How do I query the NVD?"+ assert written_data["agent_call"] == "nvdlib.query('CVE-2021-12345')"+ assert (+ written_data["ground_truth_call"]+ == "nvdlib.query('CVE-2021-12345')"+ )+ assert written_data["result"]+ assert written_data["error"] is None