diff --git a/forecasting_tools/agents_and_tools/auto_resolver/__init__.py b/forecasting_tools/agents_and_tools/auto_resolver/__init__.py new file mode 100644 index 0000000..df6961e --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/__init__.py @@ -0,0 +1,72 @@ +from typing import Optional +import os +from forecasting_tools.data_models.questions import ( + BinaryResolution, NumericResolution, DateResolution, MultipleChoiceResolution, ResolutionType +) +from forecasting_tools import ( + MetaculusQuestion, BinaryQuestion, MultipleChoiceQuestion, + NumericQuestion, DateQuestion, MetaculusClient +) +from abc import ABC, abstractmethod + +class AutoResolver(ABC): + """ + Auto resolvers are provided a metaculus question, and return a resolution if it was able to + conclusively resolve a question. + + It should be noted that "ambiguous" and "annulled" resolutions + ARE conclusive (as they are a final resolution). An inconclusive, or null, resolution, means + that the deciding event or deadline has not occured, or there is presently not enough + information for the resolver to come to a conclusion. + """ + + @abstractmethod + async def resolve_question(self, question: MetaculusQuestion) -> Optional[ResolutionType]: + raise NotImplementedError() + + def get_last_resolution_metadata(self) -> dict | None: + """ + Returns metadata from the last resolution attempt, such as chain of thought or key evidence. + + Subclasses should override this to provide additional context about how the resolution + was determined. + + Returns: + dict with metadata fields (e.g., 'key_evidence', 'reasoning', etc.) or None + """ + return None + +class CommunityForecastResolver(AutoResolver): + """ + Checks if the community forecast has reached a consensus. This only works on binary forecasts + at the minute. + + This should not be used alone, as there can be extremely slim chanced theoretical questions + (i.e. what is the chance that a meteor hits the earth in the next year) that have not resolved. + + This is also unable to determine if a question should resolve as annulled or ambiguous. + """ + + def __init__(self, binary_threshold: float = 1, mc_threshold: float = 1): + self.binary_theshold = binary_threshold + self.mc_threshold = mc_threshold + + @abstractmethod + async def resolve_question(self, question: MetaculusQuestion) -> Optional[ResolutionType]: + # Update the question + question = MetaculusClient.get_question_by_post_id(question.id_of_post) + if isinstance(question, BinaryQuestion): + return self._resolve_binary_question(question) + else: + return NotImplemented + + + def _resolve_binary_question(self, question: BinaryQuestion) -> Optional[BinaryResolution]: + if question.community_prediction_at_access_time is None or type(self.binary_theshold) is not int and type(self.binary_theshold) is not float: + return None + if self.binary_theshold + question.community_prediction_at_access_time >= 100: + return True + elif question.community_prediction_at_access_time - self.binary_theshold <= 0: + return False + else: + return None diff --git a/forecasting_tools/agents_and_tools/auto_resolver/agentic/__init__.py b/forecasting_tools/agents_and_tools/auto_resolver/agentic/__init__.py new file mode 100644 index 0000000..58c7cb4 --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/agentic/__init__.py @@ -0,0 +1,496 @@ +""" +Agentic question resolver using OpenAI Agents. + +This module implements a multi-agent architecture for resolving Metaculus +forecasting questions. It uses a pluggable researcher pattern with a default +Perplexity-based implementation. + +Architecture: + 0. Question rephraser (standalone LLM call) converts past-deadline + questions from future tense to past tense for better research + 1. Orchestrator (minimal) coordinates handoffs between agents + 2. Researcher agent performs multiple strategic searches + 3. Resolver agent analyzes research and determines resolution + 4. Structured output parsing converts to typed resolution +""" + +import logging +from typing import AsyncGenerator, Optional, Callable + +import pendulum + +from openai.types.responses import ResponseTextDeltaEvent + +from forecasting_tools.data_models.questions import ( + ResolutionType, + CanceledResolution, + BinaryResolution, +) +from forecasting_tools import MetaculusQuestion, BinaryQuestion +from forecasting_tools.agents_and_tools.auto_resolver.agentic.instructions import * +from forecasting_tools.agents_and_tools.auto_resolver.resolution_models import ( + BinaryResolutionResult, + DeadlineCheckResult, +) +from forecasting_tools.agents_and_tools.auto_resolver import AutoResolver +from forecasting_tools.agents_and_tools.minor_tools import ( + create_date_filtered_asknews_tool, + perplexity_reasoning_pro_search, +) +from forecasting_tools.ai_models.agent_wrappers import ( + AgentRunner, + AgentSdkLlm, + AiAgent, + event_to_tool_message, +) +from forecasting_tools.ai_models.general_llm import GeneralLlm +from forecasting_tools.helpers.structure_output import structure_output +from forecasting_tools.util.misc import clean_indents + +logger = logging.getLogger(__name__) + + + + +class StructuredOutputParsingError(Exception): + """Raised when structured output parsing fails. + + This exception preserves the raw unparsed output for debugging purposes. + + Attributes: + raw_output: The unparsed output that failed parsing + original_error: The original exception that caused the failure + """ + + def __init__(self, raw_output: str, original_error: Exception): + self.raw_output = raw_output + self.original_error = original_error + super().__init__( + f"Failed to parse structured output: {original_error}\n" + f"Raw output available in exception.raw_output" + ) + + +class AgenticResolver(AutoResolver): + """ + Agentic resolver using agents SDK. + """ + + def __init__(self, + model_for_supervisor: str = "openrouter/anthropic/claude-sonnet-4.6", + model_for_resolver: str = "openrouter/anthropic/claude-sonnet-4.6", + model_for_output_structure: str = "openrouter/anthropic/claude-sonnet-4.6", + model_for_researcher: str = "openrouter/anthropic/claude-sonnet-4.6", + model_for_rephraser: str = "openrouter/anthropic/claude-sonnet-4.6", + timeout: int = 480 + ): + self.model_for_supervisor = model_for_supervisor + self.model_for_resolver = model_for_resolver + self.model_for_output_structure = model_for_output_structure + self.model_for_researcher = model_for_researcher + self.model_for_rephraser = model_for_rephraser + self.timeout = timeout + + # ------------------------------------------------------------------ + # Deadline checking (two-tier) + # ------------------------------------------------------------------ + + _DEADLINE_CHECK_MODEL = "openrouter/openai/gpt-4.1-mini" + + def _is_before_scheduled_deadline(self, question: MetaculusQuestion) -> bool: + """Tier 1 (instant, free): check the metadata ``scheduled_resolution_time``. + + Returns ``True`` if the field is set and still in the future, meaning + the question's scheduled resolution has not yet arrived. Returns + ``False`` when the field is ``None`` or the date has already passed. + """ + if question.scheduled_resolution_time is None: + return False + now = pendulum.now("UTC") + return now < question.scheduled_resolution_time + + async def _check_implicit_deadline( + self, question: MetaculusQuestion + ) -> tuple[bool, str | None]: + """Tier 2 (cheap LLM call): analyse the question text for an implicit deadline. + + Returns: + A tuple of ``(should_skip, reason)``. ``should_skip`` is ``True`` + when the LLM found a deadline that has **not** yet passed. + ``reason`` is a human-readable explanation (or ``None``). + """ + prompt = deadline_check_instructions(question) + llm = GeneralLlm(model=self._DEADLINE_CHECK_MODEL, temperature=0.0) + + try: + raw_response = await llm.invoke(prompt) + result = await structure_output( + raw_response, + DeadlineCheckResult, + model=self._DEADLINE_CHECK_MODEL, + ) + except Exception as e: + logger.warning( + "Implicit deadline check failed — allowing resolution to " + "proceed. Error: %s", + e, + exc_info=True, + ) + return False, None + + if not result.has_deadline or result.deadline_date is None: + logger.info( + "No implicit deadline found for question %s: %s", + question.id_of_post, + result.reasoning, + ) + return False, None + + # Parse the deadline date and compare to now + try: + parsed = pendulum.parse(result.deadline_date, tz="UTC") + if not isinstance(parsed, pendulum.DateTime): + raise ValueError( + f"Expected a DateTime, got {type(parsed).__name__}" + ) + deadline = parsed + except Exception as e: + logger.warning( + "Could not parse deadline date '%s' from LLM response — " + "allowing resolution to proceed. Error: %s", + result.deadline_date, + e, + ) + return False, None + + now = pendulum.now("UTC") + if now < deadline: + reason = ( + f"Implicit deadline {result.deadline_date} has not yet passed " + f"(current date: {now.format('YYYY-MM-DD')}). " + f"{result.reasoning}" + ) + logger.info( + "Question %s: implicit deadline not reached — skipping resolution. %s", + question.id_of_post, + reason, + ) + return True, reason + + logger.info( + "Question %s: implicit deadline %s has passed. %s", + question.id_of_post, + result.deadline_date, + result.reasoning, + ) + return False, None + + async def _should_skip_resolution( + self, question: MetaculusQuestion + ) -> tuple[bool, str | None]: + """Decide whether to skip resolution entirely because the deadline has not passed. + + Tier 1 — free, instant check of ``scheduled_resolution_time``. + Tier 2 — cheap LLM analysis of the question text for an implicit deadline. + + Returns: + ``(should_skip, reason)`` where *reason* is a human-readable + explanation when *should_skip* is ``True``, or ``None`` otherwise. + """ + # Tier 1: metadata field + if self._is_before_scheduled_deadline(question): + reason = ( + f"Scheduled resolution time ({question.scheduled_resolution_time}) " + f"has not yet passed." + ) + logger.info( + "Question %s: %s Skipping resolution.", + question.id_of_post, + reason, + ) + return True, reason + + # Tier 2: LLM-based implicit deadline analysis + return await self._check_implicit_deadline(question) + + # ------------------------------------------------------------------ + # Public resolution entry points + # ------------------------------------------------------------------ + + async def resolve_question( + self, question: MetaculusQuestion + ) -> Optional[ResolutionType]: + should_skip, reason = await self._should_skip_resolution(question) + if should_skip: + logger.info( + "Question %s — skipping resolution: %s", + question.id_of_post, + reason, + ) + return None + + if isinstance(question, BinaryQuestion): + return await self._resolve_binary(question) + else: + return NotImplemented + + async def _resolve_binary( + self, question: BinaryQuestion + ) -> Optional[BinaryResolution]: + + # Rephrase question if its time context has passed + question = await self._rephrase_question_if_needed(question) + + # Create agents + researcher = self._create_researcher(question) + annulled_ambiguous_resolver = self._create_annulled_ambiguous_resolver_agent(question) + resolver = self._create_resolver_agent(question, annulled_ambiguous_resolver) + orchestrator = self._create_orchestrator_agent(researcher, resolver) + + # Run the workflow (non-streaming) + result = await AgentRunner.run( + orchestrator, "Please begin the resolution process.", max_turns=10 + ) + + # Parse structured output with error handling + try: + resolution_result = await structure_output( + result.final_output, + BinaryResolutionResult, + model=self.model_for_output_structure, + ) + logger.info( + f"Successfully parsed resolution: {resolution_result.resolution_status}" + ) + except Exception as e: + logger.error(f"Failed to parse structured output: {e}", exc_info=True) + raise StructuredOutputParsingError( + raw_output=result.final_output, original_error=e + ) from e + + # Store metadata for later retrieval + self._last_resolution_metadata = { + "reasoning": resolution_result.reasoning, + "key_evidence": resolution_result.key_evidence, + } + + # Convert to typed resolution + typed_resolution = resolution_result.convert_to_binary_resolution() + logger.info(f"Final resolution: {typed_resolution}") + + return typed_resolution + + async def _rephrase_question_if_needed( + self, question: BinaryQuestion + ) -> BinaryQuestion: + """Rephrase the question into past tense if its time context has passed. + + Uses a lightweight LLM call to determine whether the question's deadline + has already passed and, if so, rephrases it from future tense to past + tense. This makes downstream research searches more effective. + + Args: + question: The original question to potentially rephrase. + + Returns: + A copy of the question with question_text updated if rephrasing + was needed, or the original question unchanged. + """ + prompt = question_rephraser_instructions(question) + llm = GeneralLlm(model=self.model_for_rephraser, temperature=0.0) + + try: + rephrased_text = await llm.invoke(prompt) + rephrased_text = rephrased_text.strip().strip('"').strip("'") + + if rephrased_text and rephrased_text != question.question_text: + logger.info( + f"Question rephrased:\n" + f" Original: {question.question_text}\n" + f" Rephrased: {rephrased_text}" + ) + question = question.model_copy(deep=True) + question.question_text = rephrased_text + else: + logger.info("Question rephraser: no rephrasing needed") + except Exception as e: + logger.warning( + f"Question rephrasing failed, proceeding with original: {e}", + exc_info=True, + ) + + return question + + def _create_researcher(self, question: BinaryQuestion) -> AiAgent: + instructions = researcher_instructions(question) + asknews_tool = create_date_filtered_asknews_tool(question.close_time) + return AiAgent( + name="Resolution Researcher", + instructions=instructions, + model=AgentSdkLlm(model=self.model_for_researcher), + tools=[perplexity_reasoning_pro_search, asknews_tool], + handoffs=[], + ) + + def _create_resolver_agent(self, question: BinaryQuestion, annulled_ambiguous_resolver: AiAgent) -> AiAgent: + instructions = binary_resolver_instructions(question) + return AiAgent( + name="resolver", + instructions=instructions, + model=AgentSdkLlm(model=self.model_for_resolver), + tools=[], # No tools - only analyzes research + handoffs=[annulled_ambiguous_resolver], # Can hand off to specialized agent + ) + + def _create_annulled_ambiguous_resolver_agent(self, question: BinaryQuestion) -> AiAgent: + instructions = annulled_ambiguous_resolver_instructions(question) + return AiAgent( + name="annulled_ambiguous_resolver", + instructions=instructions, + model=AgentSdkLlm(model=self.model_for_resolver), + tools=[], # No tools - only analyzes research + handoffs=[], # Terminal agent + ) + + def _create_orchestrator_agent( + self, researcher: AiAgent, resolver: AiAgent + ) -> AiAgent: + logger.debug("Creating minimal orchestrator agent") + + instructions = clean_indents( + """ + You are coordinating a question resolution process. + + Your task is simple: + 1. Hand off to the Resolution Researcher to gather information + 2. The researcher will hand off to the resolver when ready + 3. The resolver will provide the final resolution + + Begin by handing off to the researcher. + """ + ) + + return AiAgent( + name="Resolution Orchestrator", + instructions=instructions, + model=AgentSdkLlm(model=self.model_for_output_structure), + tools=[], + handoffs=[researcher, resolver], + ) + + async def resolve_question_streamed( + self, question: MetaculusQuestion + ) -> AsyncGenerator[tuple[str, str], None]: + """Resolve a question with streaming, yielding (event_type, message) tuples. + + This is the streaming counterpart to resolve_question(). It yields + intermediate events as they occur during the agent resolution process, + allowing a TUI or other consumer to display live progress. + + Event types: + "status" -- lifecycle status updates (rephrasing, agent creation, etc.) + "text" -- streamed text delta from the agent's response + "tool" -- tool call / handoff / reasoning events + "result" -- final resolution result (yielded once at the end) + "error" -- an error occurred during resolution + + After all events are yielded, the resolver's internal metadata is updated + (same as resolve_question), so get_last_resolution_metadata() will work. + + Args: + question: The Metaculus question to resolve. + + Yields: + Tuples of (event_type, message_text). + """ + if not isinstance(question, BinaryQuestion): + yield ("error", f"Unsupported question type: {type(question).__name__}") + return + + yield ("status", "Checking whether the question deadline has passed...") + should_skip, reason = await self._should_skip_resolution(question) + if should_skip: + now = pendulum.now("UTC") + yield ( + "status", + f"Deadline has not yet passed. Skipping resolution. {reason}", + ) + yield ( + "result", + f"Resolution: NOT_YET_RESOLVABLE\n" + f"Reasoning: {reason}\n" + f"Key Evidence:\n" + f" - {reason}\n" + f" - Current time: {now}\n" + f" - Deadline has not yet passed", + ) + return + + # Step 1: Rephrase if needed + yield ("status", "Checking if question needs rephrasing...") + question = await self._rephrase_question_if_needed(question) + yield ("status", f"Question text: {question.question_text}") + + # Step 2: Create agents + yield ("status", "Creating resolution agents...") + researcher = self._create_researcher(question) + annulled_ambiguous_resolver = self._create_annulled_ambiguous_resolver_agent(question) + resolver = self._create_resolver_agent(question, annulled_ambiguous_resolver) + orchestrator = self._create_orchestrator_agent(researcher, resolver) + + # Step 3: Run streamed workflow + yield ("status", "Starting resolution process...") + streamed_text = "" + + result = AgentRunner.run_streamed( + orchestrator, "Please begin the resolution process.", max_turns=10 + ) + + async for event in result.stream_events(): + # Capture text deltas + if event.type == "raw_response_event" and isinstance( + event.data, ResponseTextDeltaEvent + ): + streamed_text += event.data.delta + yield ("text", event.data.delta) + + # Capture tool/handoff/reasoning events + tool_msg = event_to_tool_message(event) + if tool_msg: + yield ("tool", tool_msg) + + # Step 4: Parse structured output + yield ("status", "Parsing resolution output...") + final_output = result.final_output + + try: + resolution_result = await structure_output( + final_output, + BinaryResolutionResult, + model=self.model_for_output_structure, + ) + logger.info( + f"Successfully parsed resolution: {resolution_result.resolution_status}" + ) + except Exception as e: + logger.error(f"Failed to parse structured output: {e}", exc_info=True) + yield ("error", f"Failed to parse structured output: {e}") + self._last_resolution_metadata = None + return + + # Step 5: Store metadata + self._last_resolution_metadata = { + "reasoning": resolution_result.reasoning, + "key_evidence": resolution_result.key_evidence, + } + + typed_resolution = resolution_result.convert_to_binary_resolution() + logger.info(f"Final resolution: {typed_resolution}") + + yield ( + "result", + f"Resolution: {resolution_result.resolution_status}\n" + f"Reasoning: {resolution_result.reasoning}\n" + f"Key Evidence:\n" + + "\n".join(f" - {e}" for e in resolution_result.key_evidence), + ) diff --git a/forecasting_tools/agents_and_tools/auto_resolver/agentic/__main__.py b/forecasting_tools/agents_and_tools/auto_resolver/agentic/__main__.py new file mode 100644 index 0000000..f0d9a50 --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/agentic/__main__.py @@ -0,0 +1,69 @@ +import forecasting_tools +from forecasting_tools.agents_and_tools.auto_resolver.agentic import AgenticResolver +from forecasting_tools.agents_and_tools.auto_resolver.agentic import logger as target_logger +import asyncio +from dotenv import load_dotenv + +load_dotenv() + + +from forecasting_tools.agents_and_tools.auto_resolver.assess import ( + ResolutionAssesser, +) +from forecasting_tools import MetaculusClient, ApiFilter +from dotenv import load_dotenv +import random + +import logging + + +async def main(): + logging.getLogger(target_logger.name).setLevel(logging.INFO) + + # Fetch all resolved binary questions from AIB Fall 2025 + client = MetaculusClient() + filter = ApiFilter( + allowed_tournaments=[MetaculusClient.AIB_FALL_2025_ID], + allowed_statuses=["resolved"], + allowed_types=["binary"], + group_question_mode="exclude", + order_by="-published_time" + ) + + all_questions = await client.get_questions_matching_filter(filter) + + # Randomly sample questions + sample_size = min(20, len(all_questions)) + sampled_questions = random.sample(all_questions, sample_size) + question_ids = [q.id_of_post for q in sampled_questions if q.id_of_post is not None] + + + # Create resolver + resolver = AgenticResolver() + + # Create assessor with specific question IDs + assesser = ResolutionAssesser( + resolver, allowed_types=["binary"], questions=question_ids + ) + + + # Run assessment + report = await assesser.assess_resolver() + + # Print results + print("\n" + "=" * 60) + print("OpenAI Resolver Assessment Results") + print(f"Tested on {len(question_ids)} random questions from AIB Fall 2025") + print("=" * 60) + print(report) + print("=" * 60) + + # Save detailed report to reports directory + try: + report_path = report.write_to_file(directory="reports") + print(f"\nDetailed report saved to: {report_path}") + except Exception as e: + print(f"\nWarning: Could not save report to reports directory: {e}") + +if __name__ == "__main__": + asyncio.run(main()) diff --git a/forecasting_tools/agents_and_tools/auto_resolver/agentic/instructions.py b/forecasting_tools/agents_and_tools/auto_resolver/agentic/instructions.py new file mode 100644 index 0000000..f158108 --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/agentic/instructions.py @@ -0,0 +1,626 @@ +""" +To avoid clogging the code file (__init__.py), instruction generation functions are placed here. +""" + +import pendulum + +from forecasting_tools import clean_indents, BinaryQuestion, MetaculusQuestion + + +def deadline_check_instructions(question: MetaculusQuestion) -> str: + """Build instructions for the LLM-based implicit deadline analysis. + + This prompt asks the LLM to examine the question text, resolution + criteria, fine print, and scheduled resolution date to identify the + effective deadline — the date by which the question's event must have + occurred for it to be resolvable. + + Args: + question: The question to analyze for an implicit deadline. + + Returns: + Formatted instruction string. + """ + today_string = pendulum.now(tz="UTC").strftime("%Y-%m-%d") + scheduled_resolution = ( + question.scheduled_resolution_time.strftime("%Y-%m-%d") + if question.scheduled_resolution_time + else "Not specified" + ) + + return clean_indents( + f""" + # Your Task + + You are a deadline analyst for a forecasting resolution system. Your job + is to determine the **effective deadline** of a forecasting question — + the date by which the described event must have occurred for the question + to be resolvable. + + # The Question + + {question.question_text} + + # Additional Context + + Resolution criteria: {question.resolution_criteria} + + Fine print: {question.fine_print} + + Background information: {question.background_info} + + Scheduled resolution date (from platform metadata): {scheduled_resolution} + + Today's date (UTC): {today_string} + + # Instructions + + 1. Examine the question text, resolution criteria, fine print, and + background information to identify any explicit or implicit deadlines. + 2. The deadline is the date by which the event or condition described in + the question must have occurred. For example: + - "Will X happen by March 2026?" → deadline is 2026-03-31 + - "Will X happen before January 1, 2027?" → deadline is 2026-12-31 + - "Will X happen in 2025?" → deadline is 2025-12-31 + - "Will X happen by the end of Q2 2026?" → deadline is 2026-06-30 + 3. If the question text contains a specific deadline, use that — it takes + precedence over the platform's scheduled resolution date. + 4. If the question text does NOT contain a specific deadline but a + scheduled resolution date is provided, use the scheduled resolution + date as the effective deadline. + 5. If you cannot identify any deadline at all, set has_deadline to false. + + # Output Format + + Return a JSON object with these fields: + - "has_deadline": true/false — whether the question has a discernible deadline + - "deadline_date": "YYYY-MM-DD" — the effective deadline date, or null if none found + - "reasoning": "..." — 1-2 sentences explaining how you determined the deadline + + Return ONLY the JSON object. No additional text. + """ + ) + + +def researcher_instructions(question: BinaryQuestion) -> str: + """Build detailed instructions for the researcher agent. + + Args: + question: The question being researched + + Returns: + Formatted instruction string + """ + open_time_str = ( + question.open_time.strftime("%Y-%m-%d") + if question.open_time + else None + ) + close_time_str = ( + question.close_time.strftime("%Y-%m-%d") + if question.close_time + else None + ) + + if open_time_str: + end_date = close_time_str or "its close/resolution date" + temporal_section = clean_indents( + f""" + # Temporal Window — CRITICAL + + This question was opened on **{open_time_str}**. Only events that + occurred **on or after {open_time_str}** are relevant for resolution. + + If your research finds that the described event occurred *before* the + question was opened, that evidence must be clearly flagged as + **pre-question** and should NOT be treated as satisfying the resolution + criteria. The question is asking whether the event occurs during the + question's active period ({open_time_str} to {end_date}), not whether + it ever happened historically. + + When searching, focus on events between {open_time_str} and + {end_date}. Always note the exact date of any event you find and + whether it falls inside or outside this window. + """ + ) + else: + temporal_section = "" + + return clean_indents( + f""" + # Your Role + + You are a research assistant gathering information to resolve a forecasting question. + + # The Question + + {question.give_question_details_as_markdown()} + + # Your Task + + Perform multiple strategic searches to thoroughly investigate: + + 1. **Current Status**: What is the current state of affairs related to this question? + 2. **Resolution Criteria**: Have the resolution criteria been met? + 3. **Timeline Check**: Consider the scheduled resolution date and current date + 4. **Verification**: Cross-check information from multiple sources + 5. **Edge Cases**: Look for any ambiguities, disputes, or complications + 6. **Validity Check**: Investigate whether the question's subject is valid/possible (for potential annulment) + + {temporal_section} + + # Available Tools + + You have two search tools: + + 1. **Perplexity** (`perplexity_reasoning_pro_search`): Best for analytical queries, + reference lookups, and questions requiring reasoning over multiple sources. + Returns an LLM-synthesized answer with citations. + + 2. **AskNews** (`query_asknews_date_filtered`): Best for current-events and + news-driven questions. Searches international news across many languages. + **Important**: Results are automatically date-filtered to only include + articles published before the question's close date, so you will not see + news about events that happened after the question's context window closed. + This prevents false positives. Use this tool when the question is about + a specific event, policy action, election, conflict, or other newsworthy + topic. + + # Search Strategy Guidelines + + - Run 3-5 searches total (don't overdo it) + - Run searches in parallel when they're independent + - Use AskNews for event-driven / news-driven queries + - Use Perplexity for analytical / reference queries + - Using both tools for the same topic provides valuable cross-checking + - Use follow-up searches based on initial findings + - Focus on authoritative and recent sources + - Note any contradictions or uncertainties you find + - Pay special attention to dates and timelines + + # Decomposition Strategy for Multi-Entity Questions + + If a question involves multiple entities (companies, people, organizations, etc.): + + 1. **First attempt**: Search for comprehensive data about all entities + 2. **If comprehensive search fails**: Decompose the question and search each entity individually + 3. **Example**: For "Did all Magnificent Seven stocks decline 50%?", search: + - "Microsoft MSFT all-time high 2025" + - "Nvidia NVDA 2025 stock performance" + - "Apple AAPL 2025 pricing" + - And so on for each company + 4. **Then aggregate**: Combine individual findings to answer the comprehensive question + + # Detecting Annulled/Invalid Questions + + Some questions may be fundamentally invalid (annulled). Look for: + + - Studies/experiments that were never conducted, cancelled, or abandoned + - Questions about entities that never existed or were fundamentally misconceived + - Research projects that lost funding, had impossible criteria, or were invalid from the start + - Any indication that the question's subject is impossible or doesn't exist + + **When you cannot find evidence of an event occurring:** + - Search specifically for: "[subject] cancelled", "[subject] abandoned", "[subject] never conducted" + - Search for: "[subject] funding withdrawn", "[subject] fundamental problems", "[subject] invalid" + - If you find evidence the subject was never valid/possible, note this for potential ANNULLED resolution + + # Example Search Sequence + + 1. AskNews search: "[topic]" — get date-filtered news coverage + 2. Perplexity broad search: "Current status of [topic] as of [current date]" + 3. Specific search: "Has [specific criterion] occurred?" + 4. (Optional) Follow-up based on findings + 5. (If no results found) Validity check: "[topic] cancelled", "[topic] validity", "[topic] problems" + + # Important Reminders + + - Be thorough but efficient + - Document your findings clearly + - Note the sources and dates of information + - If you find conflicting information, document both sides + - Decompose multi-entity questions when comprehensive searches fail + - Actively search for evidence of annulment/invalidity when no results are found + - When ready, hand off your research to the resolver + + # Handoff + + When you've gathered sufficient information, hand off to the resolver + with a comprehensive summary of your research findings. + """ + ) + +def question_rephraser_instructions(question: BinaryQuestion) -> str: + """Build instructions for the question rephraser LLM call. + + This prompt asks the LLM to rephrase a forward-looking forecasting + question into past tense when the question's time context has already + passed, making it easier for downstream research agents to search for + information. + + Args: + question: The question to potentially rephrase + + Returns: + Formatted instruction string + """ + today_string = pendulum.now(tz="UTC").strftime("%Y-%m-%d") + scheduled_resolution = ( + question.scheduled_resolution_time.strftime("%Y-%m-%d") + if question.scheduled_resolution_time + else "Not specified" + ) + + return clean_indents( + f""" + # Your Task + + You are a question rephraser for a forecasting resolution system. Your job + is to determine whether a forecasting question's time context has already + passed and, if so, rephrase it from future tense into past tense. + + This rephrasing helps downstream research agents search more effectively, + since searching for "Did X happen?" yields better results than "Will X + happen?" when the deadline has already passed. + + # The Question + + {question.question_text} + + # Additional Context + + Resolution criteria: {question.resolution_criteria} + + Fine print: {question.fine_print} + + Scheduled resolution date: {scheduled_resolution} + + Today's date (UTC): {today_string} + + # Instructions + + 1. Examine the question text, resolution criteria, fine print, and + scheduled resolution date to identify any deadlines or time-bound + conditions. + 2. Compare those deadlines to today's date. + 3. If the deadline or time context has ALREADY PASSED: + - Rephrase the question from future tense to past tense. + - Keep the meaning, scope, and specificity identical. + - Preserve all named entities, numbers, and conditions exactly. + - Use the deadline from the original question (not today's date) + in the rephrased version. + 4. If the deadline has NOT yet passed, or the question has no + time-bound element, return the question text EXACTLY as-is. + + # Examples + + Example 1 (deadline passed): + - Original: "Will a trade deal between the US and China be signed by October 2025?" + - Today: 2025-11-15 + - Rephrased: "Was a trade deal between the US and China signed by October 2025?" + + Example 2 (deadline passed): + - Original: "Will a deal be signed by the end of March 2024?" + - Today: 2024-06-01 + - Rephrased: "Was a deal signed before the end of March 2024?" + + Example 3 (deadline NOT passed): + - Original: "Will AI surpass human performance on all MMLU categories by 2030?" + - Today: 2026-02-28 + - Rephrased: "Will AI surpass human performance on all MMLU categories by 2030?" + (returned unchanged) + + Example 4 (deadline passed, complex question): + - Original: "Will the global average temperature exceed 1.5C above pre-industrial levels before January 1, 2026?" + - Today: 2026-03-01 + - Rephrased: "Did the global average temperature exceed 1.5C above pre-industrial levels before January 1, 2026?" + + # Output Format + + Return ONLY the (possibly rephrased) question text. Do not include any + explanation, reasoning, or additional text. Just the question. + """ + ) + + +def binary_resolver_instructions(question: BinaryQuestion) -> str: + open_time_str = ( + question.open_time.strftime("%Y-%m-%d") + if question.open_time + else None + ) + + if open_time_str: + temporal_rule = clean_indents( + f""" + # Temporal Window Rule — CRITICAL + + This question was opened on **{open_time_str}**. Only events that + occurred **on or after {open_time_str}** count toward resolution. + + If the research shows the event happened *before* the question was + opened, that is **NOT** sufficient for a TRUE resolution. The question + is asking whether the event occurs during the question's active period, + not whether it ever happened historically. + + **Example**: If the question asks "Will event X happen before Jan 1, + 2025?" and the question was opened on April 1, 2024, only evidence of + event X occurring on or after April 1, 2024 is relevant. An occurrence + on March 3, 2024 (before the question opened) would NOT make this + resolve TRUE. + + When evaluating evidence, always check the date of each event against + the question's open date ({open_time_str}) and disregard any events + that predate it. + """ + ) + else: + temporal_rule = "" + + return clean_indents( + f""" + # Your Role + + You are a resolution analyst determining the final resolution status + of a forecasting question based on research provided to you. + + # The Question + + {question.give_question_details_as_markdown()} + + # Resolution Options + + You must determine one of the following resolutions: + + ## TRUE + - Resolution criteria have been definitively met + - The outcome is YES/positive + - There is strong evidence supporting this + + ## FALSE + - Resolution criteria have been definitively met + - The outcome is NO/negative + - There is strong evidence supporting this + + ## AMBIGUOUS + - The resolution criteria occurred + - BUT the outcome is unclear or disputed + - Multiple interpretations are reasonable + - Example: A law passed but its scope is unclear + + ## ANNULLED + - A fundamental assumption of the question is false + - The question itself is invalid or malformed + - Example: Question asks about a company that never existed + + ## NOT_YET_RESOLVABLE + - Insufficient information currently available + - OR the resolution date/event hasn't occurred yet + - OR you cannot confidently determine the resolution + - **BE CONSERVATIVE: Default to this when uncertain** + + # Analysis Guidelines + + 1. **Review the research** provided by the researcher carefully + 2. **Check the timeline**: Has the scheduled resolution date passed? + 3. **Assess the evidence**: Is it strong enough for a definitive resolution? + 4. **Consider ambiguity**: Is the outcome clear or disputed? + 5. **Be conservative**: If uncertain, return NOT_YET_RESOLVABLE + + {temporal_rule} + + # Critical Distinctions + + **AMBIGUOUS vs ANNULLED:** + - AMBIGUOUS: Question is valid, but answer is unclear + - ANNULLED: Question itself is invalid/malformed + + **FALSE vs NOT_YET_RESOLVABLE:** + - FALSE: Definitively did NOT happen + - NOT_YET_RESOLVABLE: Might still happen or unclear if it happened + + # Special Handling for AMBIGUOUS and ANNULLED + + If your initial assessment is AMBIGUOUS or ANNULLED, you MUST hand off + to the annulled_ambiguous_resolver agent for specialized review. This + agent has detailed instructions for distinguishing between these two + complex resolution types. + + # Output Format + + Provide your analysis in the following format: + + **Resolution Status**: [Your chosen status] + + **Reasoning**: [2-4 sentences explaining your decision] + + **Key Evidence**: + - [Evidence point 1] + - [Evidence point 2] + - [Evidence point 3] + - [Evidence point 4 - optional] + - [Evidence point 5 - optional] + + # Important + + - Be thorough in your reasoning + - Cite specific information from the research + - Acknowledge uncertainties when present + - Your output will be parsed programmatically, so follow the format exactly + - If you determine AMBIGUOUS or ANNULLED, hand off to the specialized agent + """ + ) + + +def annulled_ambiguous_resolver_instructions(question: BinaryQuestion) -> str: + """Build detailed instructions for distinguishing between ANNULLED and AMBIGUOUS resolutions. + + This agent receives the question and research from the main resolver and makes + a final determination on whether to resolve as ANNULLED or AMBIGUOUS (or potentially + another resolution type if the initial assessment was incorrect). + + Args: + question: The question being resolved + + Returns: + Formatted instruction string + """ + + return clean_indents( + f""" + # Your Role + + You are a specialized resolution analyst focusing exclusively on distinguishing + between ANNULLED and AMBIGUOUS resolutions. You have received this case because + the main resolver determined this question may need to be cancelled. + + # The Question + + {question.give_question_details_as_markdown()} + + # Your Task + + Review the research and determine whether this question should be resolved as: + - ANNULLED (question itself is invalid) + - AMBIGUOUS (question is valid but reality is unclear) + - Or if the initial assessment was incorrect, provide the correct resolution + + # Detailed Resolution Criteria + + ## AMBIGUOUS Resolution + + **Definition**: Reserved for questions where **reality is not clear**. The question + is valid and well-formed, but we cannot determine what actually happened. + + **When to use AMBIGUOUS**: + + ### 1. No Clear Consensus + - Conflicting or unclear media reports about what happened + - A data source that was expected to provide resolution information is no longer available + - Multiple reasonable interpretations of the same event + - Insufficient information to arrive at an appropriate resolution + + **Examples of AMBIGUOUS**: + + *Example 1*: "Will Russian troops enter Kyiv, Ukraine before December 31, 2022?" + - It was clear that some Russian troops entered Ukraine, and probable there were more than 100 + - However, there was no clear evidence that could be used to resolve definitively + - Resolution: AMBIGUOUS (reality unclear despite question being valid) + + *Example 2*: "What will the average cost of a ransomware kit be in 2022?" + - Question relied on data from a Microsoft report + - Microsoft's report no longer contained the relevant data + - No alternate sources could be found + - Resolution: AMBIGUOUS (expected data source unavailable) + + ## ANNULLED Resolution + + **Definition**: Reserved for questions where **reality is clear but the question is not**. + The question failed to adequately capture a method for clear resolution. + + **When to use ANNULLED**: + + ### 1. Underspecified Questions + - The question did not clearly describe an appropriate method to resolve + - An outcome occurred that doesn't correspond to the resolution criteria + - No clear direction for how the question resolves in the actual outcome + + **Examples of Underspecified**: + + *Example 1*: "What will Substack's Google Trends index be at end of 2022?" + - Did not clearly specify how Google Trends would be used + - Index value depends on the date range specified in Google Trends + - Resolution: ANNULLED (underspecified methodology) + + *Example 2*: "When will a fusion reactor reach ignition?" + - Did not clearly define what "ignition" means + - Definition varies by researchers and fusion method + - Resolution: ANNULLED (underspecified criteria) + + ### 2. Subverted Assumptions + - The question made assumptions about the present or future that were violated + - Expected data sources changed fundamentally (not just unavailable) + - The premise of the question was false + + **Examples of Subverted Assumptions**: + + *Example 1*: "Will a technical problem be identified as the cause of the crash of China Eastern Airlines Flight 5735?" + - Question relied on a future NTSB report + - This was a Chinese incident, unlikely NTSB would publish + - No date specified for when the report must be published + - Resolution: ANNULLED (assumption of NTSB report violated) + + *Example 2*: "What will the Federal Reserves' Industrial Production Index be for November 2021, for semiconductors?" + - Question anticipated possibility of base period changing + - However, the entire methodology changed (not just base period) + - Unwritten assumption of consistent methodology was violated + - Resolution: ANNULLED (methodology assumption violated) + + ### 3. Imbalanced Outcomes and Consistent Incentives + - Binary question lacks clear mechanism for BOTH Yes and No resolution + - Burden of proof tips scales toward one outcome + - Would require unreasonable research to prove negative + - Creates bad incentives for forecasters + + **Examples of Imbalanced Outcomes**: + + *Example 1*: "Will any prediction market cause users to lose at least $1M before 2023?" + - Clear mechanism for Yes: prominent report of incident + - No clear mechanism for No: would require extensive research + - To resolve No would need absurd amount of research + - Creates bad incentives (savvy forecasters know it's Yes or Annulled) + - Resolution: ANNULLED (imbalanced resolution mechanisms) + + *Example 2*: "Will any remaining FTX depositor withdraw any amount of tradeable assets from FTX before 2023?" + - Required knowledge of FTX withdrawal details unavailable to admins + - No real mechanism to resolve as No + - Question could only truly resolve as Yes or be Annulled + - Resolution: ANNULLED (imbalanced outcomes) + + # Decision Framework + + Use this framework to make your determination: + + **Step 1: Is the question valid?** + - Are the resolution criteria clear and complete? + - Are there reasonable methods to resolve as both Yes and No (for binary)? + - Are the assumptions reasonable and not violated? + - If NO to any → Likely ANNULLED + + **Step 2: Is reality clear?** + - Can we determine what actually happened? + - Is there sufficient information available? + - Are there conflicting reports or interpretations? + - If NO to any → Likely AMBIGUOUS + + **Step 3: What went wrong?** + - If the question's design is the problem → ANNULLED + - If reality/information is the problem → AMBIGUOUS + + # Output Format + + Provide your final determination in the following format: + + **Final Resolution**: [ANNULLED or AMBIGUOUS or other resolution type] + + **Primary Reason**: [UNDERSPECIFIED / SUBVERTED_ASSUMPTIONS / IMBALANCED_OUTCOMES / NO_CLEAR_CONSENSUS] + + **Detailed Reasoning**: [3-5 sentences explaining your decision, citing specific evidence] + + **Key Evidence**: + - [Evidence point 1 - specific to this determination] + - [Evidence point 2] + - [Evidence point 3] + - [Evidence point 4 - optional] + - [Evidence point 5 - optional] + + # Important Reminders + + - Focus specifically on the ANNULLED vs AMBIGUOUS distinction + - Cite specific evidence from the research + - Consider the examples above as guidance + - Your decision will be the final resolution + - Be thorough and precise in your reasoning + """ + ) + diff --git a/forecasting_tools/agents_and_tools/auto_resolver/assess.py b/forecasting_tools/agents_and_tools/auto_resolver/assess.py new file mode 100644 index 0000000..ce67ca7 --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/assess.py @@ -0,0 +1,492 @@ +from forecasting_tools.agents_and_tools.auto_resolver import AutoResolver +import asyncio +import logging +from datetime import datetime +from pathlib import Path +from typing import Optional +from forecasting_tools.data_models.questions import QuestionBasicType, BinaryResolution, CanceledResolution, ResolutionType +from forecasting_tools.helpers.metaculus_client import MetaculusClient +from forecasting_tools import MetaculusQuestion, ApiFilter, BinaryQuestion +from dataclasses import dataclass, field + + +@dataclass +class QuestionAssessmentResult: + """Detailed assessment result for a single question.""" + + question_id: int + question_title: str + question_text: str + question_url: str + actual_resolution: ResolutionType + predicted_resolution: Optional[ResolutionType] + key_evidence: Optional[list[str]] = None + outcome_category: Optional[str] = None + + +@dataclass +class ResolutionAssessmentReport: + """ + Contained variables are arrays, named according to the convention: "{predicted}{true}". + Values for predicted/true are as follows: + - p: positive + - n: negative + - c: cancelled + - x: not answered + """ + + pp: list[int] = field(default_factory=list) + pn: list[int] = field(default_factory=list) + pc: list[int] = field(default_factory=list) + + np: list[int] = field(default_factory=list) + nn: list[int] = field(default_factory=list) + nc: list[int] = field(default_factory=list) + + cp: list[int] = field(default_factory=list) + cn: list[int] = field(default_factory=list) + cc: list[int] = field(default_factory=list) + + xp: list[int] = field(default_factory=list) + xn: list[int] = field(default_factory=list) + xc: list[int] = field(default_factory=list) + + nyr_p: list[int] = field(default_factory=list) + nyr_n: list[int] = field(default_factory=list) + nyr_c: list[int] = field(default_factory=list) + nyr_nyr: list[int] = field(default_factory=list) + nyr_x: list[int] = field(default_factory=list) + + question_results: dict[int, QuestionAssessmentResult] = field(default_factory=dict) + + @property + def n_pp(self) -> int: + return len(self.pp) + + @property + def n_pn(self) -> int: + return len(self.pn) + + @property + def n_pc(self) -> int: + return len(self.pc) + + @property + def n_np(self) -> int: + return len(self.np) + + @property + def n_nn(self) -> int: + return len(self.nn) + + @property + def n_nc(self) -> int: + return len(self.nc) + + @property + def n_cp(self) -> int: + return len(self.cp) + + @property + def n_cn(self) -> int: + return len(self.cn) + + @property + def n_cc(self) -> int: + return len(self.cc) + + @property + def n_xp(self) -> int: + return len(self.xp) + + @property + def n_xn(self) -> int: + return len(self.xn) + + @property + def n_xc(self) -> int: + return len(self.xc) + + @property + def n_nyr_p(self) -> int: + return len(self.nyr_p) + + @property + def n_nyr_n(self) -> int: + return len(self.nyr_n) + + @property + def n_nyr_c(self) -> int: + return len(self.nyr_c) + + @property + def n_nyr_nyr(self) -> int: + return len(self.nyr_nyr) + + @property + def n_nyr_x(self) -> int: + return len(self.nyr_x) + + def binary_results_table(self) -> str: + """ + Returns a markdown table representation of the binary assessment report. + + Columns represent predicted resolutions, rows represent actual resolutions. + Then "Not Answered" column contains cases where the resolver returned None + or an unexpected value (logged as warnings for debugging). + + Returns: + str: A markdown formatted confusion matrix table + """ + corner_label = "Actual \\ Predicted" + col_headers = ["Positive", "Negative", "Cancelled", "Not Yet Resolvable", "Not Answered"] + row_labels = ["Positive", "Negative", "Cancelled", "Not Yet Resolvable"] + # Rows ordered: actual Positive, actual Negative, actual Cancelled, actual Not Yet Resolvable + # Columns ordered: predicted Positive, predicted Negative, predicted Cancelled, predicted Not Yet Resolvable, predicted Not Answered + data = [ + [str(self.n_pp), str(self.n_np), str(self.n_cp), str(self.n_nyr_p), str(self.n_xp)], + [str(self.n_pn), str(self.n_nn), str(self.n_cn), str(self.n_nyr_n), str(self.n_xn)], + [str(self.n_pc), str(self.n_nc), str(self.n_cc), str(self.n_nyr_c), str(self.n_xc)], + [str(self.n_nyr_p), str(self.n_nyr_n), str(self.n_nyr_c), str(self.n_nyr_nyr), str(self.n_nyr_x)], + ] + + # Compute column widths dynamically + col_widths = [len(corner_label)] + for i, header in enumerate(col_headers): + max_data_width = max(len(data[row][i]) for row in range(len(row_labels))) + col_widths.append(max(len(header), max_data_width)) + + # Update corner label width to account for row labels + col_widths[0] = max(col_widths[0], max(len(label) for label in row_labels)) + + def fmt_row(cells: list[str]) -> str: + parts = [] + for i, cell in enumerate(cells): + parts.append(f" {cell.ljust(col_widths[i])} ") + return "|" + "|".join(parts) + "|" + + def fmt_separator() -> str: + return "|" + "|".join("-" * (w + 2) for w in col_widths) + "|" + + header_row = fmt_row([corner_label] + col_headers) + separator = fmt_separator() + body_rows = [ + fmt_row([row_labels[r]] + data[r]) + for r in range(len(row_labels)) + ] + + return "\n".join([header_row, separator] + body_rows) + + def detailed_report(self) -> str: + """ + Returns a complete detailed markdown report including summary and per-question details. + + Returns: + str: A complete markdown formatted assessment report + """ + lines = [] + lines.append("# Auto Resolver Assessment Report\n") + lines.append(f"**Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n") + + # Summary section + lines.append("## Summary\n") + lines.append(self.binary_results_table()) + lines.append("") + + # Results calculation + total = ( + self.n_pp + self.n_pn + self.n_pc + + self.n_np + self.n_nn + self.n_nc + + self.n_cp + self.n_cn + self.n_cc + + self.n_xp + self.n_xn + self.n_xc + + self.n_nyr_p + self.n_nyr_n + self.n_nyr_c + + self.n_nyr_nyr + ) + correct = self.n_pp + self.n_nn + self.n_cc + self.n_nyr_nyr + accuracy = (correct / total * 100) if total > 0 else 0 + + lines.append(f"**Total Questions:** {total}") + lines.append(f"**Correct Predictions:** {correct} ({accuracy:.1f}%)") + lines.append("") + + # Detailed results section + lines.append("## Detailed Results\n") + lines.append("") + + # Sort question results by category, then by question ID + sorted_results = sorted( + self.question_results.values(), + key=lambda x: (x.outcome_category or "", x.question_id) + ) + + for result in sorted_results: + lines.append(f"### Question {result.question_id}\n") + lines.append(f"**Title:** {result.question_title}") + lines.append(f"**URL:** {result.question_url}") + lines.append("") + + # Question contents + lines.append(f"**Question Contents:**\n") + lines.append("> " + result.question_text.replace("\n", "\n> ")) + lines.append("") + + # Resolution comparison table + lines.append("| Output Resolution | Correct Resolution |") + lines.append("|-------------------|--------------------|") + actual_str = self._resolution_to_str(result.actual_resolution) + predicted_str = self._resolution_to_str(result.predicted_resolution) + lines.append(f"| {predicted_str} | {actual_str} |") + lines.append("") + + # Key evidence section + if result.key_evidence: + lines.append("**Key Evidence:**") + for evidence in result.key_evidence: + lines.append(f"- {evidence}") + lines.append("") + + lines.append("---\n") + + return "\n".join(lines) + + def write_to_file(self, directory: str = "reports") -> Path: + """ + Writes the detailed report to a markdown file in the specified directory. + + Args: + directory: Directory path to write the report to (default: "reports") + + Returns: + Path object pointing to the written file + """ + from pathlib import Path + + # Create directory if it doesn't exist + reports_dir = Path(directory) + reports_dir.mkdir(parents=True, exist_ok=True) + + # Generate filename with timestamp + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + filename = f"assessment_report_{timestamp}.md" + filepath = reports_dir / filename + + # Write report + with open(filepath, "w", encoding="utf-8") as f: + f.write(self.detailed_report()) + + logging.info(f"Assessment report written to {filepath}") + return filepath + + @staticmethod + def _resolution_to_str(resolution: Optional[ResolutionType]) -> str: + """Convert a resolution to a human-readable string.""" + if resolution is None: + return "NOT_YET_RESOLVABLE" + elif isinstance(resolution, bool): + return "TRUE" if resolution else "FALSE" + elif isinstance(resolution, CanceledResolution): + return str(resolution) + else: + return str(resolution) + + + def __str__(self): + return self.binary_results_table() + +class ResolutionAssesser: + """ + Utility for assessing how an auto resolver behaves on a set of already resolved questions. + + Supports concurrent resolution of questions when assessing resolvers. + """ + + def __init__(self, resolver: AutoResolver, allowed_types: list[QuestionBasicType], questions: list[int | str] = [], tournaments: list[int | str] = [], max_concurrency: int = 3): + """ + Initialize the resolution assessor. + + Args: + resolver: AutoResolver to assess + allowed_types: List of question types to include + questions: Optional list of question IDs or URLs to assess + tournaments: Optional list of tournament IDs to load + max_concurrency: Maximum number of questions to resolve concurrently (default: 3) + """ + self.client = MetaculusClient() + self.questions: dict[int, MetaculusQuestion] = {} + self.allowed_types = allowed_types + self.resolver = resolver + self.tournament_ids = tournaments + self.question_ids = questions + self._concurrency_limiter = asyncio.Semaphore(max_concurrency) + + + def _insert_question(self, question: MetaculusQuestion): + if question.actual_resolution_time is None: + raise ValueError("Question is not yet resolved") + if question.get_question_type() not in self.allowed_types: + raise ValueError("Question is not of allowed type") + if question.id_of_post is None: + raise ValueError("Question does not have a post id") + self.questions[question.id_of_post] = question + + def _load_question(self, question: int | str): + loaded = None + if type(question) is int: + loaded = self.client.get_question_by_post_id(question) + elif type(question) is str: + loaded = self.client.get_question_by_url(question) + else: + return NotImplemented + + if loaded is None or not isinstance(loaded, MetaculusQuestion): + raise ValueError("unable to find question") + + self._insert_question(loaded) + + def _load_questions(self, questions: list[int | str]): + for question in questions: + try: + self._load_question(question) + except ValueError as e: + logging.warning(f"Skipping question {question}: {e}") + continue + + async def _load_tournaments(self, tournament_ids: list[str | int]): + filter = ApiFilter( + allowed_tournaments=tournament_ids, + allowed_statuses=["resolved"], + allowed_types=self.allowed_types, + group_question_mode="exclude", + order_by="-published_time" + ) + + questions: list[MetaculusQuestion] = await self.client.get_questions_matching_filter(filter) + + for question in questions: + try: + self._insert_question(question) + except ValueError as e: + question_id = getattr(question, 'id_of_post', 'unknown') + logging.warning(f"Skipping question {question_id}: {e}") + continue + + async def _load_tournament(self, tournament_id: str | int): + await self._load_tournaments([tournament_id]) + + async def _resolve_single_question( + self, question: MetaculusQuestion, index: int + ) -> tuple[int, Optional[ResolutionType], dict | None]: + async with self._concurrency_limiter: + resolution = await self.resolver.resolve_question(question) + metadata = self.resolver.get_last_resolution_metadata() + return (index, resolution, metadata) + + async def assess_resolver(self) -> ResolutionAssessmentReport: + """ + Assess the resolver against the loaded questions. + + Uses concurrent execution (via asyncio.gather) to resolve multiple + questions in parallel, controlled by a semaphore to limit concurrency. + + Returns: + ResolutionAssessmentReport: Detailed report of resolver performance + """ + report = ResolutionAssessmentReport() + + if self.tournament_ids: + await self._load_tournaments(self.tournament_ids) + if self.question_ids: + self._load_questions(self.question_ids) + + question_items = list(self.questions.items()) + + tasks = [ + self._resolve_single_question(question, idx) + for idx, (question_id, question) in enumerate(question_items) + ] + results = await asyncio.gather(*tasks, return_exceptions=True) + + for result, (question_id, question) in zip(results, question_items): + if isinstance(result, Exception): + logging.error(f"Exception resolving question {question_id}: {result}") + continue + + index, test_resolution, metadata = result + true_resolution = question.typed_resolution + + key_evidence = metadata.get("key_evidence") if metadata else None + + if isinstance(true_resolution, BinaryResolution): + outcome_category = None + + match true_resolution, test_resolution: + # Positive actual resolution cases + case True, True: + report.pp.append(question_id) + outcome_category = "True Positive" + case True, False: + report.np.append(question_id) + outcome_category = "False Negative" + case True, None: + report.xp.append(question_id) + outcome_category = "Missed Positive" + case True, CanceledResolution(): + report.cp.append(question_id) + outcome_category = "Positive Incorrectly Predicted as Cancelled" + # Negative actual resolution cases + case False, True: + report.pn.append(question_id) + outcome_category = "False Positive" + case False, False: + report.nn.append(question_id) + outcome_category = "True Negative" + case False, None: + report.xn.append(question_id) + outcome_category = "Missed Negative" + case False, CanceledResolution(): + report.cn.append(question_id) + outcome_category = "Negative Incorrectly Predicted as Cancelled" + # Cancelled actual resolution cases + case CanceledResolution(), True: + report.pc.append(question_id) + outcome_category = "Cancelled Incorrectly Predicted as Positive" + case CanceledResolution(), False: + report.nc.append(question_id) + outcome_category = "Cancelled Incorrectly Predicted as Negative" + case CanceledResolution(), None: + report.xc.append(question_id) + outcome_category = "Cancelled Not Answered" + case CanceledResolution(), CanceledResolution(): + report.cc.append(question_id) + outcome_category = "Correct Cancel" + # Catch-all for unmatched cases (edge cases, errors, NotImplemented, etc.) + case _: + logging.warning( + f"Question {question_id} had unmatched prediction: " + f"true_resolution={true_resolution}, test_resolution={test_resolution}" + ) + if true_resolution == True: + report.xp.append(question_id) + outcome_category = "Unmatched - Positive" + elif true_resolution == False: + report.xn.append(question_id) + outcome_category = "Unmatched - Negative" + elif isinstance(true_resolution, CanceledResolution): + report.xc.append(question_id) + outcome_category = "Unmatched - Cancelled" + else: + continue + + # Create detailed result + question_result = QuestionAssessmentResult( + question_id=question_id, + question_title=question.question_text[:100] if question.question_text else "No title", + question_text=question.question_text or "No text available", + question_url=question.page_url or f"https://metaculus.com/{question_id}", + actual_resolution=true_resolution, + predicted_resolution=test_resolution, + key_evidence=key_evidence, + outcome_category=outcome_category, + ) + report.question_results[question_id] = question_result + return report diff --git a/forecasting_tools/agents_and_tools/auto_resolver/resolution_models.py b/forecasting_tools/agents_and_tools/auto_resolver/resolution_models.py new file mode 100644 index 0000000..8bd9c4c --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/resolution_models.py @@ -0,0 +1,93 @@ +"""Pydantic models for structured resolution output parsing. + +This module defines the data models used to parse the output from the resolver +agent into typed resolution decisions. +""" +from forecasting_tools.data_models.questions import BinaryResolution, CanceledResolution + +from pydantic import BaseModel, Field +from typing import Literal, Optional + + +class DeadlineCheckResult(BaseModel): + """Structured output from the LLM-based implicit deadline analysis. + + Used to determine whether a question's effective deadline (as described + in its text, resolution criteria, or fine print) has already passed. + + Attributes: + has_deadline: Whether the question contains a discernible deadline. + deadline_date: The effective deadline as an ISO-8601 date string + (YYYY-MM-DD), or None if no deadline was found. + reasoning: Brief explanation of how the deadline was determined. + """ + + has_deadline: bool = Field( + description="Whether the question contains a discernible deadline or time-bound condition" + ) + deadline_date: Optional[str] = Field( + default=None, + description="The effective deadline in YYYY-MM-DD format, or null if no deadline found", + ) + reasoning: str = Field( + description="1-2 sentence explanation of how the deadline was identified" + ) + + +class BinaryResolutionResult(BaseModel): + """Structured output for binary question resolution. + + This model is used to parse the final output from the resolver agent + into a typed resolution decision with supporting evidence and reasoning. + + Attributes: + resolution_status: The final resolution determination (TRUE, FALSE, + AMBIGUOUS, ANNULLED, or NOT_YET_RESOLVABLE) + reasoning: A 2-4 sentence explanation of why this resolution was chosen + key_evidence: A list of 3-5 key pieces of evidence supporting this resolution + """ + + resolution_status: Literal[ + "TRUE", "FALSE", "AMBIGUOUS", "ANNULLED", "NOT_YET_RESOLVABLE" + ] = Field(description="The final resolution determination") + + reasoning: str = Field( + description="2-4 sentence explanation of why this resolution was chosen" + ) + + key_evidence: list[str] = Field( + description="3-5 key pieces of evidence supporting this resolution", + min_length=3, + max_length=5, + ) + + + def convert_to_binary_resolution(self) -> Optional[BinaryResolution]: + """Convert structured result to typed binary resolution. + + Args: + result: Parsed resolution result + + Returns: + Typed BinaryResolution or None + + Raises: + ValueError: If resolution status is unexpected + """ + + match self.resolution_status: + case "TRUE": + return True + case "FALSE": + return False + case "AMBIGUOUS": + return CanceledResolution.AMBIGUOUS + case "ANNULLED": + return CanceledResolution.ANNULLED + case "NOT_YET_RESOLVABLE": + return None + case _: + raise ValueError( + f"Unexpected resolution status: {result.resolution_status}" + ) + diff --git a/forecasting_tools/agents_and_tools/auto_resolver/tui/__init__.py b/forecasting_tools/agents_and_tools/auto_resolver/tui/__init__.py new file mode 100644 index 0000000..654a819 --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/tui/__init__.py @@ -0,0 +1,9 @@ +""" +TUI (Terminal User Interface) for the Agentic Auto Resolver. + +Run with: + python -m forecasting_tools.agents_and_tools.auto_resolver.tui + +This is just a vibe coded tool for interfacing with the agentic auto resolver. This should be +presently be treated as functional technical debt. +""" diff --git a/forecasting_tools/agents_and_tools/auto_resolver/tui/__main__.py b/forecasting_tools/agents_and_tools/auto_resolver/tui/__main__.py new file mode 100644 index 0000000..ea8d60c --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/tui/__main__.py @@ -0,0 +1,70 @@ +"""Entry point for the Auto Resolver TUI. + +Usage: + python -m forecasting_tools.agents_and_tools.auto_resolver.tui + python -m forecasting_tools.agents_and_tools.auto_resolver.tui --tournament 32813 + python -m forecasting_tools.agents_and_tools.auto_resolver.tui --tournament fall-aib-2025 + python -m forecasting_tools.agents_and_tools.auto_resolver.tui --question 12345 --question 67890 + python -m forecasting_tools.agents_and_tools.auto_resolver.tui --concurrency 5 +""" + +import argparse + +from dotenv import load_dotenv + +load_dotenv() + + +def main() -> None: + parser = argparse.ArgumentParser( + description="Auto Resolver TUI -- interactive agentic question resolution", + ) + def _parse_tournament_id(value: str) -> int | str: + """Parse a tournament ID as int if numeric, otherwise keep as string slug.""" + try: + return int(value) + except ValueError: + return value + + parser.add_argument( + "--tournament", + type=_parse_tournament_id, + action="append", + default=[], + help="Tournament ID or slug to load on startup (can be repeated)", + ) + parser.add_argument( + "--question", + type=int, + action="append", + default=[], + help="Question post ID to load on startup (can be repeated)", + ) + parser.add_argument( + "--concurrency", + type=int, + default=3, + help="Max concurrent resolutions (default: 3)", + ) + parser.add_argument( + "--verbose", + action="store_true", + help="Enable verbose logging to stderr", + ) + args = parser.parse_args() + + + from forecasting_tools.agents_and_tools.auto_resolver.tui.app import ( + AutoResolverApp, + ) + + app = AutoResolverApp( + max_concurrency=args.concurrency, + initial_tournaments=args.tournament, + initial_questions=args.question, + ) + app.run() + + +if __name__ == "__main__": + main() diff --git a/forecasting_tools/agents_and_tools/auto_resolver/tui/app.py b/forecasting_tools/agents_and_tools/auto_resolver/tui/app.py new file mode 100644 index 0000000..2a25c5b --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/tui/app.py @@ -0,0 +1,418 @@ +"""Main Textual application for the Auto Resolver TUI.""" + +from __future__ import annotations + +import asyncio +import random +import sys +from datetime import datetime +from pathlib import Path +from typing import Literal, Optional, cast + +from textual.app import App, ComposeResult +from textual.binding import Binding +from textual.containers import Horizontal +from textual.widgets import Button, Footer, Header + +from forecasting_tools import MetaculusClient, ApiFilter +from forecasting_tools.data_models.questions import MetaculusQuestion, QuestionBasicType +from forecasting_tools.helpers.metaculus_client import QuestionStateAsString +from forecasting_tools.agents_and_tools.auto_resolver.agentic import AgenticResolver +from forecasting_tools.agents_and_tools.auto_resolver.tui.models import ( + HOME_SENTINEL_ID, + QuestionItem, + QuestionSelected, +) +from forecasting_tools.agents_and_tools.auto_resolver.tui.resolver_worker import ( + FeedEvent, + ResolutionComplete, + run_resolution, +) +from forecasting_tools.agents_and_tools.auto_resolver.tui.widgets.sidebar import ( + Sidebar, +) +from forecasting_tools.agents_and_tools.auto_resolver.tui.widgets.feed_panel import ( + FeedPanel, +) +from forecasting_tools.agents_and_tools.auto_resolver.tui.widgets.home_panel import ( + HomePanel, +) +from forecasting_tools.agents_and_tools.auto_resolver.tui.report import ( + generate_markdown_report, +) +from forecasting_tools.agents_and_tools.auto_resolver.tui.widgets.input_modal import ( + AddIdRequested, + InputModal, +) +class AutoResolverApp(App): + """TUI application for interactive agentic question resolution. + + Layout: + [Sidebar (question list)] | [Home Panel / Feed Panel] + + Keybindings: + a -- Add a question by post ID + t -- Add questions from a tournament + r -- Re-run resolution on the selected question + e -- Export report to markdown + q -- Quit + """ + + TITLE = "Auto Resolver TUI" + CSS = """ + Screen { + layout: horizontal; + } + #main-area { + width: 1fr; + height: 1fr; + } + """ + + BINDINGS = [ + Binding("a", "add_question", "Add Question", show=True), + Binding("t", "add_tournament", "Add Tournament", show=True), + Binding("r", "rerun", "Re-run Selected", show=True), + Binding("e", "export_report", "Export Report", show=True), + Binding("q", "quit", "Quit", show=True), + ] + + def __init__( + self, + max_concurrency: int = 3, + initial_tournaments: list[int | str] | None = None, + initial_questions: list[int] | None = None, + ) -> None: + super().__init__() + self._resolver = AgenticResolver() + self._client = MetaculusClient() + self._items: dict[int, QuestionItem] = {} + self._selected_post_id: Optional[int] = HOME_SENTINEL_ID + self._concurrency_sem = asyncio.Semaphore(max_concurrency) + self._initial_tournaments = initial_tournaments or [] + self._initial_questions = initial_questions or [] + self._original_stderr = sys.stderr + + # ------------------------------------------------------------------ + # Layout + # ------------------------------------------------------------------ + + def compose(self) -> ComposeResult: + yield Header() + with Horizontal(id="main-area"): + yield Sidebar(id="sidebar") + yield HomePanel(id="home-panel") + yield FeedPanel(id="feed-panel") + yield Footer() + + @property + def sidebar(self) -> Sidebar: + return self.query_one("#sidebar", Sidebar) + + @property + def feed_panel(self) -> FeedPanel: + return self.query_one("#feed-panel", FeedPanel) + + @property + def home_panel(self) -> HomePanel: + return self.query_one("#home-panel", HomePanel) + + + # ------------------------------------------------------------------ + # Lifecycle + # ------------------------------------------------------------------ + + async def on_mount(self) -> None: + """Load any questions / tournaments passed via CLI.""" + # Start with home panel visible, feed/log panels hidden + self.feed_panel.display = False + self.home_panel.display = True + + # Redirect sys.stderr so that non-logging stderr writes (e.g. + # from C extensions, Python warnings, litellm debug output) are + # also captured instead of corrupting the TUI display. + self._original_stderr = sys.stderr + + for tid in self._initial_tournaments: + self._schedule_load_tournament(tid) + for qid in self._initial_questions: + self._schedule_load_question(qid) + + # ------------------------------------------------------------------ + # View switching + # ------------------------------------------------------------------ + + def _show_home(self) -> None: + """Switch to the home overview panel.""" + self.home_panel.display = True + self.feed_panel.display = False + self.home_panel.refresh_table(self._items) + + def _show_feed(self, item: QuestionItem | None) -> None: + """Switch to the feed panel for a specific question.""" + self.home_panel.display = False + self.feed_panel.display = True + self.feed_panel.show_question(item) + + # ------------------------------------------------------------------ + # Actions (keybindings) + # ------------------------------------------------------------------ + + def action_add_question(self) -> None: + self.push_screen(InputModal(default_type="question")) + + def action_add_tournament(self) -> None: + self.push_screen(InputModal(default_type="tournament")) + + def action_rerun(self) -> None: + pid = self.sidebar.get_selected_post_id() + if pid and pid in self._items: + item = self._items[pid] + if item.status not in ("running",): + self._start_resolution(item) + + def action_export_report(self) -> None: + """Export the current results to a markdown file.""" + if not self._items: + self.notify("No questions to export.", severity="warning") + return + + report = self._generate_markdown_report() + + reports_dir = Path("reports") + reports_dir.mkdir(parents=True, exist_ok=True) + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") + filepath = reports_dir / f"tui_report_{timestamp}.md" + + filepath.write_text(report, encoding="utf-8") + self.notify(f"Report exported to {filepath}") + + + # ------------------------------------------------------------------ + # Message handlers + # ------------------------------------------------------------------ + + def on_button_pressed(self, event: Button.Pressed) -> None: + """Handle sidebar button clicks.""" + if event.button.id == "btn-add-tournament": + self.action_add_tournament() + elif event.button.id == "btn-add-question": + self.action_add_question() + + def on_add_id_requested(self, message: AddIdRequested) -> None: + if message.id_type == "tournament": + self._schedule_load_tournament( + message.id_value, + allowed_types=message.allowed_types, + max_questions=message.max_questions, + exclude_unresolved=message.exclude_unresolved, + ) + else: + self._schedule_load_question(int(message.id_value)) + + def on_question_selected(self, message: QuestionSelected) -> None: + self._selected_post_id = message.post_id + + if message.post_id == HOME_SENTINEL_ID: + self._show_home() + else: + item = self._items.get(message.post_id) + self._show_feed(item) + + def on_feed_event(self, message: FeedEvent) -> None: + """Route a live feed event to the feed panel if it's for the selected question.""" + if message.post_id == self._selected_post_id: + self.feed_panel.feed_log.append_event(message.event_type, message.text) + # Also update the sidebar entry + item = self._items.get(message.post_id) + if item: + self._refresh_sidebar_entry(item) + + def on_resolution_complete(self, message: ResolutionComplete) -> None: + """Handle completion: refresh sidebar + header if selected, refresh home table.""" + item = self._items.get(message.post_id) + if item: + self._refresh_sidebar_entry(item) + # Flush any remaining text in the feed log + if message.post_id == self._selected_post_id: + self.feed_panel.feed_log.flush_text() + self.feed_panel.header.render_item(item) + + # Always refresh home table so it stays up to date + if self.home_panel.display: + self.home_panel.refresh_table(self._items) + + # ------------------------------------------------------------------ + # Internal helpers + # ------------------------------------------------------------------ + + def _schedule_load_question(self, post_id: int) -> None: + """Kick off an async worker to load a single question from Metaculus.""" + self.run_worker(self._load_question(post_id), exclusive=False) + + def _schedule_load_tournament( + self, + tournament_id: int | str, + allowed_types: list[QuestionBasicType] | None = None, + max_questions: int | None = None, + exclude_unresolved: bool = False, + ) -> None: + """Kick off an async worker to load all questions from a tournament.""" + self.run_worker( + self._load_tournament( + tournament_id, + allowed_types=allowed_types, + max_questions=max_questions, + exclude_unresolved=exclude_unresolved, + ), + exclusive=False, + ) + + async def _load_question(self, post_id: int) -> None: + """Fetch a single question by post ID and add it to the list.""" + if post_id in self._items: + self.notify(f"Question {post_id} already loaded.", severity="warning") + return + + self.notify(f"Loading question {post_id}...") + try: + question = await asyncio.to_thread( + self._client.get_question_by_post_id, post_id + ) + except Exception as e: + self.notify(f"Failed to load question {post_id}: {e}", severity="error") + return + + if isinstance(question, list): + self.notify( + f"Question {post_id} is a group question (not supported). Skipping.", + severity="warning", + ) + return + + self._add_question(question) + + async def _load_tournament( + self, + tournament_id: int | str, + allowed_types: list[QuestionBasicType] | None = None, + max_questions: int | None = None, + exclude_unresolved: bool = False, + ) -> None: + """Fetch questions from a tournament and add them. + + Pages are fetched one at a time on a background thread so the + event loop stays free and the UI remains responsive. When no + random sampling is needed (``max_questions is None``), questions + are added to the sidebar as each page arrives. When random + sampling *is* requested, all pages are collected first, then a + random subset is sampled and added. + """ + self.notify(f"Loading tournament {tournament_id}...") + try: + allowed_statuses: list[QuestionStateAsString] | None = None + if exclude_unresolved: + allowed_statuses = cast( + list[QuestionStateAsString], ["resolved"] + ) + + api_filter = ApiFilter( + allowed_tournaments=[tournament_id], + allowed_types=allowed_types or ["binary"], + allowed_statuses=allowed_statuses, + group_question_mode="exclude", + order_by="-published_time", + ) + + # Fetch page-by-page on a thread so we don't block the + # event loop (the underlying client uses time.sleep + + # requests.get which are synchronous). + page_size = self._client.MAX_QUESTIONS_FROM_QUESTION_API_PER_REQUEST + all_questions: list[MetaculusQuestion] = [] + added = 0 + page_num = 0 + more_available = True + needs_sampling = max_questions is not None + + while more_available: + offset = page_num * page_size + new_questions, continue_searching = await asyncio.to_thread( + self._client._grab_filtered_questions_with_offset, + api_filter, + offset, + ) + + if needs_sampling: + # Collect for later random sampling + all_questions.extend(new_questions) + else: + # Add to sidebar immediately — no sampling needed + for q in new_questions: + if q.id_of_post and q.id_of_post not in self._items: + self._add_question(q) + added += 1 + + if not continue_searching: + more_available = False + page_num += 1 + + # Apply random sampling if max_questions was requested + if needs_sampling: + if max_questions is not None and len(all_questions) > max_questions: + all_questions = random.sample(all_questions, max_questions) + for q in all_questions: + if q.id_of_post and q.id_of_post not in self._items: + self._add_question(q) + added += 1 + + except Exception as e: + self.notify( + f"Failed to load tournament {tournament_id}: {e}", severity="error" + ) + return + + self.notify(f"Loaded {added} questions from tournament {tournament_id}.") + + # Refresh home table after batch load + if self.home_panel.display: + self.home_panel.refresh_table(self._items) + + def _add_question(self, question: MetaculusQuestion) -> None: + """Register a question and add it to the sidebar, then start resolution.""" + post_id = question.id_of_post + if post_id is None: + return + item = QuestionItem(question=question) + self._items[post_id] = item + + display = f"{item.status_icon} [{post_id}] {item.title}" + self.sidebar.add_question_entry(post_id, display) + + # Refresh home table if visible + if self.home_panel.display: + self.home_panel.refresh_table(self._items) + + # Start resolution immediately + self._start_resolution(item) + + def _start_resolution(self, item: QuestionItem) -> None: + """Launch a bounded async worker for resolution.""" + + async def _bounded_resolve() -> None: + async with self._concurrency_sem: + await run_resolution(item, self._resolver, self.sidebar) + + self.run_worker(_bounded_resolve(), exclusive=False) + + def _refresh_sidebar_entry(self, item: QuestionItem) -> None: + """Update the sidebar text for a question.""" + display = f"{item.status_icon} [{item.post_id}] {item.title}" + self.sidebar.update_question_entry(item.post_id, display) + + # ------------------------------------------------------------------ + # Markdown report generation + # ------------------------------------------------------------------ + + def _generate_markdown_report(self) -> str: + """Build a markdown report matching the assess.py format.""" + return generate_markdown_report(self._items) diff --git a/forecasting_tools/agents_and_tools/auto_resolver/tui/models.py b/forecasting_tools/agents_and_tools/auto_resolver/tui/models.py new file mode 100644 index 0000000..1ce9b30 --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/tui/models.py @@ -0,0 +1,78 @@ +"""Data models for TUI question state tracking.""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import Literal, Optional + +from textual.message import Message + +from forecasting_tools.data_models.questions import MetaculusQuestion, ResolutionType + + +# Sentinel post_id used by the "Home" sidebar entry. +HOME_SENTINEL_ID: int = -1 + + +class QuestionSelected(Message): + """Posted when the user selects a question in the sidebar list or home table.""" + + def __init__(self, post_id: int) -> None: + super().__init__() + self.post_id = post_id + + +QuestionStatus = Literal["pending", "running", "completed", "error"] + + +@dataclass +class QuestionItem: + """Tracks the state of a single question through the resolution pipeline. + + Attributes: + question: The Metaculus question being resolved. + status: Current resolution status. + resolution: The typed resolution result, or None if not yet resolved. + resolution_status_str: Raw status string from the resolver + (e.g. "TRUE", "FALSE", "NOT_YET_RESOLVABLE"). + resolution_metadata: Reasoning and key evidence from the resolver. + feed_lines: Accumulated agent feed messages for the live log. + error_message: Error details if status is "error". + """ + + question: MetaculusQuestion + status: QuestionStatus = "pending" + resolution: Optional[ResolutionType] = None + resolution_status_str: Optional[str] = None + resolution_metadata: Optional[dict] = None + feed_lines: list[str] = field(default_factory=list) + error_message: Optional[str] = None + cost: float = 0.0 + + @property + def post_id(self) -> int: + return self.question.id_of_post # type: ignore[return-value] + + @property + def title(self) -> str: + text = self.question.question_text or "Untitled" + return text[:80] + ("..." if len(text) > 80 else "") + + @property + def status_icon(self) -> str: + return { + "pending": " -- ", + "running": " >> ", + "completed": " OK ", + "error": " !! ", + }[self.status] + + @property + def resolution_display(self) -> str: + if self.status == "error": + return f"Error: {self.error_message or 'unknown'}" + if self.resolution_status_str is not None: + return self.resolution_status_str + if self.status == "running": + return "Resolving..." + return "Pending" diff --git a/forecasting_tools/agents_and_tools/auto_resolver/tui/report.py b/forecasting_tools/agents_and_tools/auto_resolver/tui/report.py new file mode 100644 index 0000000..2a86487 --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/tui/report.py @@ -0,0 +1,249 @@ +"""Shared report / confusion-matrix logic for the TUI. + +Builds a ``ResolutionAssessmentReport`` from a dict of ``QuestionItem`` +objects so both the home panel and the markdown export can reuse the same +data and formatting that ``assess.py`` already provides. +""" + +from __future__ import annotations + +from datetime import datetime +from typing import Optional + +from forecasting_tools.agents_and_tools.auto_resolver.assess import ( + QuestionAssessmentResult, + ResolutionAssessmentReport, +) +from forecasting_tools.agents_and_tools.auto_resolver.tui.models import QuestionItem +from forecasting_tools.data_models.questions import ( + BinaryResolution, + CanceledResolution, + ResolutionType, +) + + +# ------------------------------------------------------------------ +# Mapping resolver status strings to typed resolutions +# ------------------------------------------------------------------ + +def _status_str_to_resolution(status: str | None) -> Optional[ResolutionType]: + """Convert a resolution_status_str (e.g. 'TRUE') to a typed resolution.""" + if status is None: + return + s = status.strip().upper() + if s == "TRUE": + return True + elif s == "FALSE": + return False + elif s == "AMBIGUOUS": + return CanceledResolution.AMBIGUOUS + elif s == "ANNULLED": + return CanceledResolution.ANNULLED + elif s == "NOT_YET_RESOLVABLE": + return None + + +# ------------------------------------------------------------------ +# Build a ResolutionAssessmentReport from TUI items +# ------------------------------------------------------------------ + +def build_report_from_items( + items: dict[int, QuestionItem], +) -> ResolutionAssessmentReport: + """Populate a ``ResolutionAssessmentReport`` from the TUI question items. + + Only completed items whose questions have a ground-truth resolution are + included in the confusion matrix. Items that are still pending / running / + errored are silently skipped. + """ + report = ResolutionAssessmentReport() + + for post_id, item in items.items(): + if item.status != "completed": + continue + + true_resolution = item.question.typed_resolution + predicted_resolution = _status_str_to_resolution(item.resolution_status_str) + + key_evidence: list[str] | None = None + if item.resolution_metadata: + key_evidence = item.resolution_metadata.get("key_evidence") + + outcome_category: str | None = None + + # Classify into the confusion matrix — mirrors assess.py logic + if isinstance(true_resolution, bool): + match true_resolution, predicted_resolution: + # Positive actual + case True, True: + report.pp.append(post_id) + outcome_category = "True Positive" + case True, False: + report.np.append(post_id) + outcome_category = "False Negative" + case True, None: + report.xp.append(post_id) + outcome_category = "Missed Positive" + case True, CanceledResolution(): + report.cp.append(post_id) + outcome_category = "Positive Incorrectly Predicted as Cancelled" + # Negative actual + case False, True: + report.pn.append(post_id) + outcome_category = "False Positive" + case False, False: + report.nn.append(post_id) + outcome_category = "True Negative" + case False, None: + report.xn.append(post_id) + outcome_category = "Missed Negative" + case False, CanceledResolution(): + report.cn.append(post_id) + outcome_category = "Negative Incorrectly Predicted as Cancelled" + case _: + if true_resolution is True: + report.xp.append(post_id) + outcome_category = "Unmatched - Positive" + else: + report.xn.append(post_id) + outcome_category = "Unmatched - Negative" + + elif isinstance(true_resolution, CanceledResolution): + match predicted_resolution: + case True: + report.pc.append(post_id) + outcome_category = "Cancelled Incorrectly Predicted as Positive" + case False: + report.nc.append(post_id) + outcome_category = "Cancelled Incorrectly Predicted as Negative" + case CanceledResolution(): + report.cc.append(post_id) + outcome_category = "Correct Cancel" + case None: + report.xc.append(post_id) + outcome_category = "Cancelled Not Answered" + case _: + report.xc.append(post_id) + outcome_category = "Unmatched - Cancelled" + + elif true_resolution is None: + match predicted_resolution: + case True: + report.nyr_p.append(post_id) + outcome_category = "Not Yet Resolvable Predicted as Positive" + case False: + report.nyr_n.append(post_id) + outcome_category = "Not Yet Resolvable Predicted as Negative" + case CanceledResolution(): + report.nyr_c.append(post_id) + outcome_category = "Not Yet Resolvable Predicted as Cancelled" + case None: + report.nyr_nyr.append(post_id) + outcome_category = "Correct Not Yet Resolvable" + case _: + report.nyr_x.append(post_id) + outcome_category = "Unmatched - Not Yet Resolvable" + else: + # Unknown resolution type — skip from matrix + continue + + question_result = QuestionAssessmentResult( + question_id=post_id, + question_title=(item.question.question_text or "No title")[:100], + question_text=item.question.question_text or "No text available", + question_url=item.question.page_url or f"https://metaculus.com/{post_id}", + actual_resolution=true_resolution, + predicted_resolution=predicted_resolution, + key_evidence=key_evidence, + outcome_category=outcome_category, + ) + report.question_results[post_id] = question_result + + return report + + +# ------------------------------------------------------------------ +# Full markdown report (mirrors assess.py detailed_report + cost) +# ------------------------------------------------------------------ + +def generate_markdown_report(items: dict[int, QuestionItem]) -> str: + """Generate a markdown report matching the ``assess.py`` format, with cost info.""" + report = build_report_from_items(items) + + total_cost = sum(item.cost for item in items.values()) + + lines: list[str] = [] + lines.append("# Auto Resolver Assessment Report\n") + lines.append(f"**Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n") + + # Summary section + lines.append("## Summary\n") + lines.append(report.binary_results_table()) + lines.append("") + + # Totals + total = ( + report.n_pp + report.n_pn + report.n_pc + + report.n_np + report.n_nn + report.n_nc + + report.n_cp + report.n_cn + report.n_cc + + report.n_xp + report.n_xn + report.n_xc + + report.n_nyr_p + report.n_nyr_n + report.n_nyr_c + + report.n_nyr_nyr + ) + correct = report.n_pp + report.n_nn + report.n_cc + report.n_nyr_nyr + accuracy = (correct / total * 100) if total > 0 else 0 + + lines.append(f"**Total Questions:** {total}") + lines.append(f"**Correct Predictions:** {correct} ({accuracy:.1f}%)") + lines.append(f"**Total Cost:** ${total_cost:.4f}") + lines.append("") + + # Detailed results section + lines.append("## Detailed Results\n") + lines.append("") + + # Sort by category then question ID (same as assess.py) + sorted_results = sorted( + report.question_results.values(), + key=lambda x: (x.outcome_category or "", x.question_id), + ) + + for result in sorted_results: + lines.append(f"### Question {result.question_id}\n") + lines.append(f"**Title:** {result.question_title}") + lines.append(f"**URL:** {result.question_url}") + lines.append("") + + # Question contents + lines.append("**Question Contents:**\n") + lines.append("> " + result.question_text.replace("\n", "\n> ")) + lines.append("") + + # Resolution comparison table + lines.append("| Output Resolution | Correct Resolution |") + lines.append("|-------------------|--------------------|") + actual_str = ResolutionAssessmentReport._resolution_to_str( + result.actual_resolution + ) + predicted_str = ResolutionAssessmentReport._resolution_to_str( + result.predicted_resolution + ) + lines.append(f"| {predicted_str} | {actual_str} |") + lines.append("") + + # Cost per question + item = items.get(result.question_id) + if item and item.cost > 0: + lines.append(f"**Cost:** ${item.cost:.4f}") + lines.append("") + + # Key evidence + if result.key_evidence: + lines.append("**Key Evidence:**") + for evidence in result.key_evidence: + lines.append(f"- {evidence}") + lines.append("") + + lines.append("---\n") + + return "\n".join(lines) diff --git a/forecasting_tools/agents_and_tools/auto_resolver/tui/resolver_worker.py b/forecasting_tools/agents_and_tools/auto_resolver/tui/resolver_worker.py new file mode 100644 index 0000000..531673d --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/tui/resolver_worker.py @@ -0,0 +1,128 @@ +"""Async worker that runs the streaming AgenticResolver and posts events to the TUI.""" + +from __future__ import annotations + +import logging +from typing import TYPE_CHECKING + +from textual.message import Message +from textual.widget import Widget + +from forecasting_tools.agents_and_tools.auto_resolver.agentic import AgenticResolver +from forecasting_tools.agents_and_tools.auto_resolver.tui.models import QuestionItem +from forecasting_tools.ai_models.resource_managers.monetary_cost_manager import ( + MonetaryCostManager, +) + +if TYPE_CHECKING: + from forecasting_tools.data_models.questions import MetaculusQuestion + +logger = logging.getLogger(__name__) + + +# --------------------------------------------------------------------------- +# Textual Messages posted by the worker so the App can react +# --------------------------------------------------------------------------- + +class FeedEvent(Message): + """A single line of agent feed output for a question.""" + + def __init__(self, post_id: int, event_type: str, text: str) -> None: + super().__init__() + self.post_id = post_id + self.event_type = event_type + self.text = text + + +class ResolutionComplete(Message): + """Emitted when a question's resolution finishes (success or error).""" + + def __init__(self, post_id: int) -> None: + super().__init__() + self.post_id = post_id + + +# --------------------------------------------------------------------------- +# Worker coroutine +# --------------------------------------------------------------------------- + +async def run_resolution( + item: QuestionItem, + resolver: AgenticResolver, + poster: Widget, +) -> None: + """Run streaming resolution on a single question, posting messages to the TUI. + + This is intended to be called via Textual's Worker system + (e.g. ``self.run_worker(run_resolution(...))``) so it executes + on a background asyncio task while the UI remains responsive. + + Args: + item: The QuestionItem to resolve -- mutated in place. + resolver: The AgenticResolver instance (shared, but each call is independent). + poster: A Textual Widget whose ``.post_message()`` method will be used + to deliver events back to the app's message loop. + """ + item.status = "running" + item.feed_lines.clear() + item.cost = 0.0 + post_id = item.post_id + + cost_manager = MonetaryCostManager(hard_limit=0) + + try: + with cost_manager: + async for event_type, text in resolver.resolve_question_streamed(item.question): + # Accumulate non-delta lines (deltas are single tokens, too noisy individually) + if event_type == "text": + # For text deltas we still post them but accumulate separately + poster.post_message(FeedEvent(post_id, event_type, text)) + elif event_type == "error": + item.feed_lines.append(f"[ERROR] {text}") + item.status = "error" + item.error_message = text + item.cost = cost_manager.current_usage + poster.post_message(FeedEvent(post_id, event_type, text)) + poster.post_message(ResolutionComplete(post_id)) + return + elif event_type == "result": + item.feed_lines.append(text) + # Extract resolution info directly from the result text + # to avoid race conditions with shared resolver state. + lines = text.splitlines() + for line in lines: + if line.startswith("Resolution: "): + item.resolution_status_str = line.removeprefix("Resolution: ").strip() + elif line.startswith("Reasoning: "): + reasoning = line.removeprefix("Reasoning: ").strip() + item.resolution_metadata = item.resolution_metadata or {} + item.resolution_metadata["reasoning"] = reasoning + # Gather key evidence lines + evidence: list[str] = [] + in_evidence = False + for line in lines: + if line.strip() == "Key Evidence:": + in_evidence = True + continue + if in_evidence and line.strip().startswith("- "): + evidence.append(line.strip().removeprefix("- ")) + if evidence: + item.resolution_metadata = item.resolution_metadata or {} + item.resolution_metadata["key_evidence"] = evidence + + item.status = "completed" + poster.post_message(FeedEvent(post_id, event_type, text)) + else: + # "status" or "tool" events + item.feed_lines.append(text) + poster.post_message(FeedEvent(post_id, event_type, text)) + + except Exception as exc: + logger.exception("Resolution failed for question %s", post_id) + item.status = "error" + item.error_message = str(exc) + item.feed_lines.append(f"[EXCEPTION] {exc}") + poster.post_message(FeedEvent(post_id, "error", str(exc))) + + item.cost = cost_manager.current_usage + poster.post_message(ResolutionComplete(post_id)) diff --git a/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/__init__.py b/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/__init__.py new file mode 100644 index 0000000..7bbdce1 --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/__init__.py @@ -0,0 +1 @@ +"""TUI widget components for the auto resolver interface.""" diff --git a/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/feed_panel.py b/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/feed_panel.py new file mode 100644 index 0000000..35e7535 --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/feed_panel.py @@ -0,0 +1,189 @@ +"""Main content panel showing resolution status and live agent feed.""" + +from __future__ import annotations + +from typing import Optional + +from textual.app import ComposeResult +from textual.containers import Vertical +from textual.widgets import RichLog, Static + +from forecasting_tools.agents_and_tools.auto_resolver.tui.models import QuestionItem + + +# --------------------------------------------------------------------------- +# Helpers for normalising and colour-coding resolution values +# --------------------------------------------------------------------------- + +def _resolution_color(value: str) -> str: + """Return a Rich colour name for a resolution string.""" + v = value.strip().upper() + if v == "TRUE": + return "green" + elif v == "FALSE": + return "red" + elif v in ("NOT_YET_RESOLVABLE", "NOT YET RESOLVABLE", "RESOLVING...", "PENDING"): + return "yellow" + else: + return "cyan" # AMBIGUOUS, ANNULLED, errors, etc. + + +def _normalize_ground_truth(raw: str | None) -> str: + """Convert Metaculus ground-truth strings to True/False style.""" + if raw is None: + return "Not Yet Resolvable" + lowered = raw.strip().lower() + if lowered == "yes": + return "True" + elif lowered == "no": + return "False" + elif lowered == "ambiguous": + return "Ambiguous" + elif lowered == "annulled": + return "Annulled" + else: + return raw + + +class ResolutionHeader(Static): + """Displays the resolution status and metadata for the selected question.""" + + DEFAULT_CSS = """ + ResolutionHeader { + dock: top; + height: auto; + max-height: 14; + padding: 1 2; + background: $surface; + border-bottom: solid $primary; + color: $text; + } + """ + + def render_item(self, item: Optional[QuestionItem]) -> None: + if item is None: + self.update("No question selected. Press [bold]a[/bold] to add questions.") + return + + parts: list[str] = [] + parts.append(f"[bold]{item.question.question_text or 'Untitled'}[/bold]") + + if item.question.page_url: + parts.append(f"[dim]{item.question.page_url}[/dim]") + + # Predicted resolution line (colour-coded) + parts.append("") + resolution_str = item.resolution_display + res_color = _resolution_color(resolution_str) + parts.append( + f"Predicted: [{res_color}]{resolution_str}[/{res_color}]" + ) + + # Ground truth (normalised and colour-coded) + gt_normalized = _normalize_ground_truth(item.question.resolution_string) + gt_color = _resolution_color(gt_normalized) + parts.append( + f"Ground Truth: [{gt_color}]{gt_normalized}[/{gt_color}]" + ) + + # Cost + if item.cost > 0: + parts.append(f"Cost: [bold]${item.cost:.4f}[/bold]") + + # Metadata (reasoning + evidence) once available + if item.resolution_metadata: + reasoning = item.resolution_metadata.get("reasoning", "") + if reasoning: + parts.append("") + parts.append(f"[italic]Reasoning:[/italic] {reasoning}") + evidence = item.resolution_metadata.get("key_evidence", []) + if evidence: + parts.append("[italic]Evidence:[/italic]") + for ev in evidence: + parts.append(f" - {ev}") + + self.update("\n".join(parts)) + + +class AgentFeedLog(RichLog): + """Scrollable live log of agent events.""" + + DEFAULT_CSS = """ + AgentFeedLog { + height: 1fr; + border-top: solid $accent; + padding: 0 1; + } + """ + + def __init__(self, **kwargs) -> None: + super().__init__(highlight=True, markup=True, wrap=True, **kwargs) + self._current_text_block: str = "" + + def append_event(self, event_type: str, text: str) -> None: + """Append a single event to the log with type-appropriate styling.""" + if event_type == "text": + # Accumulate text deltas into a running block rather than one-per-token + self._current_text_block += text + return + else: + # Flush any accumulated text block first + self._flush_text_block() + + if event_type == "status": + self.write(f"[bold blue]>>> {text}[/bold blue]") + elif event_type == "tool": + self.write(f"[yellow]{text}[/yellow]") + elif event_type == "result": + self.write(f"[bold green]--- RESULT ---[/bold green]") + self.write(f"[green]{text}[/green]") + elif event_type == "error": + self.write(f"[bold red]ERROR: {text}[/bold red]") + else: + self.write(text) + + def flush_text(self) -> None: + """Flush any buffered text delta block to the log.""" + self._flush_text_block() + + def _flush_text_block(self) -> None: + if self._current_text_block: + self.write(self._current_text_block) + self._current_text_block = "" + + def clear_feed(self) -> None: + """Clear the log and reset state.""" + self._current_text_block = "" + self.clear() + + +class FeedPanel(Vertical): + """Composite widget: resolution header + scrollable agent feed log.""" + + DEFAULT_CSS = """ + FeedPanel { + width: 1fr; + height: 1fr; + } + """ + + def compose(self) -> ComposeResult: + yield ResolutionHeader(id="resolution-header") + yield AgentFeedLog(id="agent-feed-log") + + @property + def header(self) -> ResolutionHeader: + return self.query_one("#resolution-header", ResolutionHeader) + + @property + def feed_log(self) -> AgentFeedLog: + return self.query_one("#agent-feed-log", AgentFeedLog) + + def show_question(self, item: Optional[QuestionItem]) -> None: + """Switch the panel to display a specific question's data.""" + self.header.render_item(item) + self.feed_log.clear_feed() + if item is not None: + # Replay existing feed lines + for line in item.feed_lines: + self.feed_log.write(line) diff --git a/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/home_panel.py b/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/home_panel.py new file mode 100644 index 0000000..03ccad6 --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/home_panel.py @@ -0,0 +1,166 @@ +"""Home panel showing a live-updating confusion matrix and question table.""" + +from __future__ import annotations + +from textual.app import ComposeResult +from textual.containers import Vertical +from textual.widgets import DataTable, Static + +from forecasting_tools.agents_and_tools.auto_resolver.tui.models import ( + HOME_SENTINEL_ID, + QuestionItem, + QuestionSelected, +) +from forecasting_tools.agents_and_tools.auto_resolver.tui.report import ( + build_report_from_items, +) +from forecasting_tools.agents_and_tools.auto_resolver.tui.widgets.feed_panel import ( + _normalize_ground_truth, +) + + +def _normalize_for_compare(s: str) -> str: + """Normalize a resolution string for comparison (uppercase, underscores for spaces).""" + return s.strip().upper().replace(" ", "_") + + +def _match_str(predicted: str | None, ground_truth: str | None) -> str: + """Return a match indicator comparing predicted and ground truth.""" + if predicted is None or ground_truth is None: + return "-" + p = _normalize_for_compare(predicted) + g = _normalize_for_compare(ground_truth) + if p in ("PENDING", "RESOLVING..."): + return "-" + if g in ("", "NONE", "-"): + return "-" + return "Y" if p == g else "N" + + +class HomePanel(Vertical): + """Overview panel with confusion matrix, question table, and summary.""" + + DEFAULT_CSS = """ + HomePanel { + width: 1fr; + height: 1fr; + } + HomePanel > #home-title { + dock: top; + text-align: center; + text-style: bold; + padding: 1 2; + background: $surface; + border-bottom: solid $primary; + } + HomePanel > #home-matrix { + dock: top; + height: auto; + padding: 1 2; + background: $surface; + border-bottom: solid $accent; + } + HomePanel > DataTable { + height: 1fr; + } + HomePanel > #home-summary { + dock: bottom; + height: auto; + padding: 1 2; + background: $surface; + border-top: solid $primary; + } + """ + + def compose(self) -> ComposeResult: + yield Static("Auto Resolver - Overview", id="home-title") + yield Static("", id="home-matrix") + table: DataTable = DataTable(id="home-table") + table.cursor_type = "row" + table.zebra_stripes = True + yield table + yield Static("No questions loaded.", id="home-summary") + + def on_mount(self) -> None: + table = self.query_one("#home-table", DataTable) + table.add_columns( + "ID", "Question", "Status", "Predicted", "Ground Truth", "Match", "Cost" + ) + + def on_data_table_row_selected(self, event: DataTable.RowSelected) -> None: + """Navigate to the selected question's feed view.""" + try: + post_id = int(str(event.row_key.value)) + except (ValueError, TypeError): + return + self.post_message(QuestionSelected(post_id)) + + def refresh_table(self, items: dict[int, QuestionItem]) -> None: + """Rebuild the confusion matrix, table rows, and summary.""" + table = self.query_one("#home-table", DataTable) + table.clear() + + total = 0 + completed = 0 + correct = 0 + total_cost = 0.0 + + for post_id, item in items.items(): + total += 1 + total_cost += item.cost + + predicted = item.resolution_display + gt_raw = item.question.resolution_string + gt = _normalize_ground_truth(gt_raw) if gt_raw else "Not Yet Resolvable" + match = _match_str(predicted, gt) + + if item.status == "completed": + completed += 1 + if match == "Y": + correct += 1 + + cost_str = f"${item.cost:.4f}" if item.cost > 0 else "-" + + table.add_row( + str(post_id), + item.title, + item.status.title(), + predicted, + gt, + match, + cost_str, + key=str(post_id), + ) + + # --- Confusion matrix --- + report = build_report_from_items(items) + matrix_text = report.binary_results_table() + + matrix_total = ( + report.n_pp + report.n_pn + report.n_pc + + report.n_np + report.n_nn + report.n_nc + + report.n_cp + report.n_cn + report.n_cc + + report.n_xp + report.n_xn + report.n_xc + + report.n_nyr_p + report.n_nyr_n + report.n_nyr_c + + report.n_nyr_nyr + ) + matrix_correct = report.n_pp + report.n_nn + report.n_cc + report.n_nyr_nyr + matrix_accuracy = (matrix_correct / matrix_total * 100) if matrix_total > 0 else 0 + + matrix_display = ( + f"{matrix_text}\n\n" + f"Correct: {matrix_correct}/{matrix_total} " + f"Accuracy: {matrix_accuracy:.1f}%" + ) + self.query_one("#home-matrix", Static).update(matrix_display) + + # --- Summary footer --- + accuracy = (correct / completed * 100) if completed > 0 else 0 + summary_parts = [ + f"Total: {total}", + f"Completed: {completed}", + f"Correct: {correct}", + f"Accuracy: {accuracy:.1f}%", + f"Total Cost: ${total_cost:.4f}", + ] + self.query_one("#home-summary", Static).update(" | ".join(summary_parts)) diff --git a/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/input_modal.py b/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/input_modal.py new file mode 100644 index 0000000..f2cd2fe --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/input_modal.py @@ -0,0 +1,266 @@ +"""Modal dialog for adding tournament or question IDs.""" + +from __future__ import annotations + +from typing import Literal + +from textual.app import ComposeResult +from textual.containers import Vertical, Horizontal +from textual.message import Message +from textual.reactive import reactive +from textual.screen import ModalScreen +from textual.widgets import ( + Button, + Checkbox, + Input, + Label, + RadioButton, + RadioSet, + Static, +) + +from forecasting_tools.data_models.questions import QuestionBasicType + + +QUESTION_TYPES: list[QuestionBasicType] = [ + "binary", + "numeric", + "multiple_choice", + "date", + "discrete", + "conditional", +] + + +class AddIdRequested(Message): + """Posted when the user submits an ID from the modal.""" + + def __init__( + self, + id_type: Literal["tournament", "question"], + id_value: int | str, + allowed_types: list[QuestionBasicType] | None = None, + max_questions: int | None = None, + exclude_unresolved: bool = False, + ) -> None: + super().__init__() + self.id_type = id_type + self.id_value = id_value + self.allowed_types = allowed_types or ["binary"] + self.max_questions = max_questions + self.exclude_unresolved = exclude_unresolved + + +class InputModal(ModalScreen[None]): + """A modal screen for entering a tournament or question ID.""" + + DEFAULT_CSS = """ + InputModal { + align: center middle; + } + InputModal > #modal-container { + width: 60; + height: auto; + max-height: 40; + overflow-y: auto; + background: $surface; + border: thick $primary; + padding: 2 3; + } + InputModal > #modal-container > #modal-title { + text-align: center; + text-style: bold; + margin-bottom: 1; + } + InputModal > #modal-container > RadioSet { + height: auto; + margin-bottom: 1; + } + InputModal > #modal-container > Input { + margin-bottom: 1; + } + InputModal > #modal-container > #tournament-options { + height: auto; + margin-bottom: 1; + padding: 1; + background: $boost; + } + InputModal > #modal-container > #tournament-options > .option-label { + text-style: bold; + margin-bottom: 1; + } + InputModal > #modal-container > #tournament-options > #type-checkboxes { + height: auto; + margin-bottom: 1; + } + InputModal > #modal-container > #tournament-options > #type-checkboxes Checkbox { + height: auto; + padding: 0; + margin: 0; + } + InputModal > #modal-container > #tournament-options > #filters-section { + height: auto; + margin-bottom: 1; + } + InputModal > #modal-container > #tournament-options > #filters-section Checkbox { + height: auto; + padding: 0; + margin: 0; + } + InputModal > #modal-container > #modal-buttons { + height: auto; + align: center middle; + } + InputModal > #modal-container > #modal-buttons > Button { + margin: 0 2; + } + InputModal > #modal-container > #modal-error { + color: $error; + height: auto; + margin-bottom: 1; + } + """ + + BINDINGS = [ + ("escape", "cancel", "Cancel"), + ] + + _is_tournament: reactive[bool] = reactive(False) + + def __init__(self, default_type: Literal["tournament", "question"] = "question") -> None: + super().__init__() + self._default_type = default_type + + def compose(self) -> ComposeResult: + with Vertical(id="modal-container"): + yield Label("Add Questions", id="modal-title") + yield RadioSet( + RadioButton("Tournament ID", value=self._default_type == "tournament"), + RadioButton("Question ID", value=self._default_type == "question"), + id="id-type-radio", + ) + yield Input( + placeholder="Enter ID (numeric or slug for tournaments)...", + id="id-input", + ) + with Vertical(id="tournament-options"): + yield Static("Question Types:", classes="option-label") + with Vertical(id="type-checkboxes"): + for qtype in QUESTION_TYPES: + yield Checkbox( + qtype.replace("_", " ").title(), + value=(qtype == "binary"), + id=f"cb-{qtype}", + ) + with Vertical(id="filters-section"): + yield Static("Filters:", classes="option-label") + yield Checkbox( + "Exclude unresolved questions", + value=False, + id="cb-exclude-unresolved", + ) + yield Static("Random Sample (optional):", classes="option-label") + yield Input( + placeholder="Max number of questions to load (leave empty for all)", + id="max-questions-input", + ) + yield Label("", id="modal-error") + with Horizontal(id="modal-buttons"): + yield Button("Submit", id="btn-submit", variant="primary") + yield Button("Cancel", id="btn-cancel", variant="default") + + def on_mount(self) -> None: + self.query_one("#id-input", Input).focus() + radio_set = self.query_one("#id-type-radio", RadioSet) + self._is_tournament = radio_set.pressed_index == 0 + self._update_tournament_options_visibility() + + def on_radio_set_changed(self, event: RadioSet.Changed) -> None: + if event.radio_set.id == "id-type-radio": + self._is_tournament = event.radio_set.pressed_index == 0 + self._update_tournament_options_visibility() + + def _update_tournament_options_visibility(self) -> None: + try: + tournament_options = self.query_one("#tournament-options", Vertical) + tournament_options.display = self._is_tournament + except Exception: + pass + + def action_cancel(self) -> None: + self.dismiss(None) + + def on_button_pressed(self, event: Button.Pressed) -> None: + if event.button.id == "btn-cancel": + self.dismiss(None) + elif event.button.id == "btn-submit": + self._submit() + + def on_input_submitted(self, event: Input.Submitted) -> None: + self._submit() + + def _submit(self) -> None: + error_label = self.query_one("#modal-error", Label) + raw_value = self.query_one("#id-input", Input).value.strip() + + if not raw_value: + error_label.update("Please enter an ID.") + return + + radio_set = self.query_one("#id-type-radio", RadioSet) + id_type: Literal["tournament", "question"] = ( + "tournament" if radio_set.pressed_index == 0 else "question" + ) + + id_value: int | str + try: + id_value = int(raw_value) + except ValueError: + if id_type == "question": + error_label.update("Question ID must be a numeric integer.") + return + id_value = raw_value + + allowed_types: list[QuestionBasicType] = [] + max_questions: int | None = None + exclude_unresolved = False + + if id_type == "tournament": + for qtype in QUESTION_TYPES: + try: + cb = self.query_one(f"#cb-{qtype}", Checkbox) + if cb.value: + allowed_types.append(qtype) + except Exception: + pass + + if not allowed_types: + error_label.update("Please select at least one question type.") + return + + max_input = self.query_one("#max-questions-input", Input).value.strip() + if max_input: + try: + max_questions = int(max_input) + if max_questions <= 0: + error_label.update("Max questions must be a positive number.") + return + except ValueError: + error_label.update("Max questions must be a number.") + return + + try: + exclude_unresolved = self.query_one("#cb-exclude-unresolved", Checkbox).value + except Exception: + pass + + self.app.post_message( + AddIdRequested( + id_type=id_type, + id_value=id_value, + allowed_types=allowed_types if id_type == "tournament" else None, + max_questions=max_questions, + exclude_unresolved=exclude_unresolved, + ) + ) + self.dismiss(None) diff --git a/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/sidebar.py b/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/sidebar.py new file mode 100644 index 0000000..0eab863 --- /dev/null +++ b/forecasting_tools/agents_and_tools/auto_resolver/tui/widgets/sidebar.py @@ -0,0 +1,134 @@ +"""Sidebar widget: action buttons and navigable question list.""" + +from __future__ import annotations + +from typing import Optional + +from textual.app import ComposeResult +from textual.containers import Vertical +from textual.widgets import Button, ListItem, ListView, Static + +from forecasting_tools.agents_and_tools.auto_resolver.tui.models import ( + HOME_SENTINEL_ID, + QuestionSelected, +) + + +class SidebarListItem(ListItem): + """A single entry in the sidebar question list.""" + + DEFAULT_CSS = """ + SidebarListItem { + height: auto; + padding: 0 1; + } + SidebarListItem:hover { + background: $boost; + } + SidebarListItem.-highlight { + background: $accent 30%; + } + """ + + def __init__(self, post_id: int, display_text: str, **kwargs) -> None: + super().__init__(**kwargs) + self.post_id = post_id + self._label = Static(display_text) + + def compose(self) -> ComposeResult: + yield self._label + + def update_text(self, text: str) -> None: + self._label.update(text) + + +class QuestionListView(ListView): + """Navigable list of questions with keyboard support.""" + + DEFAULT_CSS = """ + QuestionListView { + height: 1fr; + border-top: solid $primary; + } + """ + + def on_list_view_selected(self, event: ListView.Selected) -> None: + item = event.item + if isinstance(item, SidebarListItem): + self.post_message(QuestionSelected(item.post_id)) + + def on_list_view_highlighted(self, event: ListView.Highlighted) -> None: + item = event.item + if isinstance(item, SidebarListItem): + self.post_message(QuestionSelected(item.post_id)) + + +class Sidebar(Vertical): + """Left sidebar with action buttons and the question list.""" + + DEFAULT_CSS = """ + Sidebar { + width: 40; + min-width: 30; + max-width: 60; + height: 1fr; + border-right: solid $primary; + background: $surface; + } + Sidebar > .sidebar-header { + dock: top; + height: auto; + padding: 1 1; + text-align: center; + text-style: bold; + color: $text; + background: $primary 20%; + } + Sidebar > .sidebar-buttons { + dock: top; + height: auto; + padding: 1 1; + } + Sidebar > .sidebar-buttons Button { + width: 100%; + margin-bottom: 1; + } + """ + + def compose(self) -> ComposeResult: + yield Static("Auto Resolver", classes="sidebar-header") + with Vertical(classes="sidebar-buttons"): + yield Button("Add Tournament [t]", id="btn-add-tournament", variant="primary") + yield Button("Add Question [a]", id="btn-add-question", variant="default") + yield QuestionListView(id="question-list") + + def on_mount(self) -> None: + """Insert the Home entry as the first (and initially highlighted) item.""" + home_item = SidebarListItem( + HOME_SENTINEL_ID, "[bold]Home[/bold] Overview", id="q-home" + ) + self.question_list.append(home_item) + + @property + def question_list(self) -> QuestionListView: + return self.query_one("#question-list", QuestionListView) + + def add_question_entry(self, post_id: int, display_text: str) -> None: + """Append a question to the list.""" + list_item = SidebarListItem(post_id, display_text, id=f"q-{post_id}") + self.question_list.append(list_item) + + def update_question_entry(self, post_id: int, display_text: str) -> None: + """Update an existing question entry's display text.""" + try: + item = self.question_list.query_one(f"#q-{post_id}", SidebarListItem) + item.update_text(display_text) + except Exception: + pass # Item may not exist yet + + def get_selected_post_id(self) -> Optional[int]: + """Return the post_id of the currently highlighted item, or None.""" + highlighted = self.question_list.highlighted_child + if isinstance(highlighted, SidebarListItem): + return highlighted.post_id + return None diff --git a/forecasting_tools/agents_and_tools/minor_tools.py b/forecasting_tools/agents_and_tools/minor_tools.py index fee3b47..b6d1572 100644 --- a/forecasting_tools/agents_and_tools/minor_tools.py +++ b/forecasting_tools/agents_and_tools/minor_tools.py @@ -1,6 +1,7 @@ import asyncio import logging import random +from datetime import datetime from forecasting_tools.agents_and_tools.question_generators.simple_question import ( SimpleQuestion, @@ -31,6 +32,61 @@ async def query_asknews(topic: str) -> str: return await AskNewsSearcher().get_formatted_news_async(topic) +def create_date_filtered_asknews_tool( + cutoff_date: datetime | None = None, +) -> AgentTool: + """Factory that returns an AskNews search tool filtered to a date cutoff. + + The returned tool only surfaces articles published **before** + ``cutoff_date``, preventing false positives from events that occurred + after a question's context window closed. + + If ``cutoff_date`` is ``None`` the tool falls back to the standard + unfiltered AskNews search. + + Args: + cutoff_date: Only return articles published before this datetime. + Typically set to the question's ``close_time``. + + Returns: + An ``@agent_tool``-decorated async function suitable for inclusion + in an agent's ``tools`` list. + """ + if cutoff_date is not None: + date_str = cutoff_date.strftime("%Y-%m-%d") + description = ( + f"Search international news articles using AskNews. " + f"Results are automatically filtered to only include articles " + f"published BEFORE {date_str} (the question's close date) to " + f"avoid false positives from events that occurred after the " + f"question's context window. Returns ~16 article summaries with " + f"title, summary, URL, and publication date." + ) + else: + description = ( + "Search international news articles using AskNews. " + "Returns ~16 article summaries with title, summary, URL, and " + "publication date. Can search international news from other " + "languages." + ) + + @agent_tool(description_override=description) + async def query_asknews_date_filtered(topic: str) -> str: + logger.info( + f"TOOL: Querying AskNews for topic: {topic}" + + (f" (before {date_str})" if cutoff_date else "") + ) + searcher = AskNewsSearcher() + if cutoff_date is not None: + return await searcher.get_formatted_news_before_date_async( + topic, cutoff_date + ) + else: + return await searcher.get_formatted_news_async(topic) + + return query_asknews_date_filtered + + @agent_tool async def perplexity_reasoning_pro_search(query: str) -> str: """ diff --git a/forecasting_tools/helpers/asknews_searcher.py b/forecasting_tools/helpers/asknews_searcher.py index e0a2ba7..bc007cb 100644 --- a/forecasting_tools/helpers/asknews_searcher.py +++ b/forecasting_tools/helpers/asknews_searcher.py @@ -3,6 +3,7 @@ import asyncio import logging import os +from datetime import datetime, timedelta, timezone from typing import Literal from asknews_sdk import AsyncAskNewsSDK @@ -136,6 +137,84 @@ async def get_formatted_news_async(self, query: str) -> str: self.cache.set(query, formatted_articles) return formatted_articles + async def get_formatted_news_before_date_async( + self, + query: str, + before_date: datetime, + ) -> str: + """Search AskNews for articles published before a specific date. + + This is designed for resolution contexts where news published after + a question's close date should not influence the resolution. It uses + the AskNews ``end_timestamp`` parameter filtered on ``pub_date`` to + ensure only articles published before the cutoff are returned. + + Args: + query: Natural language search query. + before_date: Only return articles published before this datetime. + + Returns: + Formatted string of matching news articles. + """ + cache_key = f"{query}__before__{before_date.isoformat()}" + cached_result = self.cache.get(cache_key) + if cached_result is not None: + logger.info(f"Found cached result for date-filtered query: {query}") + return cached_result + + end_ts = int(before_date.timestamp()) + now_utc = datetime.now(timezone.utc) + cutoff_is_recent = (now_utc - before_date) < timedelta(hours=48) + + async with AsyncAskNewsSDK( + client_id=self.client_id, + client_secret=self.client_secret, + api_key=self.api_key, + scopes=set(["news"]), + ) as ask: + # If cutoff is within the last 48h, also search the hot database + hot_articles = [] + if cutoff_is_recent: + hot_response = await ask.news.search_news( + query=query, + n_articles=6, + return_type="both", + strategy="default", + end_timestamp=end_ts, + time_filter="pub_date", + historical=False, + ) + hot_articles = hot_response.as_dicts or [] + await asyncio.sleep(self._default_rate_limit) + + # Search the historical archive (back to 2023) + historical_response = await ask.news.search_news( + query=query, + n_articles=10, + return_type="both", + strategy="default", + end_timestamp=end_ts, + time_filter="pub_date", + historical=True, + ) + historical_articles = historical_response.as_dicts or [] + + formatted_articles = ( + f"Here are the relevant news articles " + f"(filtered to articles published before " + f"{before_date.strftime('%Y-%m-%d')}):\n\n" + ) + + if hot_articles: + formatted_articles += self._format_articles(hot_articles) + if historical_articles: + formatted_articles += self._format_articles(historical_articles) + if not hot_articles and not historical_articles: + formatted_articles += "No articles were found.\n\n" + + self.cache.set(cache_key, formatted_articles) + return formatted_articles + def _format_articles(self, articles: list[SearchResponseDictItem]) -> str: formatted_articles = "" sorted_articles = sorted(articles, key=lambda x: x.pub_date, reverse=True) diff --git a/poetry.lock b/poetry.lock index 21cb7eb..1affe9d 100644 --- a/poetry.lock +++ b/poetry.lock @@ -369,13 +369,13 @@ tests = ["mypy (>=1.14.0)", "pytest", "pytest-asyncio"] [[package]] name = "asknews" -version = "0.13.19" +version = "0.13.25" description = "Python SDK for AskNews" optional = false python-versions = ">=3.8" groups = ["main"] files = [ - {file = "asknews-0.13.19-py3-none-any.whl", hash = "sha256:52022f830d6494508208b6fe9719e046d6313d2226d4a603ee160d3ecfef99fe"}, + {file = "asknews-0.13.25-py3-none-any.whl", hash = "sha256:3c3c9ee104321bd7e1cee3f97080f6a0c34a6340103498ea8ae3b0538346b02b"}, ] [package.dependencies] @@ -414,18 +414,6 @@ files = [ {file = "async_lru-2.2.0.tar.gz", hash = "sha256:80abae2a237dbc6c60861d621619af39f0d920aea306de34cb992c879e01370c"}, ] -[[package]] -name = "asyncio" -version = "4.0.0" -description = "Deprecated backport of asyncio; use the stdlib package instead" -optional = false -python-versions = ">=3.4" -groups = ["main"] -files = [ - {file = "asyncio-4.0.0-py3-none-any.whl", hash = "sha256:c1eddb0659231837046809e68103969b2bef8b0400d59cfa6363f6b5ed8cc88b"}, - {file = "asyncio-4.0.0.tar.gz", hash = "sha256:570cd9e50db83bc1629152d4d0b7558d6451bb1bfd5dfc2e935d96fc2f40329b"}, -] - [[package]] name = "attrs" version = "25.4.0" @@ -509,26 +497,26 @@ files = [ [[package]] name = "cachetools" -version = "6.2.6" +version = "7.0.5" description = "Extensible memoizing collections and decorators" optional = false -python-versions = ">=3.9" +python-versions = ">=3.10" groups = ["main", "dev"] files = [ - {file = "cachetools-6.2.6-py3-none-any.whl", hash = "sha256:8c9717235b3c651603fff0076db52d6acbfd1b338b8ed50256092f7ce9c85bda"}, - {file = "cachetools-6.2.6.tar.gz", hash = "sha256:16c33e1f276b9a9c0b49ab5782d901e3ad3de0dd6da9bf9bcd29ac5672f2f9e6"}, + {file = "cachetools-7.0.5-py3-none-any.whl", hash = "sha256:46bc8ebefbe485407621d0a4264b23c080cedd913921bad7ac3ed2f26c183114"}, + {file = "cachetools-7.0.5.tar.gz", hash = "sha256:0cd042c24377200c1dcd225f8b7b12b0ca53cc2c961b43757e774ebe190fd990"}, ] [[package]] name = "certifi" -version = "2026.1.4" +version = "2026.2.25" description = "Python package for providing Mozilla's CA Bundle." optional = false python-versions = ">=3.7" groups = ["main", "dev"] files = [ - {file = "certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c"}, - {file = "certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120"}, + {file = "certifi-2026.2.25-py3-none-any.whl", hash = "sha256:027692e4402ad994f1c42e52a4997a9763c646b73e4096e4d5d6db8af1d6f0fa"}, + {file = "certifi-2026.2.25.tar.gz", hash = "sha256:e887ab5cee78ea814d3472169153c2d12cd43b14bd03329a39a9c6e2e80bfba7"}, ] [[package]] @@ -655,125 +643,125 @@ files = [ [[package]] name = "charset-normalizer" -version = "3.4.4" +version = "3.4.5" description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." optional = false python-versions = ">=3.7" groups = ["main", "dev"] files = [ - {file = "charset_normalizer-3.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e824f1492727fa856dd6eda4f7cee25f8518a12f3c4a56a74e8095695089cf6d"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bd5d4137d500351a30687c2d3971758aac9a19208fc110ccb9d7188fbe709e8"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:027f6de494925c0ab2a55eab46ae5129951638a49a34d87f4c3eda90f696b4ad"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f820802628d2694cb7e56db99213f930856014862f3fd943d290ea8438d07ca8"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:798d75d81754988d2565bff1b97ba5a44411867c0cf32b77a7e8f8d84796b10d"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d1bb833febdff5c8927f922386db610b49db6e0d4f4ee29601d71e7c2694313"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cd98cdc06614a2f768d2b7286d66805f94c48cde050acdbbb7db2600ab3197e"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:077fbb858e903c73f6c9db43374fd213b0b6a778106bc7032446a8e8b5b38b93"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:244bfb999c71b35de57821b8ea746b24e863398194a4014e4c76adc2bbdfeff0"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:64b55f9dce520635f018f907ff1b0df1fdc31f2795a922fb49dd14fbcdf48c84"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:faa3a41b2b66b6e50f84ae4a68c64fcd0c44355741c6374813a800cd6695db9e"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6515f3182dbe4ea06ced2d9e8666d97b46ef4c75e326b79bb624110f122551db"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cc00f04ed596e9dc0da42ed17ac5e596c6ccba999ba6bd92b0e0aef2f170f2d6"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-win32.whl", hash = "sha256:f34be2938726fc13801220747472850852fe6b1ea75869a048d6f896838c896f"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-win_amd64.whl", hash = "sha256:a61900df84c667873b292c3de315a786dd8dac506704dea57bc957bd31e22c7d"}, - {file = "charset_normalizer-3.4.4-cp310-cp310-win_arm64.whl", hash = "sha256:cead0978fc57397645f12578bfd2d5ea9138ea0fac82b2f63f7f7c6877986a69"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016"}, - {file = "charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525"}, - {file = "charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14"}, - {file = "charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c"}, - {file = "charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ce8a0633f41a967713a59c4139d29110c07e826d131a316b50ce11b1d79b4f84"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaabd426fe94daf8fd157c32e571c85cb12e66692f15516a83a03264b08d06c3"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c4ef880e27901b6cc782f1b95f82da9313c0eb95c3af699103088fa0ac3ce9ac"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aaba3b0819274cc41757a1da876f810a3e4d7b6eb25699253a4effef9e8e4af"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:778d2e08eda00f4256d7f672ca9fef386071c9202f5e4607920b86d7803387f2"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f155a433c2ec037d4e8df17d18922c3a0d9b3232a396690f17175d2946f0218d"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a8bf8d0f749c5757af2142fe7903a9df1d2e8aa3841559b2bad34b08d0e2bcf3"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:194f08cbb32dc406d6e1aea671a68be0823673db2832b38405deba2fb0d88f63"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_armv7l.whl", hash = "sha256:6aee717dcfead04c6eb1ce3bd29ac1e22663cdea57f943c87d1eab9a025438d7"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:cd4b7ca9984e5e7985c12bc60a6f173f3c958eae74f3ef6624bb6b26e2abbae4"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_riscv64.whl", hash = "sha256:b7cf1017d601aa35e6bb650b6ad28652c9cd78ee6caff19f3c28d03e1c80acbf"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:e912091979546adf63357d7e2ccff9b44f026c075aeaf25a52d0e95ad2281074"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:5cb4d72eea50c8868f5288b7f7f33ed276118325c1dfd3957089f6b519e1382a"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-win32.whl", hash = "sha256:837c2ce8c5a65a2035be9b3569c684358dfbf109fd3b6969630a87535495ceaa"}, - {file = "charset_normalizer-3.4.4-cp38-cp38-win_amd64.whl", hash = "sha256:44c2a8734b333e0578090c4cd6b16f275e07aa6614ca8715e6c038e865e70576"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:a9768c477b9d7bd54bc0c86dbaebdec6f03306675526c9927c0e8a04e8f94af9"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1bee1e43c28aa63cb16e5c14e582580546b08e535299b8b6158a7c9c768a1f3d"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:fd44c878ea55ba351104cb93cc85e74916eb8fa440ca7903e57575e97394f608"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0f04b14ffe5fdc8c4933862d8306109a2c51e0704acfa35d51598eb45a1e89fc"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:cd09d08005f958f370f539f186d10aec3377d55b9eeb0d796025d4886119d76e"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4fe7859a4e3e8457458e2ff592f15ccb02f3da787fcd31e0183879c3ad4692a1"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fa09f53c465e532f4d3db095e0c55b615f010ad81803d383195b6b5ca6cbf5f3"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:7fa17817dc5625de8a027cb8b26d9fefa3ea28c8253929b8d6649e705d2835b6"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:5947809c8a2417be3267efc979c47d76a079758166f7d43ef5ae8e9f92751f88"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:4902828217069c3c5c71094537a8e623f5d097858ac6ca8252f7b4d10b7560f1"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_riscv64.whl", hash = "sha256:7c308f7e26e4363d79df40ca5b2be1c6ba9f02bdbccfed5abddb7859a6ce72cf"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:2c9d3c380143a1fedbff95a312aa798578371eb29da42106a29019368a475318"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:cb01158d8b88ee68f15949894ccc6712278243d95f344770fa7593fa2d94410c"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-win32.whl", hash = "sha256:2677acec1a2f8ef614c6888b5b4ae4060cc184174a938ed4e8ef690e15d3e505"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-win_amd64.whl", hash = "sha256:f8e160feb2aed042cd657a72acc0b481212ed28b1b9a95c0cee1621b524e1966"}, - {file = "charset_normalizer-3.4.4-cp39-cp39-win_arm64.whl", hash = "sha256:b5d84d37db046c5ca74ee7bb47dd6cbc13f80665fdde3e8040bdd3fb015ecb50"}, - {file = "charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f"}, - {file = "charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:4167a621a9a1a986c73777dbc15d4b5eac8ac5c10393374109a343d4013ec765"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3f64c6bf8f32f9133b668c7f7a7cbdbc453412bc95ecdbd157f3b1e377a92990"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:568e3c34b58422075a1b49575a6abc616d9751b4d61b23f712e12ebb78fe47b2"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:036c079aa08a6a592b82487f97c60b439428320ed1b2ea0b3912e99d30c77765"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:340810d34ef83af92148e96e3e44cb2d3f910d2bf95e5618a5c467d9f102231d"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:cd2d0f0ec9aa977a27731a3209ebbcacebebaf41f902bd453a928bfd281cf7f8"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0b362bcd27819f9c07cbf23db4e0e8cd4b44c5ecd900c2ff907b2b92274a7412"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:77be992288f720306ab4108fe5c74797de327f3248368dfc7e1a916d6ed9e5a2"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:8b78d8a609a4b82c273257ee9d631ded7fac0d875bdcdccc109f3ee8328cfcb1"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ba20bdf69bd127f66d0174d6f2a93e69045e0b4036dc1ca78e091bcc765830c4"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:76a9d0de4d0eab387822e7b35d8f89367dd237c72e82ab42b9f7bf5e15ada00f"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:8fff79bf5978c693c9b1a4d71e4a94fddfb5fe744eb062a318e15f4a2f63a550"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c7e84e0c0005e3bdc1a9211cd4e62c78ba80bc37b2365ef4410cd2007a9047f2"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-win32.whl", hash = "sha256:58ad8270cfa5d4bef1bc85bd387217e14ff154d6630e976c6f56f9a040757475"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-win_amd64.whl", hash = "sha256:02a9d1b01c1e12c27883b0c9349e0bcd9ae92e727ff1a277207e1a262b1cbf05"}, + {file = "charset_normalizer-3.4.5-cp310-cp310-win_arm64.whl", hash = "sha256:039215608ac7b358c4da0191d10fc76868567fbf276d54c14721bdedeb6de064"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:610f72c0ee565dfb8ae1241b666119582fdbfe7c0975c175be719f940e110694"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60d68e820af339df4ae8358c7a2e7596badeb61e544438e489035f9fbf3246a5"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b473fc8dca1c3ad8559985794815f06ca3fc71942c969129070f2c3cdf7281"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d4eb8ac7469b2a5d64b5b8c04f84d8bf3ad340f4514b98523805cbf46e3b3923"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bcb3227c3d9aaf73eaaab1db7ccd80a8995c509ee9941e2aae060ca6e4e5d81"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:75ee9c1cce2911581a70a3c0919d8bccf5b1cbc9b0e5171400ec736b4b569497"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1d1401945cb77787dbd3af2446ff2d75912327c4c3a1526ab7955ecf8600687c"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0a45e504f5e1be0bd385935a8e1507c442349ca36f511a47057a71c9d1d6ea9e"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:e09f671a54ce70b79a1fc1dc6da3072b7ef7251fadb894ed92d9aa8218465a5f"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d01de5e768328646e6a3fa9e562706f8f6641708c115c62588aef2b941a4f88e"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:131716d6786ad5e3dc542f5cc6f397ba3339dc0fb87f87ac30e550e8987756af"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a374cc0b88aa710e8865dc1bd6edb3743c59f27830f0293ab101e4cf3ce9f85"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d31f0d1671e1534e395f9eb84a68e0fb670e1edb1fe819a9d7f564ae3bc4e53f"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-win32.whl", hash = "sha256:cace89841c0599d736d3d74a27bc5821288bb47c5441923277afc6059d7fbcb4"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-win_amd64.whl", hash = "sha256:f8102ae93c0bc863b1d41ea0f4499c20a83229f52ed870850892df555187154a"}, + {file = "charset_normalizer-3.4.5-cp311-cp311-win_arm64.whl", hash = "sha256:ed98364e1c262cf5f9363c3eca8c2df37024f52a8fa1180a3610014f26eac51c"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed97c282ee4f994ef814042423a529df9497e3c666dca19be1d4cd1129dc7ade"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0294916d6ccf2d069727d65973c3a1ca477d68708db25fd758dd28b0827cff54"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dc57a0baa3eeedd99fafaef7511b5a6ef4581494e8168ee086031744e2679467"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ed1a9a204f317ef879b32f9af507d47e49cd5e7f8e8d5d96358c98373314fc60"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7ad83b8f9379176c841f8865884f3514d905bcd2a9a3b210eaa446e7d2223e4d"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:a118e2e0b5ae6b0120d5efa5f866e58f2bb826067a646431da4d6a2bdae7950e"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:754f96058e61a5e22e91483f823e07df16416ce76afa4ebf306f8e1d1296d43f"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0c300cefd9b0970381a46394902cd18eaf2aa00163f999590ace991989dcd0fc"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c108f8619e504140569ee7de3f97d234f0fbae338a7f9f360455071ef9855a95"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:d1028de43596a315e2720a9849ee79007ab742c06ad8b45a50db8cdb7ed4a82a"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:19092dde50335accf365cce21998a1c6dd8eafd42c7b226eb54b2747cdce2fac"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4354e401eb6dab9aed3c7b4030514328a6c748d05e1c3e19175008ca7de84fb1"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a68766a3c58fde7f9aaa22b3786276f62ab2f594efb02d0a1421b6282e852e98"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-win32.whl", hash = "sha256:1827734a5b308b65ac54e86a618de66f935a4f63a8a462ff1e19a6788d6c2262"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-win_amd64.whl", hash = "sha256:728c6a963dfab66ef865f49286e45239384249672cd598576765acc2a640a636"}, + {file = "charset_normalizer-3.4.5-cp312-cp312-win_arm64.whl", hash = "sha256:75dfd1afe0b1647449e852f4fb428195a7ed0588947218f7ba929f6538487f02"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac59c15e3f1465f722607800c68713f9fbc2f672b9eb649fe831da4019ae9b23"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:165c7b21d19365464e8f70e5ce5e12524c58b48c78c1f5a57524603c1ab003f8"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:28269983f25a4da0425743d0d257a2d6921ea7d9b83599d4039486ec5b9f911d"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d27ce22ec453564770d29d03a9506d449efbb9fa13c00842262b2f6801c48cce"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0625665e4ebdddb553ab185de5db7054393af8879fb0c87bd5690d14379d6819"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:c23eb3263356d94858655b3e63f85ac5d50970c6e8febcdde7830209139cc37d"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e6302ca4ae283deb0af68d2fbf467474b8b6aedcd3dab4db187e07f94c109763"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e51ae7d81c825761d941962450f50d041db028b7278e7b08930b4541b3e45cb9"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:597d10dec876923e5c59e48dbd366e852eacb2b806029491d307daea6b917d7c"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5cffde4032a197bd3b42fd0b9509ec60fb70918d6970e4cc773f20fc9180ca67"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2da4eedcb6338e2321e831a0165759c0c620e37f8cd044a263ff67493be8ffb3"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:65a126fb4b070d05340a84fc709dd9e7c75d9b063b610ece8a60197a291d0adf"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c7a80a9242963416bd81f99349d5f3fce1843c303bd404f204918b6d75a75fd6"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-win32.whl", hash = "sha256:f1d725b754e967e648046f00c4facc42d414840f5ccc670c5670f59f83693e4f"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-win_amd64.whl", hash = "sha256:e37bd100d2c5d3ba35db9c7c5ba5a9228cbcffe5c4778dc824b164e5257813d7"}, + {file = "charset_normalizer-3.4.5-cp313-cp313-win_arm64.whl", hash = "sha256:93b3b2cc5cf1b8743660ce77a4f45f3f6d1172068207c1defc779a36eea6bb36"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8197abe5ca1ffb7d91e78360f915eef5addff270f8a71c1fc5be24a56f3e4873"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a2aecdb364b8a1802afdc7f9327d55dad5366bc97d8502d0f5854e50712dbc5f"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a66aa5022bf81ab4b1bebfb009db4fd68e0c6d4307a1ce5ef6a26e5878dfc9e4"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d77f97e515688bd615c1d1f795d540f32542d514242067adcb8ef532504cb9ee"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01a1ed54b953303ca7e310fafe0fe347aab348bd81834a0bcd602eb538f89d66"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:b2d37d78297b39a9eb9eb92c0f6df98c706467282055419df141389b23f93362"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e71bbb595973622b817c042bd943c3f3667e9c9983ce3d205f973f486fec98a7"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4cd966c2559f501c6fd69294d082c2934c8dd4719deb32c22961a5ac6db0df1d"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:d5e52d127045d6ae01a1e821acfad2f3a1866c54d0e837828538fabe8d9d1bd6"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:30a2b1a48478c3428d047ed9690d57c23038dac838a87ad624c85c0a78ebeb39"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:d8ed79b8f6372ca4254955005830fd61c1ccdd8c0fac6603e2c145c61dd95db6"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:c5af897b45fa606b12464ccbe0014bbf8c09191e0a66aab6aa9d5cf6e77e0c94"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1088345bcc93c58d8d8f3d783eca4a6e7a7752bbff26c3eee7e73c597c191c2e"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-win32.whl", hash = "sha256:ee57b926940ba00bca7ba7041e665cc956e55ef482f851b9b65acb20d867e7a2"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-win_amd64.whl", hash = "sha256:4481e6da1830c8a1cc0b746b47f603b653dadb690bcd851d039ffaefe70533aa"}, + {file = "charset_normalizer-3.4.5-cp314-cp314-win_arm64.whl", hash = "sha256:97ab7787092eb9b50fb47fa04f24c75b768a606af1bcba1957f07f128a7219e4"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e22d1059b951e7ae7c20ef6b06afd10fb95e3c41bf3c4fbc874dba113321c193"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:afca7f78067dd27c2b848f1b234623d26b87529296c6c5652168cc1954f2f3b2"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ec56a2266f32bc06ed3c3e2a8f58417ce02f7e0356edc89786e52db13c593c98"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2b970382e4a36bed897c19f310f31d7d13489c11b4f468ddfba42d41cddfb918"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:573ef5814c4b7c0d59a7710aa920eaaaef383bd71626aa420fba27b5cab92e8d"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-manylinux_2_31_armv7l.whl", hash = "sha256:50bcbca6603c06a1dcc7b056ed45c37715fb5d2768feb3bcd37d2313c587a5b9"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1f2da5cbb9becfcd607757a169e38fb82aa5fd86fae6653dea716e7b613fe2cf"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:fc1c64934b8faf7584924143eb9db4770bbdb16659626e1a1a4d9efbcb68d947"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-musllinux_1_2_armv7l.whl", hash = "sha256:ae8b03427410731469c4033934cf473426faff3e04b69d2dfb64a4281a3719f8"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:b3e71afc578b98512bfe7bdb822dd6bc57d4b0093b4b6e5487c1e96ad4ace242"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-musllinux_1_2_riscv64.whl", hash = "sha256:4b8551b6e6531e156db71193771c93bda78ffc4d1e6372517fe58ad3b91e4659"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:65b3c403a5b6b8034b655e7385de4f72b7b244869a22b32d4030b99a60593eca"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:8ce11cd4d62d11166f2b441e30ace226c19a3899a7cf0796f668fba49a9fb123"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-win32.whl", hash = "sha256:66dee73039277eb35380d1b82cccc69cc82b13a66f9f4a18da32d573acf02b7c"}, + {file = "charset_normalizer-3.4.5-cp38-cp38-win_amd64.whl", hash = "sha256:d29dd9c016f2078b43d0c357511e87eee5b05108f3dd603423cb389b89813969"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:259cd1ca995ad525f638e131dbcc2353a586564c038fc548a3fe450a91882139"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a28afb04baa55abf26df544e3e5c6534245d3daa5178bc4a8eeb48202060d0e"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ff95a9283de8a457e6b12989de3f9f5193430f375d64297d323a615ea52cbdb3"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:708c7acde173eedd4bfa4028484426ba689d2103b28588c513b9db2cd5ecde9c"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa92ec1102eaff840ccd1021478af176a831f1bccb08e526ce844b7ddda85c22"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-manylinux_2_31_armv7l.whl", hash = "sha256:5fea359734b140d0d6741189fea5478c6091b54ffc69d7ce119e0a05637d8c99"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e545b51da9f9af5c67815ca0eb40676c0f016d0b0381c86f20451e35696c5f95"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:30987f4a8ed169983f93e1be8ffeea5214a779e27ed0b059835c7afe96550ad7"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:149ec69866c3d6c2fb6f758dbc014ecb09f30b35a5ca90b6a8a2d4e54e18fdfe"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:530beedcec9b6e027e7a4b6ce26eed36678aa39e17da85e6e03d7bd9e8e9d7c9"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-musllinux_1_2_riscv64.whl", hash = "sha256:14498a429321de554b140013142abe7608f9d8ccc04d7baf2ad60498374aefa2"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:2820a98460c83663dd8ec015d9ddfd1e4879f12e06bb7d0500f044fb477d2770"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:aa2f963b4da26daf46231d9b9e0e2c9408a751f8f0d0f44d2de56d3caf51d294"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-win32.whl", hash = "sha256:82cc7c2ad42faec8b574351f8bc2a0c049043893853317bd9bb309f5aba6cb5a"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-win_amd64.whl", hash = "sha256:92263f7eca2f4af326cd20de8d16728d2602f7cfea02e790dcde9d83c365d7cc"}, + {file = "charset_normalizer-3.4.5-cp39-cp39-win_arm64.whl", hash = "sha256:014837af6fabf57121b6254fa8ade10dceabc3528b27b721a64bbc7b8b1d4eb4"}, + {file = "charset_normalizer-3.4.5-py3-none-any.whl", hash = "sha256:9db5e3fcdcee89a78c04dffb3fe33c79f77bd741a624946db2591c81b2fc85b0"}, + {file = "charset_normalizer-3.4.5.tar.gz", hash = "sha256:95adae7b6c42a6c5b5b559b1a99149f090a57128155daeea91732c8d970d8644"}, ] [[package]] @@ -1216,14 +1204,14 @@ tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipyth [[package]] name = "faker" -version = "40.4.0" +version = "40.8.0" description = "Faker is a Python package that generates fake data for you." optional = false python-versions = ">=3.10" groups = ["main"] files = [ - {file = "faker-40.4.0-py3-none-any.whl", hash = "sha256:486d43c67ebbb136bc932406418744f9a0bdf2c07f77703ea78b58b77e9aa443"}, - {file = "faker-40.4.0.tar.gz", hash = "sha256:76f8e74a3df28c3e2ec2caafa956e19e37a132fdc7ea067bc41783affcfee364"}, + {file = "faker-40.8.0-py3-none-any.whl", hash = "sha256:eb21bdba18f7a8375382eb94fb436fce07046893dc94cb20817d28deb0c3d579"}, + {file = "faker-40.8.0.tar.gz", hash = "sha256:936a3c9be6c004433f20aa4d99095df5dec82b8c7ad07459756041f8c1728875"}, ] [package.dependencies] @@ -1337,74 +1325,74 @@ files = [ [[package]] name = "filelock" -version = "3.24.3" +version = "3.25.1" description = "A platform independent file lock." optional = false python-versions = ">=3.10" groups = ["main", "dev"] files = [ - {file = "filelock-3.24.3-py3-none-any.whl", hash = "sha256:426e9a4660391f7f8a810d71b0555bce9008b0a1cc342ab1f6947d37639e002d"}, - {file = "filelock-3.24.3.tar.gz", hash = "sha256:011a5644dc937c22699943ebbfc46e969cdde3e171470a6e40b9533e5a72affa"}, + {file = "filelock-3.25.1-py3-none-any.whl", hash = "sha256:18972df45473c4aa2c7921b609ee9ca4925910cc3a0fb226c96b92fc224ef7bf"}, + {file = "filelock-3.25.1.tar.gz", hash = "sha256:b9a2e977f794ef94d77cdf7d27129ac648a61f585bff3ca24630c1629f701aa9"}, ] [[package]] name = "fonttools" -version = "4.61.1" +version = "4.62.0" description = "Tools to manipulate font files" optional = false python-versions = ">=3.10" groups = ["dev"] files = [ - {file = "fonttools-4.61.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c7db70d57e5e1089a274cbb2b1fd635c9a24de809a231b154965d415d6c6d24"}, - {file = "fonttools-4.61.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5fe9fd43882620017add5eabb781ebfbc6998ee49b35bd7f8f79af1f9f99a958"}, - {file = "fonttools-4.61.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8db08051fc9e7d8bc622f2112511b8107d8f27cd89e2f64ec45e9825e8288da"}, - {file = "fonttools-4.61.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a76d4cb80f41ba94a6691264be76435e5f72f2cb3cab0b092a6212855f71c2f6"}, - {file = "fonttools-4.61.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a13fc8aeb24bad755eea8f7f9d409438eb94e82cf86b08fe77a03fbc8f6a96b1"}, - {file = "fonttools-4.61.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b846a1fcf8beadeb9ea4f44ec5bdde393e2f1569e17d700bfc49cd69bde75881"}, - {file = "fonttools-4.61.1-cp310-cp310-win32.whl", hash = "sha256:78a7d3ab09dc47ac1a363a493e6112d8cabed7ba7caad5f54dbe2f08676d1b47"}, - {file = "fonttools-4.61.1-cp310-cp310-win_amd64.whl", hash = "sha256:eff1ac3cc66c2ac7cda1e64b4e2f3ffef474b7335f92fc3833fc632d595fcee6"}, - {file = "fonttools-4.61.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c6604b735bb12fef8e0efd5578c9fb5d3d8532d5001ea13a19cddf295673ee09"}, - {file = "fonttools-4.61.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5ce02f38a754f207f2f06557523cd39a06438ba3aafc0639c477ac409fc64e37"}, - {file = "fonttools-4.61.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77efb033d8d7ff233385f30c62c7c79271c8885d5c9657d967ede124671bbdfb"}, - {file = "fonttools-4.61.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:75c1a6dfac6abd407634420c93864a1e274ebc1c7531346d9254c0d8f6ca00f9"}, - {file = "fonttools-4.61.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0de30bfe7745c0d1ffa2b0b7048fb7123ad0d71107e10ee090fa0b16b9452e87"}, - {file = "fonttools-4.61.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:58b0ee0ab5b1fc9921eccfe11d1435added19d6494dde14e323f25ad2bc30c56"}, - {file = "fonttools-4.61.1-cp311-cp311-win32.whl", hash = "sha256:f79b168428351d11e10c5aeb61a74e1851ec221081299f4cf56036a95431c43a"}, - {file = "fonttools-4.61.1-cp311-cp311-win_amd64.whl", hash = "sha256:fe2efccb324948a11dd09d22136fe2ac8a97d6c1347cf0b58a911dcd529f66b7"}, - {file = "fonttools-4.61.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f3cb4a569029b9f291f88aafc927dd53683757e640081ca8c412781ea144565e"}, - {file = "fonttools-4.61.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41a7170d042e8c0024703ed13b71893519a1a6d6e18e933e3ec7507a2c26a4b2"}, - {file = "fonttools-4.61.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:10d88e55330e092940584774ee5e8a6971b01fc2f4d3466a1d6c158230880796"}, - {file = "fonttools-4.61.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:15acc09befd16a0fb8a8f62bc147e1a82817542d72184acca9ce6e0aeda9fa6d"}, - {file = "fonttools-4.61.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e6bcdf33aec38d16508ce61fd81838f24c83c90a1d1b8c68982857038673d6b8"}, - {file = "fonttools-4.61.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5fade934607a523614726119164ff621e8c30e8fa1ffffbbd358662056ba69f0"}, - {file = "fonttools-4.61.1-cp312-cp312-win32.whl", hash = "sha256:75da8f28eff26defba42c52986de97b22106cb8f26515b7c22443ebc9c2d3261"}, - {file = "fonttools-4.61.1-cp312-cp312-win_amd64.whl", hash = "sha256:497c31ce314219888c0e2fce5ad9178ca83fe5230b01a5006726cdf3ac9f24d9"}, - {file = "fonttools-4.61.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c56c488ab471628ff3bfa80964372fc13504ece601e0d97a78ee74126b2045c"}, - {file = "fonttools-4.61.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dc492779501fa723b04d0ab1f5be046797fee17d27700476edc7ee9ae535a61e"}, - {file = "fonttools-4.61.1-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:64102ca87e84261419c3747a0d20f396eb024bdbeb04c2bfb37e2891f5fadcb5"}, - {file = "fonttools-4.61.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c1b526c8d3f615a7b1867f38a9410849c8f4aef078535742198e942fba0e9bd"}, - {file = "fonttools-4.61.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:41ed4b5ec103bd306bb68f81dc166e77409e5209443e5773cb4ed837bcc9b0d3"}, - {file = "fonttools-4.61.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b501c862d4901792adaec7c25b1ecc749e2662543f68bb194c42ba18d6eec98d"}, - {file = "fonttools-4.61.1-cp313-cp313-win32.whl", hash = "sha256:4d7092bb38c53bbc78e9255a59158b150bcdc115a1e3b3ce0b5f267dc35dd63c"}, - {file = "fonttools-4.61.1-cp313-cp313-win_amd64.whl", hash = "sha256:21e7c8d76f62ab13c9472ccf74515ca5b9a761d1bde3265152a6dc58700d895b"}, - {file = "fonttools-4.61.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fff4f534200a04b4a36e7ae3cb74493afe807b517a09e99cb4faa89a34ed6ecd"}, - {file = "fonttools-4.61.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d9203500f7c63545b4ce3799319fe4d9feb1a1b89b28d3cb5abd11b9dd64147e"}, - {file = "fonttools-4.61.1-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fa646ecec9528bef693415c79a86e733c70a4965dd938e9a226b0fc64c9d2e6c"}, - {file = "fonttools-4.61.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11f35ad7805edba3aac1a3710d104592df59f4b957e30108ae0ba6c10b11dd75"}, - {file = "fonttools-4.61.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b931ae8f62db78861b0ff1ac017851764602288575d65b8e8ff1963fed419063"}, - {file = "fonttools-4.61.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b148b56f5de675ee16d45e769e69f87623a4944f7443850bf9a9376e628a89d2"}, - {file = "fonttools-4.61.1-cp314-cp314-win32.whl", hash = "sha256:9b666a475a65f4e839d3d10473fad6d47e0a9db14a2f4a224029c5bfde58ad2c"}, - {file = "fonttools-4.61.1-cp314-cp314-win_amd64.whl", hash = "sha256:4f5686e1fe5fce75d82d93c47a438a25bf0d1319d2843a926f741140b2b16e0c"}, - {file = "fonttools-4.61.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:e76ce097e3c57c4bcb67c5aa24a0ecdbd9f74ea9219997a707a4061fbe2707aa"}, - {file = "fonttools-4.61.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9cfef3ab326780c04d6646f68d4b4742aae222e8b8ea1d627c74e38afcbc9d91"}, - {file = "fonttools-4.61.1-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a75c301f96db737e1c5ed5fd7d77d9c34466de16095a266509e13da09751bd19"}, - {file = "fonttools-4.61.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:91669ccac46bbc1d09e9273546181919064e8df73488ea087dcac3e2968df9ba"}, - {file = "fonttools-4.61.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c33ab3ca9d3ccd581d58e989d67554e42d8d4ded94ab3ade3508455fe70e65f7"}, - {file = "fonttools-4.61.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:664c5a68ec406f6b1547946683008576ef8b38275608e1cee6c061828171c118"}, - {file = "fonttools-4.61.1-cp314-cp314t-win32.whl", hash = "sha256:aed04cabe26f30c1647ef0e8fbb207516fd40fe9472e9439695f5c6998e60ac5"}, - {file = "fonttools-4.61.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2180f14c141d2f0f3da43f3a81bc8aa4684860f6b0e6f9e165a4831f24e6a23b"}, - {file = "fonttools-4.61.1-py3-none-any.whl", hash = "sha256:17d2bf5d541add43822bcf0c43d7d847b160c9bb01d15d5007d84e2217aaa371"}, - {file = "fonttools-4.61.1.tar.gz", hash = "sha256:6675329885c44657f826ef01d9e4fb33b9158e9d93c537d84ad8399539bc6f69"}, + {file = "fonttools-4.62.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:62b6a3d0028e458e9b59501cf7124a84cd69681c433570e4861aff4fb54a236c"}, + {file = "fonttools-4.62.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:966557078b55e697f65300b18025c54e872d7908d1899b7314d7c16e64868cb2"}, + {file = "fonttools-4.62.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cf34861145b516cddd19b07ae6f4a61ea1c6326031b960ec9ddce8ee815e888"}, + {file = "fonttools-4.62.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e2ff573de2775508c8a366351fb901c4ced5dc6cf2d87dd15c973bedcdd5216"}, + {file = "fonttools-4.62.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:55b189a1b3033860a38e4e5bd0626c5aa25c7ce9caee7bc784a8caec7a675401"}, + {file = "fonttools-4.62.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:825f98cd14907c74a4d0a3f7db8570886ffce9c6369fed1385020febf919abf6"}, + {file = "fonttools-4.62.0-cp310-cp310-win32.whl", hash = "sha256:c858030560f92a054444c6e46745227bfd3bb4e55383c80d79462cd47289e4b5"}, + {file = "fonttools-4.62.0-cp310-cp310-win_amd64.whl", hash = "sha256:9bf75eb69330e34ad2a096fac67887102c8537991eb6cac1507fc835bbb70e0a"}, + {file = "fonttools-4.62.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:196cafef9aeec5258425bd31a4e9a414b2ee0d1557bca184d7923d3d3bcd90f9"}, + {file = "fonttools-4.62.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:153afc3012ff8761b1733e8fbe5d98623409774c44ffd88fbcb780e240c11d13"}, + {file = "fonttools-4.62.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13b663fb197334de84db790353d59da2a7288fd14e9be329f5debc63ec0500a5"}, + {file = "fonttools-4.62.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:591220d5333264b1df0d3285adbdfe2af4f6a45bbf9ca2b485f97c9f577c49ff"}, + {file = "fonttools-4.62.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:579f35c121528a50c96bf6fcb6a393e81e7f896d4326bf40e379f1c971603db9"}, + {file = "fonttools-4.62.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:44956b003151d5a289eba6c71fe590d63509267c37e26de1766ba15d9c589582"}, + {file = "fonttools-4.62.0-cp311-cp311-win32.whl", hash = "sha256:42c7848fa8836ab92c23b1617c407a905642521ff2d7897fe2bf8381530172f1"}, + {file = "fonttools-4.62.0-cp311-cp311-win_amd64.whl", hash = "sha256:4da779e8f342a32856075ddb193b2a024ad900bc04ecb744014c32409ae871ed"}, + {file = "fonttools-4.62.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:22bde4dc12a9e09b5ced77f3b5053d96cf10c4976c6ac0dee293418ef289d221"}, + {file = "fonttools-4.62.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7199c73b326bad892f1cb53ffdd002128bfd58a89b8f662204fbf1daf8d62e85"}, + {file = "fonttools-4.62.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d732938633681d6e2324e601b79e93f7f72395ec8681f9cdae5a8c08bc167e72"}, + {file = "fonttools-4.62.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:31a804c16d76038cc4e3826e07678efb0a02dc4f15396ea8e07088adbfb2578e"}, + {file = "fonttools-4.62.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:090e74ac86e68c20150e665ef8e7e0c20cb9f8b395302c9419fa2e4d332c3b51"}, + {file = "fonttools-4.62.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8f086120e8be9e99ca1288aa5ce519833f93fe0ec6ebad2380c1dee18781f0b5"}, + {file = "fonttools-4.62.0-cp312-cp312-win32.whl", hash = "sha256:37a73e5e38fd05c637daede6ffed5f3496096be7df6e4a3198d32af038f87527"}, + {file = "fonttools-4.62.0-cp312-cp312-win_amd64.whl", hash = "sha256:658ab837c878c4d2a652fcbb319547ea41693890e6434cf619e66f79387af3b8"}, + {file = "fonttools-4.62.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:274c8b8a87e439faf565d3bcd3f9f9e31bca7740755776a4a90a4bfeaa722efa"}, + {file = "fonttools-4.62.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:93e27131a5a0ae82aaadcffe309b1bae195f6711689722af026862bede05c07c"}, + {file = "fonttools-4.62.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:83c6524c5b93bad9c2939d88e619fedc62e913c19e673f25d5ab74e7a5d074e5"}, + {file = "fonttools-4.62.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:106aec9226f9498fc5345125ff7200842c01eda273ae038f5049b0916907acee"}, + {file = "fonttools-4.62.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:15d86b96c79013320f13bc1b15f94789edb376c0a2d22fb6088f33637e8dfcbc"}, + {file = "fonttools-4.62.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4f16c07e5250d5d71d0f990a59460bc5620c3cc456121f2cfb5b60475699905f"}, + {file = "fonttools-4.62.0-cp313-cp313-win32.whl", hash = "sha256:d31558890f3fa00d4f937d12708f90c7c142c803c23eaeb395a71f987a77ebe3"}, + {file = "fonttools-4.62.0-cp313-cp313-win_amd64.whl", hash = "sha256:6826a5aa53fb6def8a66bf423939745f415546c4e92478a7c531b8b6282b6c3b"}, + {file = "fonttools-4.62.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:4fa5a9c716e2f75ef34b5a5c2ca0ee4848d795daa7e6792bf30fd4abf8993449"}, + {file = "fonttools-4.62.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:625f5cbeb0b8f4e42343eaeb4bc2786718ddd84760a2f5e55fdd3db049047c00"}, + {file = "fonttools-4.62.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6247e58b96b982709cd569a91a2ba935d406dccf17b6aa615afaed37ac3856aa"}, + {file = "fonttools-4.62.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:840632ea9c1eab7b7f01c369e408c0721c287dfd7500ab937398430689852fd1"}, + {file = "fonttools-4.62.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:28a9ea2a7467a816d1bec22658b0cce4443ac60abac3e293bdee78beb74588f3"}, + {file = "fonttools-4.62.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5ae611294f768d413949fd12693a8cba0e6332fbc1e07aba60121be35eac68d0"}, + {file = "fonttools-4.62.0-cp314-cp314-win32.whl", hash = "sha256:273acb61f316d07570a80ed5ff0a14a23700eedbec0ad968b949abaa4d3f6bb5"}, + {file = "fonttools-4.62.0-cp314-cp314-win_amd64.whl", hash = "sha256:a5f974006d14f735c6c878fc4b117ad031dc93638ddcc450ca69f8fd64d5e104"}, + {file = "fonttools-4.62.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0361a7d41d86937f1f752717c19f719d0fde064d3011038f9f19bdf5fc2f5c95"}, + {file = "fonttools-4.62.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4108c12773b3c97aa592311557c405d5b4fc03db2b969ed928fcf68e7b3c887"}, + {file = "fonttools-4.62.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b448075f32708e8fb377fe7687f769a5f51a027172c591ba9a58693631b077a8"}, + {file = "fonttools-4.62.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e5f1fa8cc9f1a56a3e33ee6b954d6d9235e6b9d11eb7a6c9dfe2c2f829dc24db"}, + {file = "fonttools-4.62.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f8c8ea812f82db1e884b9cdb663080453e28f0f9a1f5027a5adb59c4cc8d38d1"}, + {file = "fonttools-4.62.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:03c6068adfdc67c565d217e92386b1cdd951abd4240d65180cec62fa74ba31b2"}, + {file = "fonttools-4.62.0-cp314-cp314t-win32.whl", hash = "sha256:d28d5baacb0017d384df14722a63abe6e0230d8ce642b1615a27d78ffe3bc983"}, + {file = "fonttools-4.62.0-cp314-cp314t-win_amd64.whl", hash = "sha256:3f9e20c4618f1e04190c802acae6dc337cb6db9fa61e492fd97cd5c5a9ff6d07"}, + {file = "fonttools-4.62.0-py3-none-any.whl", hash = "sha256:75064f19a10c50c74b336aa5ebe7b1f89fd0fb5255807bfd4b0c6317098f4af3"}, + {file = "fonttools-4.62.0.tar.gz", hash = "sha256:0dc477c12b8076b4eb9af2e440421b0433ffa9e1dcb39e0640a6c94665ed1098"}, ] [package.extras] @@ -1678,35 +1666,38 @@ files = [ [[package]] name = "hf-xet" -version = "1.2.0" +version = "1.3.2" description = "Fast transfer of large files with the Hugging Face Hub." optional = false python-versions = ">=3.8" groups = ["main"] markers = "platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"arm64\" or platform_machine == \"aarch64\"" files = [ - {file = "hf_xet-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:ceeefcd1b7aed4956ae8499e2199607765fbd1c60510752003b6cc0b8413b649"}, - {file = "hf_xet-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b70218dd548e9840224df5638fdc94bd033552963cfa97f9170829381179c813"}, - {file = "hf_xet-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d40b18769bb9a8bc82a9ede575ce1a44c75eb80e7375a01d76259089529b5dc"}, - {file = "hf_xet-1.2.0-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:cd3a6027d59cfb60177c12d6424e31f4b5ff13d8e3a1247b3a584bf8977e6df5"}, - {file = "hf_xet-1.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6de1fc44f58f6dd937956c8d304d8c2dea264c80680bcfa61ca4a15e7b76780f"}, - {file = "hf_xet-1.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f182f264ed2acd566c514e45da9f2119110e48a87a327ca271027904c70c5832"}, - {file = "hf_xet-1.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:293a7a3787e5c95d7be1857358a9130694a9c6021de3f27fa233f37267174382"}, - {file = "hf_xet-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:10bfab528b968c70e062607f663e21e34e2bba349e8038db546646875495179e"}, - {file = "hf_xet-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2a212e842647b02eb6a911187dc878e79c4aa0aa397e88dd3b26761676e8c1f8"}, - {file = "hf_xet-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:30e06daccb3a7d4c065f34fc26c14c74f4653069bb2b194e7f18f17cbe9939c0"}, - {file = "hf_xet-1.2.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:29c8fc913a529ec0a91867ce3d119ac1aac966e098cf49501800c870328cc090"}, - {file = "hf_xet-1.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e159cbfcfbb29f920db2c09ed8b660eb894640d284f102ada929b6e3dc410a"}, - {file = "hf_xet-1.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9c91d5ae931510107f148874e9e2de8a16052b6f1b3ca3c1b12f15ccb491390f"}, - {file = "hf_xet-1.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:210d577732b519ac6ede149d2f2f34049d44e8622bf14eb3d63bbcd2d4b332dc"}, - {file = "hf_xet-1.2.0-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:46740d4ac024a7ca9b22bebf77460ff43332868b661186a8e46c227fdae01848"}, - {file = "hf_xet-1.2.0-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:27df617a076420d8845bea087f59303da8be17ed7ec0cd7ee3b9b9f579dff0e4"}, - {file = "hf_xet-1.2.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3651fd5bfe0281951b988c0facbe726aa5e347b103a675f49a3fa8144c7968fd"}, - {file = "hf_xet-1.2.0-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:d06fa97c8562fb3ee7a378dd9b51e343bc5bc8190254202c9771029152f5e08c"}, - {file = "hf_xet-1.2.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:4c1428c9ae73ec0939410ec73023c4f842927f39db09b063b9482dac5a3bb737"}, - {file = "hf_xet-1.2.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a55558084c16b09b5ed32ab9ed38421e2d87cf3f1f89815764d1177081b99865"}, - {file = "hf_xet-1.2.0-cp37-abi3-win_amd64.whl", hash = "sha256:e6584a52253f72c9f52f9e549d5895ca7a471608495c4ecaa6cc73dba2b24d69"}, - {file = "hf_xet-1.2.0.tar.gz", hash = "sha256:a8c27070ca547293b6890c4bf389f713f80e8c478631432962bb7f4bc0bd7d7f"}, + {file = "hf_xet-1.3.2-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:335a8f36c55fd35a92d0062f4e9201b4015057e62747b7e7001ffb203c0ee1d2"}, + {file = "hf_xet-1.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c1ae4d3a716afc774e66922f3cac8206bfa707db13f6a7e62dfff74bfc95c9a8"}, + {file = "hf_xet-1.3.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6dbdf231efac0b9b39adcf12a07f0c030498f9212a18e8c50224d0e84ab803d"}, + {file = "hf_xet-1.3.2-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:c1980abfb68ecf6c1c7983379ed7b1e2b49a1aaf1a5aca9acc7d48e5e2e0a961"}, + {file = "hf_xet-1.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:1c88fbd90ad0d27c46b77a445f0a436ebaa94e14965c581123b68b1c52f5fd30"}, + {file = "hf_xet-1.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:35b855024ca37f2dd113ac1c08993e997fbe167b9d61f9ef66d3d4f84015e508"}, + {file = "hf_xet-1.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:31612ba0629046e425ba50375685a2586e11fb9144270ebabd75878c3eaf6378"}, + {file = "hf_xet-1.3.2-cp313-cp313t-win_arm64.whl", hash = "sha256:433c77c9f4e132b562f37d66c9b22c05b5479f243a1f06a120c1c06ce8b1502a"}, + {file = "hf_xet-1.3.2-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:c34e2c7aefad15792d57067c1c89b2b02c1bbaeabd7f8456ae3d07b4bbaf4094"}, + {file = "hf_xet-1.3.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:4bc995d6c41992831f762096020dc14a65fdf3963f86ffed580b596d04de32e3"}, + {file = "hf_xet-1.3.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:959083c89dee30f7d6f890b36cdadda823386c4de63b1a30384a75bfd2ae995d"}, + {file = "hf_xet-1.3.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:cfa760888633b08c01b398d212ce7e8c0d7adac6c86e4b20dfb2397d8acd78ee"}, + {file = "hf_xet-1.3.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:3155a02e083aa21fd733a7485c7c36025e49d5975c8d6bda0453d224dd0b0ac4"}, + {file = "hf_xet-1.3.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:91b1dc03c31cbf733d35dc03df7c5353686233d86af045e716f1e0ea4a2673cf"}, + {file = "hf_xet-1.3.2-cp314-cp314t-win_amd64.whl", hash = "sha256:211f30098512d95e85ad03ae63bd7dd2c4df476558a5095d09f9e38e78cbf674"}, + {file = "hf_xet-1.3.2-cp314-cp314t-win_arm64.whl", hash = "sha256:4a6817c41de7c48ed9270da0b02849347e089c5ece9a0e72ae4f4b3a57617f82"}, + {file = "hf_xet-1.3.2-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:f93b7595f1d8fefddfede775c18b5c9256757824f7f6832930b49858483cd56f"}, + {file = "hf_xet-1.3.2-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:a85d3d43743174393afe27835bde0cd146e652b5fcfdbcd624602daef2ef3259"}, + {file = "hf_xet-1.3.2-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7c2a054a97c44e136b1f7f5a78f12b3efffdf2eed3abc6746fc5ea4b39511633"}, + {file = "hf_xet-1.3.2-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:06b724a361f670ae557836e57801b82c75b534812e351a87a2c739f77d1e0635"}, + {file = "hf_xet-1.3.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:305f5489d7241a47e0458ef49334be02411d1d0f480846363c1c8084ed9916f7"}, + {file = "hf_xet-1.3.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:06cdbde243c85f39a63b28e9034321399c507bcd5e7befdd17ed2ccc06dfe14e"}, + {file = "hf_xet-1.3.2-cp37-abi3-win_amd64.whl", hash = "sha256:9298b47cce6037b7045ae41482e703c471ce36b52e73e49f71226d2e8e5685a1"}, + {file = "hf_xet-1.3.2-cp37-abi3-win_arm64.whl", hash = "sha256:83d8ec273136171431833a6957e8f3af496bee227a0fe47c7b8b39c106d1749a"}, + {file = "hf_xet-1.3.2.tar.gz", hash = "sha256:e130ee08984783d12717444e538587fa2119385e5bd8fc2bb9f930419b73a7af"}, ] [package.extras] @@ -1773,37 +1764,36 @@ files = [ [[package]] name = "huggingface-hub" -version = "1.4.1" +version = "1.6.0" description = "Client library to download and publish models, datasets and other repos on the huggingface.co hub" optional = false python-versions = ">=3.9.0" groups = ["main"] files = [ - {file = "huggingface_hub-1.4.1-py3-none-any.whl", hash = "sha256:9931d075fb7a79af5abc487106414ec5fba2c0ae86104c0c62fd6cae38873d18"}, - {file = "huggingface_hub-1.4.1.tar.gz", hash = "sha256:b41131ec35e631e7383ab26d6146b8d8972abc8b6309b963b306fbcca87f5ed5"}, + {file = "huggingface_hub-1.6.0-py3-none-any.whl", hash = "sha256:ef40e2d5cb85e48b2c067020fa5142168342d5108a1b267478ed384ecbf18961"}, + {file = "huggingface_hub-1.6.0.tar.gz", hash = "sha256:d931ddad8ba8dfc1e816bf254810eb6f38e5c32f60d4184b5885662a3b167325"}, ] [package.dependencies] -filelock = "*" +filelock = ">=3.10.0" fsspec = ">=2023.5.0" -hf-xet = {version = ">=1.2.0,<2.0.0", markers = "platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"arm64\" or platform_machine == \"aarch64\""} +hf-xet = {version = ">=1.3.2,<2.0.0", markers = "platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"arm64\" or platform_machine == \"aarch64\""} httpx = ">=0.23.0,<1" packaging = ">=20.9" pyyaml = ">=5.1" -shellingham = "*" tqdm = ">=4.42.1" -typer-slim = "*" +typer = "*" typing-extensions = ">=4.1.0" [package.extras] -all = ["Jinja2", "Pillow", "authlib (>=1.3.2)", "fastapi", "fastapi", "httpx", "itsdangerous", "jedi", "libcst (>=1.4.0)", "mypy (==1.15.0)", "numpy", "pytest (>=8.4.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures (<16.0)", "pytest-vcr", "pytest-xdist", "ruff (>=0.9.0)", "soundfile", "ty", "types-PyYAML", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)", "urllib3 (<2.0)"] -dev = ["Jinja2", "Pillow", "authlib (>=1.3.2)", "fastapi", "fastapi", "httpx", "itsdangerous", "jedi", "libcst (>=1.4.0)", "mypy (==1.15.0)", "numpy", "pytest (>=8.4.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures (<16.0)", "pytest-vcr", "pytest-xdist", "ruff (>=0.9.0)", "soundfile", "ty", "types-PyYAML", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)", "urllib3 (<2.0)"] +all = ["Jinja2", "Pillow", "authlib (>=1.3.2)", "duckdb", "fastapi", "fastapi", "httpx", "itsdangerous", "jedi", "libcst (>=1.4.0)", "mypy (==1.15.0)", "numpy", "pytest (>=8.4.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures (<16.0)", "pytest-vcr", "pytest-xdist", "ruff (>=0.9.0)", "soundfile", "ty", "types-PyYAML", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)", "urllib3 (<2.0)"] +dev = ["Jinja2", "Pillow", "authlib (>=1.3.2)", "duckdb", "fastapi", "fastapi", "httpx", "itsdangerous", "jedi", "libcst (>=1.4.0)", "mypy (==1.15.0)", "numpy", "pytest (>=8.4.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures (<16.0)", "pytest-vcr", "pytest-xdist", "ruff (>=0.9.0)", "soundfile", "ty", "types-PyYAML", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)", "urllib3 (<2.0)"] fastai = ["fastai (>=2.4)", "fastcore (>=1.3.27)", "toml"] -hf-xet = ["hf-xet (>=1.2.0,<2.0.0)"] +hf-xet = ["hf-xet (>=1.3.2,<2.0.0)"] mcp = ["mcp (>=1.8.0)"] oauth = ["authlib (>=1.3.2)", "fastapi", "httpx", "itsdangerous"] quality = ["libcst (>=1.4.0)", "mypy (==1.15.0)", "ruff (>=0.9.0)", "ty"] -testing = ["Jinja2", "Pillow", "authlib (>=1.3.2)", "fastapi", "fastapi", "httpx", "itsdangerous", "jedi", "numpy", "pytest (>=8.4.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures (<16.0)", "pytest-vcr", "pytest-xdist", "soundfile", "urllib3 (<2.0)"] +testing = ["Jinja2", "Pillow", "authlib (>=1.3.2)", "duckdb", "fastapi", "fastapi", "httpx", "itsdangerous", "jedi", "numpy", "pytest (>=8.4.2)", "pytest-asyncio", "pytest-cov", "pytest-env", "pytest-mock", "pytest-rerunfailures (<16.0)", "pytest-vcr", "pytest-xdist", "soundfile", "urllib3 (<2.0)"] torch = ["safetensors[torch]", "torch"] typing = ["types-PyYAML", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)"] @@ -1826,14 +1816,14 @@ pydantic = ">=2.0,<3" [[package]] name = "identify" -version = "2.6.16" +version = "2.6.17" description = "File identification library for Python" optional = false python-versions = ">=3.10" groups = ["dev"] files = [ - {file = "identify-2.6.16-py2.py3-none-any.whl", hash = "sha256:391ee4d77741d994189522896270b787aed8670389bfd60f326d677d64a6dfb0"}, - {file = "identify-2.6.16.tar.gz", hash = "sha256:846857203b5511bbe94d5a352a48ef2359532bc8f6727b5544077a0dcfb24980"}, + {file = "identify-2.6.17-py2.py3-none-any.whl", hash = "sha256:be5f8412d5ed4b20f2bd41a65f920990bdccaa6a4a18a08f1eefdcd0bdd885f0"}, + {file = "identify-2.6.17.tar.gz", hash = "sha256:f816b0b596b204c9fdf076ded172322f2723cf958d02f9c3587504834c8ff04d"}, ] [package.extras] @@ -1931,6 +1921,7 @@ description = "IPython: Productive Interactive Computing" optional = false python-versions = ">=3.11" groups = ["dev"] +markers = "python_version == \"3.11\"" files = [ {file = "ipython-9.10.0-py3-none-any.whl", hash = "sha256:c6ab68cc23bba8c7e18e9b932797014cc61ea7fd6f19de180ab9ba73e65ee58d"}, {file = "ipython-9.10.0.tar.gz", hash = "sha256:cd9e656be97618a0676d058134cd44e6dc7012c0e5cb36a9ce96a8c904adaf77"}, @@ -1957,6 +1948,39 @@ matplotlib = ["matplotlib (>3.9)"] test = ["packaging (>=20.1.0)", "pytest (>=7.0.0)", "pytest-asyncio (>=1.0.0)", "setuptools (>=61.2)", "testpath (>=0.2)"] test-extra = ["curio", "ipykernel (>6.30)", "ipython[matplotlib]", "ipython[test]", "jupyter_ai", "nbclient", "nbformat", "numpy (>=1.27)", "pandas (>2.1)", "trio (>=0.1.0)"] +[[package]] +name = "ipython" +version = "9.11.0" +description = "IPython: Productive Interactive Computing" +optional = false +python-versions = ">=3.12" +groups = ["dev"] +markers = "python_version >= \"3.12\"" +files = [ + {file = "ipython-9.11.0-py3-none-any.whl", hash = "sha256:6922d5bcf944c6e525a76a0a304451b60a2b6f875e86656d8bc2dfda5d710e19"}, + {file = "ipython-9.11.0.tar.gz", hash = "sha256:2a94bc4406b22ecc7e4cb95b98450f3ea493a76bec8896cda11b78d7752a6667"}, +] + +[package.dependencies] +colorama = {version = ">=0.4.4", markers = "sys_platform == \"win32\""} +decorator = ">=5.1.0" +ipython-pygments-lexers = ">=1.0.0" +jedi = ">=0.18.2" +matplotlib-inline = ">=0.1.6" +pexpect = {version = ">4.6", markers = "sys_platform != \"win32\" and sys_platform != \"emscripten\""} +prompt_toolkit = ">=3.0.41,<3.1.0" +pygments = ">=2.14.0" +stack_data = ">=0.6.0" +traitlets = ">=5.13.0" + +[package.extras] +all = ["argcomplete (>=3.0)", "ipython[doc,matplotlib,terminal,test,test-extra]", "types-decorator"] +black = ["black"] +doc = ["docrepr", "exceptiongroup", "intersphinx_registry", "ipykernel", "ipython[matplotlib,test]", "setuptools (>=80.0)", "sphinx (>=8.0)", "sphinx-rtd-theme (>=0.1.8)", "sphinx_toml (==0.0.4)", "typing_extensions"] +matplotlib = ["matplotlib (>3.9)"] +test = ["packaging (>=23.0.0)", "pytest (>=7.0.0)", "pytest-asyncio (>=1.0.0)", "setuptools (>=80.0)", "testpath (>=0.2)"] +test-extra = ["curio", "ipykernel (>6.30)", "ipython[matplotlib]", "ipython[test]", "jupyter_ai", "nbclient", "nbformat", "numpy (>=2.0)", "pandas (>2.1)", "trio (>=0.22.0)"] + [[package]] name = "ipython-pygments-lexers" version = "1.1.1" @@ -2448,113 +2472,129 @@ test = ["hatch", "ipykernel", "openapi-core (>=0.18.0,<0.19.0)", "openapi-spec-v [[package]] name = "kiwisolver" -version = "1.4.9" +version = "1.5.0" description = "A fast implementation of the Cassowary constraint solver" optional = false python-versions = ">=3.10" groups = ["dev"] files = [ - {file = "kiwisolver-1.4.9-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b4b4d74bda2b8ebf4da5bd42af11d02d04428b2c32846e4c2c93219df8a7987b"}, - {file = "kiwisolver-1.4.9-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:fb3b8132019ea572f4611d770991000d7f58127560c4889729248eb5852a102f"}, - {file = "kiwisolver-1.4.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:84fd60810829c27ae375114cd379da1fa65e6918e1da405f356a775d49a62bcf"}, - {file = "kiwisolver-1.4.9-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:b78efa4c6e804ecdf727e580dbb9cba85624d2e1c6b5cb059c66290063bd99a9"}, - {file = "kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d4efec7bcf21671db6a3294ff301d2fc861c31faa3c8740d1a94689234d1b415"}, - {file = "kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:90f47e70293fc3688b71271100a1a5453aa9944a81d27ff779c108372cf5567b"}, - {file = "kiwisolver-1.4.9-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8fdca1def57a2e88ef339de1737a1449d6dbf5fab184c54a1fca01d541317154"}, - {file = "kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:9cf554f21be770f5111a1690d42313e140355e687e05cf82cb23d0a721a64a48"}, - {file = "kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:fc1795ac5cd0510207482c3d1d3ed781143383b8cfd36f5c645f3897ce066220"}, - {file = "kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:ccd09f20ccdbbd341b21a67ab50a119b64a403b09288c27481575105283c1586"}, - {file = "kiwisolver-1.4.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:540c7c72324d864406a009d72f5d6856f49693db95d1fbb46cf86febef873634"}, - {file = "kiwisolver-1.4.9-cp310-cp310-win_amd64.whl", hash = "sha256:ede8c6d533bc6601a47ad4046080d36b8fc99f81e6f1c17b0ac3c2dc91ac7611"}, - {file = "kiwisolver-1.4.9-cp310-cp310-win_arm64.whl", hash = "sha256:7b4da0d01ac866a57dd61ac258c5607b4cd677f63abaec7b148354d2b2cdd536"}, - {file = "kiwisolver-1.4.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb14a5da6dc7642b0f3a18f13654847cd8b7a2550e2645a5bda677862b03ba16"}, - {file = "kiwisolver-1.4.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:39a219e1c81ae3b103643d2aedb90f1ef22650deb266ff12a19e7773f3e5f089"}, - {file = "kiwisolver-1.4.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2405a7d98604b87f3fc28b1716783534b1b4b8510d8142adca34ee0bc3c87543"}, - {file = "kiwisolver-1.4.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:dc1ae486f9abcef254b5618dfb4113dd49f94c68e3e027d03cf0143f3f772b61"}, - {file = "kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a1f570ce4d62d718dce3f179ee78dac3b545ac16c0c04bb363b7607a949c0d1"}, - {file = "kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb27e7b78d716c591e88e0a09a2139c6577865d7f2e152488c2cc6257f460872"}, - {file = "kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:15163165efc2f627eb9687ea5f3a28137217d217ac4024893d753f46bce9de26"}, - {file = "kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bdee92c56a71d2b24c33a7d4c2856bd6419d017e08caa7802d2963870e315028"}, - {file = "kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:412f287c55a6f54b0650bd9b6dce5aceddb95864a1a90c87af16979d37c89771"}, - {file = "kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2c93f00dcba2eea70af2be5f11a830a742fe6b579a1d4e00f47760ef13be247a"}, - {file = "kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f117e1a089d9411663a3207ba874f31be9ac8eaa5b533787024dc07aeb74f464"}, - {file = "kiwisolver-1.4.9-cp311-cp311-win_amd64.whl", hash = "sha256:be6a04e6c79819c9a8c2373317d19a96048e5a3f90bec587787e86a1153883c2"}, - {file = "kiwisolver-1.4.9-cp311-cp311-win_arm64.whl", hash = "sha256:0ae37737256ba2de764ddc12aed4956460277f00c4996d51a197e72f62f5eec7"}, - {file = "kiwisolver-1.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ac5a486ac389dddcc5bef4f365b6ae3ffff2c433324fb38dd35e3fab7c957999"}, - {file = "kiwisolver-1.4.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2ba92255faa7309d06fe44c3a4a97efe1c8d640c2a79a5ef728b685762a6fd2"}, - {file = "kiwisolver-1.4.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a2899935e724dd1074cb568ce7ac0dce28b2cd6ab539c8e001a8578eb106d14"}, - {file = "kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f6008a4919fdbc0b0097089f67a1eb55d950ed7e90ce2cc3e640abadd2757a04"}, - {file = "kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:67bb8b474b4181770f926f7b7d2f8c0248cbcb78b660fdd41a47054b28d2a752"}, - {file = "kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2327a4a30d3ee07d2fbe2e7933e8a37c591663b96ce42a00bc67461a87d7df77"}, - {file = "kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a08b491ec91b1d5053ac177afe5290adacf1f0f6307d771ccac5de30592d198"}, - {file = "kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8fc5c867c22b828001b6a38d2eaeb88160bf5783c6cb4a5e440efc981ce286d"}, - {file = "kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3b3115b2581ea35bb6d1f24a4c90af37e5d9b49dcff267eeed14c3893c5b86ab"}, - {file = "kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858e4c22fb075920b96a291928cb7dea5644e94c0ee4fcd5af7e865655e4ccf2"}, - {file = "kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed0fecd28cc62c54b262e3736f8bb2512d8dcfdc2bcf08be5f47f96bf405b145"}, - {file = "kiwisolver-1.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:f68208a520c3d86ea51acf688a3e3002615a7f0238002cccc17affecc86a8a54"}, - {file = "kiwisolver-1.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:2c1a4f57df73965f3f14df20b80ee29e6a7930a57d2d9e8491a25f676e197c60"}, - {file = "kiwisolver-1.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5d0432ccf1c7ab14f9949eec60c5d1f924f17c037e9f8b33352fa05799359b8"}, - {file = "kiwisolver-1.4.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efb3a45b35622bb6c16dbfab491a8f5a391fe0e9d45ef32f4df85658232ca0e2"}, - {file = "kiwisolver-1.4.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a12cf6398e8a0a001a059747a1cbf24705e18fe413bc22de7b3d15c67cffe3f"}, - {file = "kiwisolver-1.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b67e6efbf68e077dd71d1a6b37e43e1a99d0bff1a3d51867d45ee8908b931098"}, - {file = "kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5656aa670507437af0207645273ccdfee4f14bacd7f7c67a4306d0dcaeaf6eed"}, - {file = "kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bfc08add558155345129c7803b3671cf195e6a56e7a12f3dde7c57d9b417f525"}, - {file = "kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:40092754720b174e6ccf9e845d0d8c7d8e12c3d71e7fc35f55f3813e96376f78"}, - {file = "kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:497d05f29a1300d14e02e6441cf0f5ee81c1ff5a304b0d9fb77423974684e08b"}, - {file = "kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdd1a81a1860476eb41ac4bc1e07b3f07259e6d55bbf739b79c8aaedcf512799"}, - {file = "kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e6b93f13371d341afee3be9f7c5964e3fe61d5fa30f6a30eb49856935dfe4fc3"}, - {file = "kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d75aa530ccfaa593da12834b86a0724f58bff12706659baa9227c2ccaa06264c"}, - {file = "kiwisolver-1.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:dd0a578400839256df88c16abddf9ba14813ec5f21362e1fe65022e00c883d4d"}, - {file = "kiwisolver-1.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:d4188e73af84ca82468f09cadc5ac4db578109e52acb4518d8154698d3a87ca2"}, - {file = "kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5a0f2724dfd4e3b3ac5a82436a8e6fd16baa7d507117e4279b660fe8ca38a3a1"}, - {file = "kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1b11d6a633e4ed84fc0ddafd4ebfd8ea49b3f25082c04ad12b8315c11d504dc1"}, - {file = "kiwisolver-1.4.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61874cdb0a36016354853593cffc38e56fc9ca5aa97d2c05d3dcf6922cd55a11"}, - {file = "kiwisolver-1.4.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:60c439763a969a6af93b4881db0eed8fadf93ee98e18cbc35bc8da868d0c4f0c"}, - {file = "kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92a2f997387a1b79a75e7803aa7ded2cfbe2823852ccf1ba3bcf613b62ae3197"}, - {file = "kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31d512c812daea6d8b3be3b2bfcbeb091dbb09177706569bcfc6240dcf8b41c"}, - {file = "kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:52a15b0f35dad39862d376df10c5230155243a2c1a436e39eb55623ccbd68185"}, - {file = "kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a30fd6fdef1430fd9e1ba7b3398b5ee4e2887783917a687d86ba69985fb08748"}, - {file = "kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cc9617b46837c6468197b5945e196ee9ca43057bb7d9d1ae688101e4e1dddf64"}, - {file = "kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:0ab74e19f6a2b027ea4f845a78827969af45ce790e6cb3e1ebab71bdf9f215ff"}, - {file = "kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dba5ee5d3981160c28d5490f0d1b7ed730c22470ff7f6cc26cfcfaacb9896a07"}, - {file = "kiwisolver-1.4.9-cp313-cp313t-win_arm64.whl", hash = "sha256:0749fd8f4218ad2e851e11cc4dc05c7cbc0cbc4267bdfdb31782e65aace4ee9c"}, - {file = "kiwisolver-1.4.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9928fe1eb816d11ae170885a74d074f57af3a0d65777ca47e9aeb854a1fba386"}, - {file = "kiwisolver-1.4.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d0005b053977e7b43388ddec89fa567f43d4f6d5c2c0affe57de5ebf290dc552"}, - {file = "kiwisolver-1.4.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2635d352d67458b66fd0667c14cb1d4145e9560d503219034a18a87e971ce4f3"}, - {file = "kiwisolver-1.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:767c23ad1c58c9e827b649a9ab7809fd5fd9db266a9cf02b0e926ddc2c680d58"}, - {file = "kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72d0eb9fba308b8311685c2268cf7d0a0639a6cd027d8128659f72bdd8a024b4"}, - {file = "kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f68e4f3eeca8fb22cc3d731f9715a13b652795ef657a13df1ad0c7dc0e9731df"}, - {file = "kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d84cd4061ae292d8ac367b2c3fa3aad11cb8625a95d135fe93f286f914f3f5a6"}, - {file = "kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a60ea74330b91bd22a29638940d115df9dc00af5035a9a2a6ad9399ffb4ceca5"}, - {file = "kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ce6a3a4e106cf35c2d9c4fa17c05ce0b180db622736845d4315519397a77beaf"}, - {file = "kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:77937e5e2a38a7b48eef0585114fe7930346993a88060d0bf886086d2aa49ef5"}, - {file = "kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:24c175051354f4a28c5d6a31c93906dc653e2bf234e8a4bbfb964892078898ce"}, - {file = "kiwisolver-1.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:0763515d4df10edf6d06a3c19734e2566368980d21ebec439f33f9eb936c07b7"}, - {file = "kiwisolver-1.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:0e4e2bf29574a6a7b7f6cb5fa69293b9f96c928949ac4a53ba3f525dffb87f9c"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d976bbb382b202f71c67f77b0ac11244021cfa3f7dfd9e562eefcea2df711548"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2489e4e5d7ef9a1c300a5e0196e43d9c739f066ef23270607d45aba368b91f2d"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e2ea9f7ab7fbf18fffb1b5434ce7c69a07582f7acc7717720f1d69f3e806f90c"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b34e51affded8faee0dfdb705416153819d8ea9250bbbf7ea1b249bdeb5f1122"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8aacd3d4b33b772542b2e01beb50187536967b514b00003bdda7589722d2a64"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7cf974dd4e35fa315563ac99d6287a1024e4dc2077b8a7d7cd3d2fb65d283134"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:85bd218b5ecfbee8c8a82e121802dcb519a86044c9c3b2e4aef02fa05c6da370"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0856e241c2d3df4efef7c04a1e46b1936b6120c9bcf36dd216e3acd84bc4fb21"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9af39d6551f97d31a4deebeac6f45b156f9755ddc59c07b402c148f5dbb6482a"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:bb4ae2b57fc1d8cbd1cf7b1d9913803681ffa903e7488012be5b76dedf49297f"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:aedff62918805fb62d43a4aa2ecd4482c380dc76cd31bd7c8878588a61bd0369"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:1fa333e8b2ce4d9660f2cda9c0e1b6bafcfb2457a9d259faa82289e73ec24891"}, - {file = "kiwisolver-1.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:4a48a2ce79d65d363597ef7b567ce3d14d68783d2b2263d98db3d9477805ba32"}, - {file = "kiwisolver-1.4.9-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4d1d9e582ad4d63062d34077a9a1e9f3c34088a2ec5135b1f7190c07cf366527"}, - {file = "kiwisolver-1.4.9-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:deed0c7258ceb4c44ad5ec7d9918f9f14fd05b2be86378d86cf50e63d1e7b771"}, - {file = "kiwisolver-1.4.9-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0a590506f303f512dff6b7f75fd2fd18e16943efee932008fe7140e5fa91d80e"}, - {file = "kiwisolver-1.4.9-pp310-pypy310_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e09c2279a4d01f099f52d5c4b3d9e208e91edcbd1a175c9662a8b16e000fece9"}, - {file = "kiwisolver-1.4.9-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:c9e7cdf45d594ee04d5be1b24dd9d49f3d1590959b2271fb30b5ca2b262c00fb"}, - {file = "kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:720e05574713db64c356e86732c0f3c5252818d05f9df320f0ad8380641acea5"}, - {file = "kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:17680d737d5335b552994a2008fab4c851bcd7de33094a82067ef3a576ff02fa"}, - {file = "kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:85b5352f94e490c028926ea567fc569c52ec79ce131dadb968d3853e809518c2"}, - {file = "kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:464415881e4801295659462c49461a24fb107c140de781d55518c4b80cb6790f"}, - {file = "kiwisolver-1.4.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fb940820c63a9590d31d88b815e7a3aa5915cad3ce735ab45f0c730b39547de1"}, - {file = "kiwisolver-1.4.9.tar.gz", hash = "sha256:c3b22c26c6fd6811b0ae8363b95ca8ce4ea3c202d3d0975b2914310ceb1bcc4d"}, + {file = "kiwisolver-1.5.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:32cc0a5365239a6ea0c6ed461e8838d053b57e397443c0ca894dcc8e388d4374"}, + {file = "kiwisolver-1.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cc0b66c1eec9021353a4b4483afb12dfd50e3669ffbb9152d6842eb34c7e29fd"}, + {file = "kiwisolver-1.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:86e0287879f75621ae85197b0877ed2f8b7aa57b511c7331dce2eb6f4de7d476"}, + {file = "kiwisolver-1.5.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:62f59da443c4f4849f73a51a193b1d9d258dcad0c41bc4d1b8fb2bcc04bfeb22"}, + {file = "kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9190426b7aa26c5229501fa297b8d0653cfd3f5a36f7990c264e157cbf886b3b"}, + {file = "kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c8277104ded0a51e699c8c3aff63ce2c56d4ed5519a5f73e0fd7057f959a2b9e"}, + {file = "kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8f9baf6f0a6e7571c45c8863010b45e837c3ee1c2c77fcd6ef423be91b21fedb"}, + {file = "kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cff8e5383db4989311f99e814feeb90c4723eb4edca425b9d5d9c3fefcdd9537"}, + {file = "kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ebae99ed6764f2b5771c522477b311be313e8841d2e0376db2b10922daebbba4"}, + {file = "kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:d5cd5189fc2b6a538b75ae45433140c4823463918f7b1617c31e68b085c0022c"}, + {file = "kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f42c23db5d1521218a3276bb08666dcb662896a0be7347cba864eca45ff64ede"}, + {file = "kiwisolver-1.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:94eff26096eb5395136634622515b234ecb6c9979824c1f5004c6e3c3c85ccd2"}, + {file = "kiwisolver-1.5.0-cp310-cp310-win_arm64.whl", hash = "sha256:dd952e03bfbb096cfe2dd35cd9e00f269969b67536cb4370994afc20ff2d0875"}, + {file = "kiwisolver-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9eed0f7edbb274413b6ee781cca50541c8c0facd3d6fd289779e494340a2b85c"}, + {file = "kiwisolver-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c4923e404d6bcd91b6779c009542e5647fef32e4a5d75e115e3bbac6f2335eb"}, + {file = "kiwisolver-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0df54df7e686afa55e6f21fb86195224a6d9beb71d637e8d7920c95cf0f89aac"}, + {file = "kiwisolver-1.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2517e24d7315eb51c10664cdb865195df38ab74456c677df67bb47f12d088a27"}, + {file = "kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff710414307fefa903e0d9bdf300972f892c23477829f49504e59834f4195398"}, + {file = "kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6176c1811d9d5a04fa391c490cc44f451e240697a16977f11c6f722efb9041db"}, + {file = "kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50847dca5d197fcbd389c805aa1a1cf32f25d2e7273dc47ab181a517666b68cc"}, + {file = "kiwisolver-1.5.0-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:01808c6d15f4c3e8559595d6d1fe6411c68e4a3822b4b9972b44473b24f4e679"}, + {file = "kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1f9f4121ec58628c96baa3de1a55a4e3a333c5102c8e94b64e23bf7b2083309"}, + {file = "kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b7d335370ae48a780c6e6a6bbfa97342f563744c39c35562f3f367665f5c1de2"}, + {file = "kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:800ee55980c18545af444d93fdd60c56b580db5cc54867d8cbf8a1dc0829938c"}, + {file = "kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c438f6ca858697c9ab67eb28246c92508af972e114cac34e57a6d4ba17a3ac08"}, + {file = "kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8c63c91f95173f9c2a67c7c526b2cea976828a0e7fced9cdcead2802dc10f8a4"}, + {file = "kiwisolver-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:beb7f344487cdcb9e1efe4b7a29681b74d34c08f0043a327a74da852a6749e7b"}, + {file = "kiwisolver-1.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:ad4ae4ffd1ee9cd11357b4c66b612da9888f4f4daf2f36995eda64bd45370cac"}, + {file = "kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9"}, + {file = "kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588"}, + {file = "kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819"}, + {file = "kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f"}, + {file = "kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf"}, + {file = "kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d"}, + {file = "kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083"}, + {file = "kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6"}, + {file = "kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1"}, + {file = "kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0"}, + {file = "kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15"}, + {file = "kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314"}, + {file = "kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9"}, + {file = "kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384"}, + {file = "kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7"}, + {file = "kiwisolver-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fd40bb9cd0891c4c3cb1ddf83f8bbfa15731a248fdc8162669405451e2724b09"}, + {file = "kiwisolver-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c0e1403fd7c26d77c1f03e096dc58a5c726503fa0db0456678b8668f76f521e3"}, + {file = "kiwisolver-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dda366d548e89a90d88a86c692377d18d8bd64b39c1fb2b92cb31370e2896bbd"}, + {file = "kiwisolver-1.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:332b4f0145c30b5f5ad9374881133e5aa64320428a57c2c2b61e9d891a51c2f3"}, + {file = "kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c50b89ffd3e1a911c69a1dd3de7173c0cd10b130f56222e57898683841e4f96"}, + {file = "kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4db576bb8c3ef9365f8b40fe0f671644de6736ae2c27a2c62d7d8a1b4329f099"}, + {file = "kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0b85aad90cea8ac6797a53b5d5f2e967334fa4d1149f031c4537569972596cb8"}, + {file = "kiwisolver-1.5.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:d36ca54cb4c6c4686f7cbb7b817f66f5911c12ddb519450bbe86707155028f87"}, + {file = "kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:38f4a703656f493b0ad185211ccfca7f0386120f022066b018eb5296d8613e23"}, + {file = "kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ac2360e93cb41be81121755c6462cff3beaa9967188c866e5fce5cf13170859"}, + {file = "kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c95cab08d1965db3d84a121f1c7ce7479bdd4072c9b3dafd8fecce48a2e6b902"}, + {file = "kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc20894c3d21194d8041a28b65622d5b86db786da6e3cfe73f0c762951a61167"}, + {file = "kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a32f72973f0f950c1920475d5c5ea3d971b81b6f0ec53b8d0a956cc965f22e0"}, + {file = "kiwisolver-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bf3acf1419fa93064a4c2189ac0b58e3be7872bf6ee6177b0d4c63dc4cea276"}, + {file = "kiwisolver-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa8eb9ecdb7efb0b226acec134e0d709e87a909fa4971a54c0c4f6e88635484c"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db485b3847d182b908b483b2ed133c66d88d49cacf98fd278fadafe11b4478d1"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:be12f931839a3bdfe28b584db0e640a65a8bcbc24560ae3fdb025a449b3d754e"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:16b85d37c2cbb3253226d26e64663f755d88a03439a9c47df6246b35defbdfb7"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4432b835675f0ea7414aab3d37d119f7226d24869b7a829caeab49ebda407b0c"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b0feb50971481a2cc44d94e88bdb02cdd497618252ae226b8eb1201b957e368"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fa888f10d0f367155e76ce849fa1166fc9730d13bd2d65a2aa13b6f5424489"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:940dda65d5e764406b9fb92761cbf462e4e63f712ab60ed98f70552e496f3bf1"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:89fc958c702ee9a745e4700378f5d23fddbc46ff89e8fdbf5395c24d5c1452a3"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9027d773c4ff81487181a925945743413f6069634d0b122d0b37684ccf4f1e18"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5b233ea3e165e43e35dba1d2b8ecc21cf070b45b65ae17dd2747d2713d942021"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ce9bf03dad3b46408c08649c6fbd6ca28a9fce0eb32fdfffa6775a13103b5310"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2"}, + {file = "kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53"}, + {file = "kiwisolver-1.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8df31fe574b8b3993cc61764f40941111b25c2d9fea13d3ce24a49907cd2d615"}, + {file = "kiwisolver-1.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1d49a49ac4cbfb7c1375301cd1ec90169dfeae55ff84710d782260ce77a75a02"}, + {file = "kiwisolver-1.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0cbe94b69b819209a62cb27bdfa5dc2a8977d8de2f89dfd97ba4f53ed3af754e"}, + {file = "kiwisolver-1.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:80aa065ffd378ff784822a6d7c3212f2d5f5e9c3589614b5c228b311fd3063ac"}, + {file = "kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e7f886f47ab881692f278ae901039a234e4025a68e6dfab514263a0b1c4ae05"}, + {file = "kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5060731cc3ed12ca3a8b57acd4aeca5bbc2f49216dd0bec1650a1acd89486bcd"}, + {file = "kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a4aa69609f40fce3cbc3f87b2061f042eee32f94b8f11db707b66a26461591a"}, + {file = "kiwisolver-1.5.0-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:d168fda2dbff7b9b5f38e693182d792a938c31db4dac3a80a4888de603c99554"}, + {file = "kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:413b820229730d358efd838ecbab79902fe97094565fdc80ddb6b0a18c18a581"}, + {file = "kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5124d1ea754509b09e53738ec185584cc609aae4a3b510aaf4ed6aa047ef9303"}, + {file = "kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e4415a8db000bf49a6dd1c478bf70062eaacff0f462b92b0ba68791a905861f9"}, + {file = "kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d618fd27420381a4f6044faa71f46d8bfd911bd077c555f7138ed88729bfbe79"}, + {file = "kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5092eb5b1172947f57d6ea7d89b2f29650414e4293c47707eb499ec07a0ac796"}, + {file = "kiwisolver-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:d76e2d8c75051d58177e762164d2e9ab92886534e3a12e795f103524f221dd8e"}, + {file = "kiwisolver-1.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:fa6248cd194edff41d7ea9425ced8ca3a6f838bfb295f6f1d6e6bb694a8518df"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d1ffeb80b5676463d7a7d56acbe8e37a20ce725570e09549fe738e02ca6b7e1e"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bc4d8e252f532ab46a1de9349e2d27b91fce46736a9eedaa37beaca66f574ed4"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6783e069732715ad0c3ce96dbf21dbc2235ab0593f2baf6338101f70371f4028"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e7c4c09a490dc4d4a7f8cbee56c606a320f9dc28cf92a7157a39d1ce7676a657"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a075bd7bd19c70cf67c8badfa36cf7c5d8de3c9ddb8420c51e10d9c50e94920"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bdd3e53429ff02aa319ba59dfe4ceeec345bf46cf180ec2cf6fd5b942e7975e9"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cdcb35dc9d807259c981a85531048ede628eabcffb3239adf3d17463518992d"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:70d593af6a6ca332d1df73d519fddb5148edb15cd90d5f0155e3746a6d4fcc65"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:377815a8616074cabbf3f53354e1d040c35815a134e01d7614b7692e4bf8acfa"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0255a027391d52944eae1dbb5d4cc5903f57092f3674e8e544cdd2622826b3f0"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:012b1eb16e28718fa782b5e61dc6f2da1f0792ca73bd05d54de6cb9561665fc9"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e3aafb33aed7479377e5e9a82e9d4bf87063741fc99fc7ae48b0f16e32bdd6f"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7a116ae737f0000343218c4edf5bd45893bfeaff0993c0b215d7124c9f77646"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1dd9b0b119a350976a6d781e7278ec7aca0b201e1a9e2d23d9804afecb6ca681"}, + {file = "kiwisolver-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:58f812017cd2985c21fbffb4864d59174d4903dd66fa23815e74bbc7a0e2dd57"}, + {file = "kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797"}, + {file = "kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203"}, + {file = "kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7"}, + {file = "kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57"}, + {file = "kiwisolver-1.5.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:295d9ffe712caa9f8a3081de8d32fc60191b4b51c76f02f951fd8407253528f4"}, + {file = "kiwisolver-1.5.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:51e8c4084897de9f05898c2c2a39af6318044ae969d46ff7a34ed3f96274adca"}, + {file = "kiwisolver-1.5.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b83af57bdddef03c01a9138034c6ff03181a3028d9a1003b301eb1a55e161a3f"}, + {file = "kiwisolver-1.5.0-pp310-pypy310_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf4679a3d71012a7c2bf360e5cd878fbd5e4fcac0896b56393dec239d81529ed"}, + {file = "kiwisolver-1.5.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:41024ed50e44ab1a60d3fe0a9d15a4ccc9f5f2b1d814ff283c8d01134d5b81bc"}, + {file = "kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ec4c85dc4b687c7f7f15f553ff26a98bfe8c58f5f7f0ac8905f0ba4c7be60232"}, + {file = "kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:12e91c215a96e39f57989c8912ae761286ac5a9584d04030ceb3368a357f017a"}, + {file = "kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be4a51a55833dc29ab5d7503e7bcb3b3af3402d266018137127450005cdfe737"}, + {file = "kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daae526907e262de627d8f70058a0f64acc9e2641c164c99c8f594b34a799a16"}, + {file = "kiwisolver-1.5.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:59cd8683f575d96df5bb48f6add94afc055012c29e28124fcae2b63661b9efb1"}, + {file = "kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a"}, ] [[package]] @@ -2575,16 +2615,37 @@ interegular = ["interegular (>=0.3.1,<0.4.0)"] nearley = ["js2py"] regex = ["regex"] +[[package]] +name = "linkify-it-py" +version = "2.1.0" +description = "Links recognition library with FULL unicode support." +optional = false +python-versions = ">=3.10" +groups = ["main"] +files = [ + {file = "linkify_it_py-2.1.0-py3-none-any.whl", hash = "sha256:0d252c1594ecba2ecedc444053db5d3a9b7ec1b0dd929c8f1d74dce89f86c05e"}, + {file = "linkify_it_py-2.1.0.tar.gz", hash = "sha256:43360231720999c10e9328dc3691160e27a718e280673d444c38d7d3aaa3b98b"}, +] + +[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 = "litellm" -version = "1.81.14" +version = "1.82.0" description = "Library to easily interface with LLM API providers" optional = false python-versions = "<4.0,>=3.9" groups = ["main"] files = [ - {file = "litellm-1.81.14-py3-none-any.whl", hash = "sha256:6394e61bbdef7121e5e3800349f6b01e9369e7cf611e034f1832750c481abfed"}, - {file = "litellm-1.81.14.tar.gz", hash = "sha256:445efb92ae359e8f40ee984753c5ae752535eb18a2aeef00d3089922de5676b7"}, + {file = "litellm-1.82.0-py3-none-any.whl", hash = "sha256:5496b5d4532cccdc7a095c21cbac4042f7662021c57bc1d17be4e39838929e80"}, + {file = "litellm-1.82.0.tar.gz", hash = "sha256:d388f52447daccbcaafa19a3e68d17b75f1374b5bf2cde680d65e1cd86e50d22"}, ] [package.dependencies] @@ -2607,7 +2668,7 @@ extra-proxy = ["a2a-sdk (>=0.3.22,<0.4.0) ; python_version >= \"3.10\"", "azure- google = ["google-cloud-aiplatform (>=1.38.0)"] grpc = ["grpcio (>=1.62.3,<1.68.dev0 || >1.71.0,!=1.71.1,!=1.72.0,!=1.72.1,!=1.73.0) ; python_version < \"3.14\"", "grpcio (>=1.75.0) ; python_version >= \"3.14\""] mlflow = ["mlflow (>3.1.4) ; python_version >= \"3.10\""] -proxy = ["PyJWT (>=2.10.1,<3.0.0) ; python_version >= \"3.9\"", "apscheduler (>=3.10.4,<4.0.0)", "azure-identity (>=1.15.0,<2.0.0) ; python_version >= \"3.9\"", "azure-storage-blob (>=12.25.1,<13.0.0)", "backoff", "boto3 (==1.40.76)", "cryptography", "fastapi (>=0.120.1)", "fastapi-sso (>=0.16.0,<0.17.0)", "gunicorn (>=23.0.0,<24.0.0)", "litellm-enterprise (==0.1.32)", "litellm-proxy-extras (==0.4.46)", "mcp (>=1.25.0,<2.0.0) ; python_version >= \"3.10\"", "orjson (>=3.9.7,<4.0.0)", "polars (>=1.31.0,<2.0.0) ; python_version >= \"3.10\"", "pynacl (>=1.5.0,<2.0.0)", "pyroscope-io (>=0.8,<0.9) ; sys_platform != \"win32\"", "python-multipart (>=0.0.22,<0.0.23) ; python_version >= \"3.10\"", "pyyaml (>=6.0.1,<7.0.0)", "rich (==13.7.1)", "rq", "soundfile (>=0.12.1,<0.13.0)", "uvicorn (>=0.32.1,<1.0.0)", "uvloop (>=0.21.0,<0.22.0) ; sys_platform != \"win32\"", "websockets (>=15.0.1,<16.0.0)"] +proxy = ["PyJWT (>=2.10.1,<3.0.0) ; python_version >= \"3.9\"", "apscheduler (>=3.10.4,<4.0.0)", "azure-identity (>=1.15.0,<2.0.0) ; python_version >= \"3.9\"", "azure-storage-blob (>=12.25.1,<13.0.0)", "backoff", "boto3 (==1.40.76)", "cryptography", "fastapi (>=0.120.1)", "fastapi-sso (>=0.16.0,<0.17.0)", "gunicorn (>=23.0.0,<24.0.0)", "litellm-enterprise (==0.1.33)", "litellm-proxy-extras (==0.4.50)", "mcp (>=1.25.0,<2.0.0) ; python_version >= \"3.10\"", "orjson (>=3.9.7,<4.0.0)", "polars (>=1.31.0,<2.0.0) ; python_version >= \"3.10\"", "pynacl (>=1.5.0,<2.0.0)", "pyroscope-io (>=0.8,<0.9) ; sys_platform != \"win32\"", "python-multipart (>=0.0.22,<0.0.23) ; python_version >= \"3.10\"", "pyyaml (>=6.0.1,<7.0.0)", "rich (==13.7.1)", "rq", "soundfile (>=0.12.1,<0.13.0)", "uvicorn (>=0.32.1,<1.0.0)", "uvloop (>=0.21.0,<0.22.0) ; sys_platform != \"win32\"", "websockets (>=15.0.1,<16.0.0)"] semantic-router = ["semantic-router (>=0.1.12) ; python_version >= \"3.9\" and python_version < \"3.14\""] utils = ["numpydoc"] @@ -2624,6 +2685,8 @@ files = [ ] [package.dependencies] +linkify-it-py = {version = ">=1,<3", optional = true, markers = "extra == \"linkify\""} +mdit-py-plugins = {version = ">=0.5.0", optional = true, markers = "extra == \"plugins\""} mdurl = ">=0.1,<1.0" [package.extras] @@ -2882,6 +2945,26 @@ cli = ["python-dotenv (>=1.0.0)", "typer (>=0.16.0)"] rich = ["rich (>=13.9.4)"] ws = ["websockets (>=15.0.1)"] +[[package]] +name = "mdit-py-plugins" +version = "0.5.0" +description = "Collection of plugins for markdown-it-py" +optional = false +python-versions = ">=3.10" +groups = ["main"] +files = [ + {file = "mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f"}, + {file = "mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6"}, +] + +[package.dependencies] +markdown-it-py = ">=2.0.0,<5.0.0" + +[package.extras] +code-style = ["pre-commit"] +rtd = ["myst-parser", "sphinx-book-theme"] +testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] + [[package]] name = "mdurl" version = "0.1.2" @@ -3196,19 +3279,19 @@ files = [ [[package]] name = "notebook" -version = "7.5.3" +version = "7.5.4" description = "Jupyter Notebook - A web-based notebook environment for interactive computing" optional = false python-versions = ">=3.9" groups = ["dev"] files = [ - {file = "notebook-7.5.3-py3-none-any.whl", hash = "sha256:c997bfa1a2a9eb58c9bbb7e77d50428befb1033dd6f02c482922e96851d67354"}, - {file = "notebook-7.5.3.tar.gz", hash = "sha256:393ceb269cf9fdb02a3be607a57d7bd5c2c14604f1818a17dbeb38e04f98cbfa"}, + {file = "notebook-7.5.4-py3-none-any.whl", hash = "sha256:860e31782b3d3a25ca0819ff039f5cf77845d1bf30c78ef9528b88b25e0a9850"}, + {file = "notebook-7.5.4.tar.gz", hash = "sha256:b928b2ba22cb63aa83df2e0e76fe3697950a0c1c4a41b84ebccf1972b1bb5771"}, ] [package.dependencies] jupyter-server = ">=2.4.0,<3" -jupyterlab = ">=4.5.3,<4.6" +jupyterlab = ">=4.5.5,<4.6" jupyterlab-server = ">=2.28.0,<3" notebook-shim = ">=0.2,<0.3" tornado = ">=6.2.0" @@ -3238,96 +3321,96 @@ test = ["pytest", "pytest-console-scripts", "pytest-jupyter", "pytest-tornasync" [[package]] name = "numpy" -version = "2.4.2" +version = "2.4.3" description = "Fundamental package for array computing in Python" optional = false python-versions = ">=3.11" groups = ["main", "dev"] files = [ - {file = "numpy-2.4.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e7e88598032542bd49af7c4747541422884219056c268823ef6e5e89851c8825"}, - {file = "numpy-2.4.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7edc794af8b36ca37ef5fcb5e0d128c7e0595c7b96a2318d1badb6fcd8ee86b1"}, - {file = "numpy-2.4.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:6e9f61981ace1360e42737e2bae58b27bf28a1b27e781721047d84bd754d32e7"}, - {file = "numpy-2.4.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:cb7bbb88aa74908950d979eeaa24dbdf1a865e3c7e45ff0121d8f70387b55f73"}, - {file = "numpy-2.4.2-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f069069931240b3fc703f1e23df63443dbd6390614c8c44a87d96cd0ec81eb1"}, - {file = "numpy-2.4.2-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c02ef4401a506fb60b411467ad501e1429a3487abca4664871d9ae0b46c8ba32"}, - {file = "numpy-2.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2653de5c24910e49c2b106499803124dde62a5a1fe0eedeaecf4309a5f639390"}, - {file = "numpy-2.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1ae241bbfc6ae276f94a170b14785e561cb5e7f626b6688cf076af4110887413"}, - {file = "numpy-2.4.2-cp311-cp311-win32.whl", hash = "sha256:df1b10187212b198dd45fa943d8985a3c8cf854aed4923796e0e019e113a1bda"}, - {file = "numpy-2.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:b9c618d56a29c9cb1c4da979e9899be7578d2e0b3c24d52079c166324c9e8695"}, - {file = "numpy-2.4.2-cp311-cp311-win_arm64.whl", hash = "sha256:47c5a6ed21d9452b10227e5e8a0e1c22979811cad7dcc19d8e3e2fb8fa03f1a3"}, - {file = "numpy-2.4.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:21982668592194c609de53ba4933a7471880ccbaadcc52352694a59ecc860b3a"}, - {file = "numpy-2.4.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40397bda92382fcec844066efb11f13e1c9a3e2a8e8f318fb72ed8b6db9f60f1"}, - {file = "numpy-2.4.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:b3a24467af63c67829bfaa61eecf18d5432d4f11992688537be59ecd6ad32f5e"}, - {file = "numpy-2.4.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:805cc8de9fd6e7a22da5aed858e0ab16be5a4db6c873dde1d7451c541553aa27"}, - {file = "numpy-2.4.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d82351358ffbcdcd7b686b90742a9b86632d6c1c051016484fa0b326a0a1548"}, - {file = "numpy-2.4.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e35d3e0144137d9fdae62912e869136164534d64a169f86438bc9561b6ad49f"}, - {file = "numpy-2.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:adb6ed2ad29b9e15321d167d152ee909ec73395901b70936f029c3bc6d7f4460"}, - {file = "numpy-2.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8906e71fd8afcb76580404e2a950caef2685df3d2a57fe82a86ac8d33cc007ba"}, - {file = "numpy-2.4.2-cp312-cp312-win32.whl", hash = "sha256:ec055f6dae239a6299cace477b479cca2fc125c5675482daf1dd886933a1076f"}, - {file = "numpy-2.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:209fae046e62d0ce6435fcfe3b1a10537e858249b3d9b05829e2a05218296a85"}, - {file = "numpy-2.4.2-cp312-cp312-win_arm64.whl", hash = "sha256:fbde1b0c6e81d56f5dccd95dd4a711d9b95df1ae4009a60887e56b27e8d903fa"}, - {file = "numpy-2.4.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:25f2059807faea4b077a2b6837391b5d830864b3543627f381821c646f31a63c"}, - {file = "numpy-2.4.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bd3a7a9f5847d2fb8c2c6d1c862fa109c31a9abeca1a3c2bd5a64572955b2979"}, - {file = "numpy-2.4.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:8e4549f8a3c6d13d55041925e912bfd834285ef1dd64d6bc7d542583355e2e98"}, - {file = "numpy-2.4.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:aea4f66ff44dfddf8c2cffd66ba6538c5ec67d389285292fe428cb2c738c8aef"}, - {file = "numpy-2.4.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3cd545784805de05aafe1dde61752ea49a359ccba9760c1e5d1c88a93bbf2b7"}, - {file = "numpy-2.4.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d0d9b7c93578baafcbc5f0b83eaf17b79d345c6f36917ba0c67f45226911d499"}, - {file = "numpy-2.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f74f0f7779cc7ae07d1810aab8ac6b1464c3eafb9e283a40da7309d5e6e48fbb"}, - {file = "numpy-2.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c7ac672d699bf36275c035e16b65539931347d68b70667d28984c9fb34e07fa7"}, - {file = "numpy-2.4.2-cp313-cp313-win32.whl", hash = "sha256:8e9afaeb0beff068b4d9cd20d322ba0ee1cecfb0b08db145e4ab4dd44a6b5110"}, - {file = "numpy-2.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:7df2de1e4fba69a51c06c28f5a3de36731eb9639feb8e1cf7e4a7b0daf4cf622"}, - {file = "numpy-2.4.2-cp313-cp313-win_arm64.whl", hash = "sha256:0fece1d1f0a89c16b03442eae5c56dc0be0c7883b5d388e0c03f53019a4bfd71"}, - {file = "numpy-2.4.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5633c0da313330fd20c484c78cdd3f9b175b55e1a766c4a174230c6b70ad8262"}, - {file = "numpy-2.4.2-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d9f64d786b3b1dd742c946c42d15b07497ed14af1a1f3ce840cce27daa0ce913"}, - {file = "numpy-2.4.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:b21041e8cb6a1eb5312dd1d2f80a94d91efffb7a06b70597d44f1bd2dfc315ab"}, - {file = "numpy-2.4.2-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:00ab83c56211a1d7c07c25e3217ea6695e50a3e2f255053686b081dc0b091a82"}, - {file = "numpy-2.4.2-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fb882da679409066b4603579619341c6d6898fc83a8995199d5249f986e8e8f"}, - {file = "numpy-2.4.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:66cb9422236317f9d44b67b4d18f44efe6e9c7f8794ac0462978513359461554"}, - {file = "numpy-2.4.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0f01dcf33e73d80bd8dc0f20a71303abbafa26a19e23f6b68d1aa9990af90257"}, - {file = "numpy-2.4.2-cp313-cp313t-win32.whl", hash = "sha256:52b913ec40ff7ae845687b0b34d8d93b60cb66dcee06996dd5c99f2fc9328657"}, - {file = "numpy-2.4.2-cp313-cp313t-win_amd64.whl", hash = "sha256:5eea80d908b2c1f91486eb95b3fb6fab187e569ec9752ab7d9333d2e66bf2d6b"}, - {file = "numpy-2.4.2-cp313-cp313t-win_arm64.whl", hash = "sha256:fd49860271d52127d61197bb50b64f58454e9f578cb4b2c001a6de8b1f50b0b1"}, - {file = "numpy-2.4.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:444be170853f1f9d528428eceb55f12918e4fda5d8805480f36a002f1415e09b"}, - {file = "numpy-2.4.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d1240d50adff70c2a88217698ca844723068533f3f5c5fa6ee2e3220e3bdb000"}, - {file = "numpy-2.4.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:7cdde6de52fb6664b00b056341265441192d1291c130e99183ec0d4b110ff8b1"}, - {file = "numpy-2.4.2-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:cda077c2e5b780200b6b3e09d0b42205a3d1c68f30c6dceb90401c13bff8fe74"}, - {file = "numpy-2.4.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d30291931c915b2ab5717c2974bb95ee891a1cf22ebc16a8006bd59cd210d40a"}, - {file = "numpy-2.4.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bba37bc29d4d85761deed3954a1bc62be7cf462b9510b51d367b769a8c8df325"}, - {file = "numpy-2.4.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b2f0073ed0868db1dcd86e052d37279eef185b9c8db5bf61f30f46adac63c909"}, - {file = "numpy-2.4.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7f54844851cdb630ceb623dcec4db3240d1ac13d4990532446761baede94996a"}, - {file = "numpy-2.4.2-cp314-cp314-win32.whl", hash = "sha256:12e26134a0331d8dbd9351620f037ec470b7c75929cb8a1537f6bfe411152a1a"}, - {file = "numpy-2.4.2-cp314-cp314-win_amd64.whl", hash = "sha256:068cdb2d0d644cdb45670810894f6a0600797a69c05f1ac478e8d31670b8ee75"}, - {file = "numpy-2.4.2-cp314-cp314-win_arm64.whl", hash = "sha256:6ed0be1ee58eef41231a5c943d7d1375f093142702d5723ca2eb07db9b934b05"}, - {file = "numpy-2.4.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:98f16a80e917003a12c0580f97b5f875853ebc33e2eaa4bccfc8201ac6869308"}, - {file = "numpy-2.4.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:20abd069b9cda45874498b245c8015b18ace6de8546bf50dfa8cea1696ed06ef"}, - {file = "numpy-2.4.2-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:e98c97502435b53741540a5717a6749ac2ada901056c7db951d33e11c885cc7d"}, - {file = "numpy-2.4.2-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:da6cad4e82cb893db4b69105c604d805e0c3ce11501a55b5e9f9083b47d2ffe8"}, - {file = "numpy-2.4.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e4424677ce4b47fe73c8b5556d876571f7c6945d264201180db2dc34f676ab5"}, - {file = "numpy-2.4.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2b8f157c8a6f20eb657e240f8985cc135598b2b46985c5bccbde7616dc9c6b1e"}, - {file = "numpy-2.4.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5daf6f3914a733336dab21a05cdec343144600e964d2fcdabaac0c0269874b2a"}, - {file = "numpy-2.4.2-cp314-cp314t-win32.whl", hash = "sha256:8c50dd1fc8826f5b26a5ee4d77ca55d88a895f4e4819c7ecc2a9f5905047a443"}, - {file = "numpy-2.4.2-cp314-cp314t-win_amd64.whl", hash = "sha256:fcf92bee92742edd401ba41135185866f7026c502617f422eb432cfeca4fe236"}, - {file = "numpy-2.4.2-cp314-cp314t-win_arm64.whl", hash = "sha256:1f92f53998a17265194018d1cc321b2e96e900ca52d54c7c77837b71b9465181"}, - {file = "numpy-2.4.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:89f7268c009bc492f506abd6f5265defa7cb3f7487dc21d357c3d290add45082"}, - {file = "numpy-2.4.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:e6dee3bb76aa4009d5a912180bf5b2de012532998d094acee25d9cb8dee3e44a"}, - {file = "numpy-2.4.2-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:cd2bd2bbed13e213d6b55dc1d035a4f91748a7d3edc9480c13898b0353708920"}, - {file = "numpy-2.4.2-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:cf28c0c1d4c4bf00f509fa7eb02c58d7caf221b50b467bcb0d9bbf1584d5c821"}, - {file = "numpy-2.4.2-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e04ae107ac591763a47398bb45b568fc38f02dbc4aa44c063f67a131f99346cb"}, - {file = "numpy-2.4.2-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:602f65afdef699cda27ec0b9224ae5dc43e328f4c24c689deaf77133dbee74d0"}, - {file = "numpy-2.4.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:be71bf1edb48ebbbf7f6337b5bfd2f895d1902f6335a5830b20141fc126ffba0"}, - {file = "numpy-2.4.2.tar.gz", hash = "sha256:659a6107e31a83c4e33f763942275fd278b21d095094044eb35569e86a21ddae"}, + {file = "numpy-2.4.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:33b3bf58ee84b172c067f56aeadc7ee9ab6de69c5e800ab5b10295d54c581adb"}, + {file = "numpy-2.4.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8ba7b51e71c05aa1f9bc3641463cd82308eab40ce0d5c7e1fd4038cbf9938147"}, + {file = "numpy-2.4.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:a1988292870c7cb9d0ebb4cc96b4d447513a9644801de54606dc7aabf2b7d920"}, + {file = "numpy-2.4.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:23b46bb6d8ecb68b58c09944483c135ae5f0e9b8d8858ece5e4ead783771d2a9"}, + {file = "numpy-2.4.3-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a016db5c5dba78fa8fe9f5d80d6708f9c42ab087a739803c0ac83a43d686a470"}, + {file = "numpy-2.4.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:715de7f82e192e8cae5a507a347d97ad17598f8e026152ca97233e3666daaa71"}, + {file = "numpy-2.4.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2ddb7919366ee468342b91dea2352824c25b55814a987847b6c52003a7c97f15"}, + {file = "numpy-2.4.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a315e5234d88067f2d97e1f2ef670a7569df445d55400f1e33d117418d008d52"}, + {file = "numpy-2.4.3-cp311-cp311-win32.whl", hash = "sha256:2b3f8d2c4589b1a2028d2a770b0fc4d1f332fb5e01521f4de3199a896d158ddd"}, + {file = "numpy-2.4.3-cp311-cp311-win_amd64.whl", hash = "sha256:77e76d932c49a75617c6d13464e41203cd410956614d0a0e999b25e9e8d27eec"}, + {file = "numpy-2.4.3-cp311-cp311-win_arm64.whl", hash = "sha256:eb610595dd91560905c132c709412b512135a60f1851ccbd2c959e136431ff67"}, + {file = "numpy-2.4.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:61b0cbabbb6126c8df63b9a3a0c4b1f44ebca5e12ff6997b80fcf267fb3150ef"}, + {file = "numpy-2.4.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7395e69ff32526710748f92cd8c9849b361830968ea3e24a676f272653e8983e"}, + {file = "numpy-2.4.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:abdce0f71dcb4a00e4e77f3faf05e4616ceccfe72ccaa07f47ee79cda3b7b0f4"}, + {file = "numpy-2.4.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:48da3a4ee1336454b07497ff7ec83903efa5505792c4e6d9bf83d99dc07a1e18"}, + {file = "numpy-2.4.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:32e3bef222ad6b052280311d1d60db8e259e4947052c3ae7dd6817451fc8a4c5"}, + {file = "numpy-2.4.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e7dd01a46700b1967487141a66ac1a3cf0dd8ebf1f08db37d46389401512ca97"}, + {file = "numpy-2.4.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:76f0f283506c28b12bba319c0fab98217e9f9b54e6160e9c79e9f7348ba32e9c"}, + {file = "numpy-2.4.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:737f630a337364665aba3b5a77e56a68cc42d350edd010c345d65a3efa3addcc"}, + {file = "numpy-2.4.3-cp312-cp312-win32.whl", hash = "sha256:26952e18d82a1dbbc2f008d402021baa8d6fc8e84347a2072a25e08b46d698b9"}, + {file = "numpy-2.4.3-cp312-cp312-win_amd64.whl", hash = "sha256:65f3c2455188f09678355f5cae1f959a06b778bc66d535da07bf2ef20cd319d5"}, + {file = "numpy-2.4.3-cp312-cp312-win_arm64.whl", hash = "sha256:2abad5c7fef172b3377502bde47892439bae394a71bc329f31df0fd829b41a9e"}, + {file = "numpy-2.4.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b346845443716c8e542d54112966383b448f4a3ba5c66409771b8c0889485dd3"}, + {file = "numpy-2.4.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2629289168f4897a3c4e23dc98d6f1731f0fc0fe52fb9db19f974041e4cc12b9"}, + {file = "numpy-2.4.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:bb2e3cf95854233799013779216c57e153c1ee67a0bf92138acca0e429aefaee"}, + {file = "numpy-2.4.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:7f3408ff897f8ab07a07fbe2823d7aee6ff644c097cc1f90382511fe982f647f"}, + {file = "numpy-2.4.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:decb0eb8a53c3b009b0962378065589685d66b23467ef5dac16cbe818afde27f"}, + {file = "numpy-2.4.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5f51900414fc9204a0e0da158ba2ac52b75656e7dce7e77fb9f84bfa343b4cc"}, + {file = "numpy-2.4.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6bd06731541f89cdc01b261ba2c9e037f1543df7472517836b78dfb15bd6e476"}, + {file = "numpy-2.4.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:22654fe6be0e5206f553a9250762c653d3698e46686eee53b399ab90da59bd92"}, + {file = "numpy-2.4.3-cp313-cp313-win32.whl", hash = "sha256:d71e379452a2f670ccb689ec801b1218cd3983e253105d6e83780967e899d687"}, + {file = "numpy-2.4.3-cp313-cp313-win_amd64.whl", hash = "sha256:0a60e17a14d640f49146cb38e3f105f571318db7826d9b6fef7e4dce758faecd"}, + {file = "numpy-2.4.3-cp313-cp313-win_arm64.whl", hash = "sha256:c9619741e9da2059cd9c3f206110b97583c7152c1dc9f8aafd4beb450ac1c89d"}, + {file = "numpy-2.4.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:7aa4e54f6469300ebca1d9eb80acd5253cdfa36f2c03d79a35883687da430875"}, + {file = "numpy-2.4.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:d1b90d840b25874cf5cd20c219af10bac3667db3876d9a495609273ebe679070"}, + {file = "numpy-2.4.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:a749547700de0a20a6718293396ec237bb38218049cfce788e08fcb716e8cf73"}, + {file = "numpy-2.4.3-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94f3c4a151a2e529adf49c1d54f0f57ff8f9b233ee4d44af623a81553ab86368"}, + {file = "numpy-2.4.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22c31dc07025123aedf7f2db9e91783df13f1776dc52c6b22c620870dc0fab22"}, + {file = "numpy-2.4.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:148d59127ac95979d6f07e4d460f934ebdd6eed641db9c0db6c73026f2b2101a"}, + {file = "numpy-2.4.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a97cbf7e905c435865c2d939af3d93f99d18eaaa3cabe4256f4304fb51604349"}, + {file = "numpy-2.4.3-cp313-cp313t-win32.whl", hash = "sha256:be3b8487d725a77acccc9924f65fd8bce9af7fac8c9820df1049424a2115af6c"}, + {file = "numpy-2.4.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1ec84fd7c8e652b0f4aaaf2e6e9cc8eaa9b1b80a537e06b2e3a2fb176eedcb26"}, + {file = "numpy-2.4.3-cp313-cp313t-win_arm64.whl", hash = "sha256:120df8c0a81ebbf5b9020c91439fccd85f5e018a927a39f624845be194a2be02"}, + {file = "numpy-2.4.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:5884ce5c7acfae1e4e1b6fde43797d10aa506074d25b531b4f54bde33c0c31d4"}, + {file = "numpy-2.4.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:297837823f5bc572c5f9379b0c9f3a3365f08492cbdc33bcc3af174372ebb168"}, + {file = "numpy-2.4.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:a111698b4a3f8dcbe54c64a7708f049355abd603e619013c346553c1fd4ca90b"}, + {file = "numpy-2.4.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:4bd4741a6a676770e0e97fe9ab2e51de01183df3dcbcec591d26d331a40de950"}, + {file = "numpy-2.4.3-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:54f29b877279d51e210e0c80709ee14ccbbad647810e8f3d375561c45ef613dd"}, + {file = "numpy-2.4.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:679f2a834bae9020f81534671c56fd0cc76dd7e5182f57131478e23d0dc59e24"}, + {file = "numpy-2.4.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d84f0f881cb2225c2dfd7f78a10a5645d487a496c6668d6cc39f0f114164f3d0"}, + {file = "numpy-2.4.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d213c7e6e8d211888cc359bab7199670a00f5b82c0978b9d1c75baf1eddbeac0"}, + {file = "numpy-2.4.3-cp314-cp314-win32.whl", hash = "sha256:52077feedeff7c76ed7c9f1a0428558e50825347b7545bbb8523da2cd55c547a"}, + {file = "numpy-2.4.3-cp314-cp314-win_amd64.whl", hash = "sha256:0448e7f9caefb34b4b7dd2b77f21e8906e5d6f0365ad525f9f4f530b13df2afc"}, + {file = "numpy-2.4.3-cp314-cp314-win_arm64.whl", hash = "sha256:b44fd60341c4d9783039598efadd03617fa28d041fc37d22b62d08f2027fa0e7"}, + {file = "numpy-2.4.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0a195f4216be9305a73c0e91c9b026a35f2161237cf1c6de9b681637772ea657"}, + {file = "numpy-2.4.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:cd32fbacb9fd1bf041bf8e89e4576b6f00b895f06d00914820ae06a616bdfef7"}, + {file = "numpy-2.4.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:2e03c05abaee1f672e9d67bc858f300b5ccba1c21397211e8d77d98350972093"}, + {file = "numpy-2.4.3-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7d1ce23cce91fcea443320a9d0ece9b9305d4368875bab09538f7a5b4131938a"}, + {file = "numpy-2.4.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c59020932feb24ed49ffd03704fbab89f22aa9c0d4b180ff45542fe8918f5611"}, + {file = "numpy-2.4.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9684823a78a6cd6ad7511fc5e25b07947d1d5b5e2812c93fe99d7d4195130720"}, + {file = "numpy-2.4.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0200b25c687033316fb39f0ff4e3e690e8957a2c3c8d22499891ec58c37a3eb5"}, + {file = "numpy-2.4.3-cp314-cp314t-win32.whl", hash = "sha256:5e10da9e93247e554bb1d22f8edc51847ddd7dde52d85ce31024c1b4312bfba0"}, + {file = "numpy-2.4.3-cp314-cp314t-win_amd64.whl", hash = "sha256:45f003dbdffb997a03da2d1d0cb41fbd24a87507fb41605c0420a3db5bd4667b"}, + {file = "numpy-2.4.3-cp314-cp314t-win_arm64.whl", hash = "sha256:4d382735cecd7bcf090172489a525cd7d4087bc331f7df9f60ddc9a296cf208e"}, + {file = "numpy-2.4.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c6b124bfcafb9e8d3ed09130dbee44848c20b3e758b6bbf006e641778927c028"}, + {file = "numpy-2.4.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:76dbb9d4e43c16cf9aa711fcd8de1e2eeb27539dcefb60a1d5e9f12fae1d1ed8"}, + {file = "numpy-2.4.3-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:29363fbfa6f8ee855d7569c96ce524845e3d726d6c19b29eceec7dd555dab152"}, + {file = "numpy-2.4.3-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:bc71942c789ef415a37f0d4eab90341425a00d538cd0642445d30b41023d3395"}, + {file = "numpy-2.4.3-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e58765ad74dcebd3ef0208a5078fba32dc8ec3578fe84a604432950cd043d79"}, + {file = "numpy-2.4.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e236dbda4e1d319d681afcbb136c0c4a8e0f1a5c58ceec2adebb547357fe857"}, + {file = "numpy-2.4.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:4b42639cdde6d24e732ff823a3fa5b701d8acad89c4142bc1d0bd6dc85200ba5"}, + {file = "numpy-2.4.3.tar.gz", hash = "sha256:483a201202b73495f00dbc83796c6ae63137a9bdade074f7648b3e32613412dd"}, ] [[package]] name = "openai" -version = "2.21.0" +version = "2.26.0" description = "The official Python library for the openai API" optional = false python-versions = ">=3.9" groups = ["main"] files = [ - {file = "openai-2.21.0-py3-none-any.whl", hash = "sha256:0bc1c775e5b1536c294eded39ee08f8407656537ccc71b1004104fe1602e267c"}, - {file = "openai-2.21.0.tar.gz", hash = "sha256:81b48ce4b8bbb2cc3af02047ceb19561f7b1dc0d4e52d1de7f02abfd15aa59b7"}, + {file = "openai-2.26.0-py3-none-any.whl", hash = "sha256:6151bf8f83802f036117f06cc8a57b3a4da60da9926826cc96747888b57f394f"}, + {file = "openai-2.26.0.tar.gz", hash = "sha256:b41f37c140ae0034a6e92b0c509376d907f3a66109935fba2c1b471a7c05a8fb"}, ] [package.dependencies] @@ -3858,26 +3941,26 @@ xmp = ["defusedxml"] [[package]] name = "platformdirs" -version = "4.9.2" +version = "4.9.4" description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." optional = false python-versions = ">=3.10" -groups = ["dev"] +groups = ["main", "dev"] files = [ - {file = "platformdirs-4.9.2-py3-none-any.whl", hash = "sha256:9170634f126f8efdae22fb58ae8a0eaa86f38365bc57897a6c4f781d1f5875bd"}, - {file = "platformdirs-4.9.2.tar.gz", hash = "sha256:9a33809944b9db043ad67ca0db94b14bf452cc6aeaac46a88ea55b26e2e9d291"}, + {file = "platformdirs-4.9.4-py3-none-any.whl", hash = "sha256:68a9a4619a666ea6439f2ff250c12a853cd1cbd5158d258bd824a7df6be2f868"}, + {file = "platformdirs-4.9.4.tar.gz", hash = "sha256:1ec356301b7dc906d83f371c8f487070e99d3ccf9e501686456394622a01a934"}, ] [[package]] name = "plotly" -version = "6.5.2" +version = "6.6.0" description = "An open-source interactive data visualization library for Python" optional = false python-versions = ">=3.8" groups = ["main"] files = [ - {file = "plotly-6.5.2-py3-none-any.whl", hash = "sha256:91757653bd9c550eeea2fa2404dba6b85d1e366d54804c340b2c874e5a7eb4a4"}, - {file = "plotly-6.5.2.tar.gz", hash = "sha256:7478555be0198562d1435dee4c308268187553cc15516a2f4dd034453699e393"}, + {file = "plotly-6.6.0-py3-none-any.whl", hash = "sha256:8d6daf0f87412e0c0bfe72e809d615217ab57cc715899a1e5145135a7800d1d0"}, + {file = "plotly-6.6.0.tar.gz", hash = "sha256:b897f15f3b02028d69f755f236be890ba950d0a42d7dfc619b44e2d8cea8748c"}, ] [package.dependencies] @@ -4695,16 +4778,36 @@ files = [ [package.dependencies] six = ">=1.5" +[[package]] +name = "python-discovery" +version = "1.1.2" +description = "Python interpreter discovery" +optional = false +python-versions = ">=3.8" +groups = ["dev"] +files = [ + {file = "python_discovery-1.1.2-py3-none-any.whl", hash = "sha256:d18edd61b382d62f8bcd004a71ebaabc87df31dbefb30aeed59f4fc6afa005be"}, + {file = "python_discovery-1.1.2.tar.gz", hash = "sha256:c500bd2153e3afc5f48a61d33ff570b6f3e710d36ceaaf882fa9bbe5cc2cec49"}, +] + +[package.dependencies] +filelock = ">=3.15.4" +platformdirs = ">=4.3.6,<5" + +[package.extras] +docs = ["furo (>=2025.12.19)", "sphinx (>=9.1)", "sphinx-autodoc-typehints (>=3.6.3)", "sphinxcontrib-mermaid (>=2)"] +testing = ["covdefaults (>=2.3)", "coverage (>=7.5.4)", "pytest (>=8.3.5)", "pytest-mock (>=3.14)", "setuptools (>=75.1)"] + [[package]] name = "python-dotenv" -version = "1.2.1" +version = "1.2.2" description = "Read key-value pairs from a .env file and set them as environment variables" optional = false -python-versions = ">=3.9" +python-versions = ">=3.10" groups = ["main"] files = [ - {file = "python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61"}, - {file = "python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6"}, + {file = "python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a"}, + {file = "python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3"}, ] [package.extras] @@ -4757,14 +4860,14 @@ unidecode = ["Unidecode (>=1.1.1)"] [[package]] name = "pytz" -version = "2025.2" +version = "2026.1.post1" description = "World timezone definitions, modern and historical" optional = false python-versions = "*" groups = ["main", "dev"] files = [ - {file = "pytz-2025.2-py2.py3-none-any.whl", hash = "sha256:5ddf76296dd8c44c26eb8f4b6f35488f3ccbf6fbbd7adee0b7262d43f0ec2f00"}, - {file = "pytz-2025.2.tar.gz", hash = "sha256:360b9e3dbb49a209c21ad61809c7fb453643e048b38924c765813546746e81c3"}, + {file = "pytz-2026.1.post1-py2.py3-none-any.whl", hash = "sha256:f2fd16142fda348286a75e1a524be810bb05d444e5a081f37f7affc635035f7a"}, + {file = "pytz-2026.1.post1.tar.gz", hash = "sha256:3378dde6a0c3d26719182142c56e60c7f9af7e968076f31aae569d72a0358ee1"}, ] [[package]] @@ -5525,19 +5628,19 @@ test = ["pytest (>=8)"] [[package]] name = "setuptools" -version = "82.0.0" -description = "Easily download, build, install, upgrade, and uninstall Python packages" +version = "82.0.1" +description = "Most extensible Python build backend with support for C/C++ extension modules" optional = false python-versions = ">=3.9" groups = ["dev"] files = [ - {file = "setuptools-82.0.0-py3-none-any.whl", hash = "sha256:70b18734b607bd1da571d097d236cfcfacaf01de45717d59e6e04b96877532e0"}, - {file = "setuptools-82.0.0.tar.gz", hash = "sha256:22e0a2d69474c6ae4feb01951cb69d515ed23728cf96d05513d36e42b62b37cb"}, + {file = "setuptools-82.0.1-py3-none-any.whl", hash = "sha256:a59e362652f08dcd477c78bb6e7bd9d80a7995bc73ce773050228a348ce2e5bb"}, + {file = "setuptools-82.0.1.tar.gz", hash = "sha256:7d872682c5d01cfde07da7bccc7b65469d3dca203318515ada1de5eda35efbf9"}, ] [package.extras] check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\"", "ruff (>=0.13.0) ; sys_platform != \"cygwin\""] -core = ["importlib_metadata (>=6) ; python_version < \"3.10\"", "jaraco.functools (>=4)", "jaraco.text (>=3.7)", "more_itertools", "more_itertools (>=8.8)", "packaging (>=24.2)", "platformdirs (>=4.2.2)", "tomli (>=2.0.1) ; python_version < \"3.11\"", "wheel (>=0.43.0)"] +core = ["importlib_metadata (>=6) ; python_version < \"3.10\"", "jaraco.functools (>=4)", "jaraco.text (>=3.7)", "more_itertools", "more_itertools (>=8.8)", "packaging (>=24.2)", "tomli (>=2.0.1) ; python_version < \"3.11\"", "wheel (>=0.43.0)"] cover = ["pytest-cov"] doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "pyproject-hooks (!=1.1)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier", "towncrier (<24.7)"] enabler = ["pytest-enabler (>=2.2)"] @@ -5570,14 +5673,14 @@ files = [ [[package]] name = "smmap" -version = "5.0.2" +version = "5.0.3" description = "A pure Python implementation of a sliding window memory map manager" optional = false python-versions = ">=3.7" groups = ["main"] files = [ - {file = "smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e"}, - {file = "smmap-5.0.2.tar.gz", hash = "sha256:26ea65a03958fa0c8a1c7e8c7a58fdc77221b8910f6be2131affade476898ad5"}, + {file = "smmap-5.0.3-py3-none-any.whl", hash = "sha256:c106e05d5a61449cf6ba9a1e650227ecfb141590d2a98412103ff35d89fc7b2f"}, + {file = "smmap-5.0.3.tar.gz", hash = "sha256:4d9debb8b99007ae47165abc08670bd74cb74b5227dda7f643eccc4e9eb5642c"}, ] [[package]] @@ -5606,14 +5709,14 @@ files = [ [[package]] name = "sse-starlette" -version = "3.2.0" +version = "3.3.2" description = "SSE plugin for Starlette" optional = false -python-versions = ">=3.9" +python-versions = ">=3.10" groups = ["main"] files = [ - {file = "sse_starlette-3.2.0-py3-none-any.whl", hash = "sha256:5876954bd51920fc2cd51baee47a080eb88a37b5b784e615abb0b283f801cdbf"}, - {file = "sse_starlette-3.2.0.tar.gz", hash = "sha256:8127594edfb51abe44eac9c49e59b0b01f1039d0c7461c6fd91d4e03b70da422"}, + {file = "sse_starlette-3.3.2-py3-none-any.whl", hash = "sha256:5c3ea3dad425c601236726af2f27689b74494643f57017cafcb6f8c9acfbb862"}, + {file = "sse_starlette-3.3.2.tar.gz", hash = "sha256:678fca55a1945c734d8472a6cad186a55ab02840b4f6786f5ee8770970579dcd"}, ] [package.dependencies] @@ -5667,20 +5770,20 @@ full = ["httpx (>=0.27.0,<0.29.0)", "itsdangerous", "jinja2", "python-multipart [[package]] name = "streamlit" -version = "1.54.0" +version = "1.55.0" description = "A faster way to build and share data apps" optional = false python-versions = ">=3.10" groups = ["main"] files = [ - {file = "streamlit-1.54.0-py3-none-any.whl", hash = "sha256:a7b67d6293a9f5f6b4d4c7acdbc4980d7d9f049e78e404125022ecb1712f79fc"}, - {file = "streamlit-1.54.0.tar.gz", hash = "sha256:09965e6ae7eb0357091725de1ce2a3f7e4be155c2464c505c40a3da77ab69dd8"}, + {file = "streamlit-1.55.0-py3-none-any.whl", hash = "sha256:1e4a16449c6131696180f4ddb40ea8c51834e89c2a43e1b0362bc9b1cfd9b415"}, + {file = "streamlit-1.55.0.tar.gz", hash = "sha256:015e512bbd02d000f4047e51118dc086b70e7d9c46b4a11a33c2509731379626"}, ] [package.dependencies] altair = ">=4.0,<5.4.0 || >5.4.0,<5.4.1 || >5.4.1,<7" blinker = ">=1.5.0,<2" -cachetools = ">=5.5,<7" +cachetools = ">=5.5,<8" click = ">=7.0,<9" gitpython = ">=3.0.7,<3.1.19 || >3.1.19,<4" numpy = ">=1.23,<3" @@ -5807,6 +5910,27 @@ files = [ {file = "text_unidecode-1.3-py2.py3-none-any.whl", hash = "sha256:1311f10e8b895935241623731c2ba64f4c455287888b18189350b67134a822e8"}, ] +[[package]] +name = "textual" +version = "3.7.1" +description = "Modern Text User Interface framework" +optional = false +python-versions = "<4.0.0,>=3.8.1" +groups = ["main"] +files = [ + {file = "textual-3.7.1-py3-none-any.whl", hash = "sha256:ab5d153f4f65e77017977fa150d0376409e0acf5f1d2e25e2e4ab9de6c0d61ff"}, + {file = "textual-3.7.1.tar.gz", hash = "sha256:a76ba0c8a6c194ef24fd5c3681ebfddca55e7127c064a014128c84fbd7f5d271"}, +] + +[package.dependencies] +markdown-it-py = {version = ">=2.1.0", extras = ["linkify", "plugins"]} +platformdirs = ">=3.6.0,<5" +rich = ">=13.3.3" +typing-extensions = ">=4.4.0,<5.0.0" + +[package.extras] +syntax = ["tree-sitter (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-bash (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-css (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-go (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-html (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-java (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-javascript (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-json (>=0.24.0) ; python_version >= \"3.9\"", "tree-sitter-markdown (>=0.3.0) ; python_version >= \"3.9\"", "tree-sitter-python (>=0.23.0) ; python_version >= \"3.9\"", "tree-sitter-regex (>=0.24.0) ; python_version >= \"3.9\"", "tree-sitter-rust (>=0.23.0,<=0.23.2) ; python_version >= \"3.9\"", "tree-sitter-sql (>=0.3.0,<0.3.8) ; python_version >= \"3.9\"", "tree-sitter-toml (>=0.6.0) ; python_version >= \"3.9\"", "tree-sitter-xml (>=0.7.0) ; python_version >= \"3.9\"", "tree-sitter-yaml (>=0.6.0) ; python_version >= \"3.9\""] + [[package]] name = "threadpoolctl" version = "3.6.0" @@ -6058,6 +6182,18 @@ files = [ {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"}, ] +[[package]] +name = "tomli-w" +version = "1.2.0" +description = "A lil' TOML writer" +optional = false +python-versions = ">=3.9" +groups = ["dev"] +files = [ + {file = "tomli_w-1.2.0-py3-none-any.whl", hash = "sha256:188306098d013b691fcadc011abd66727d3c414c571bb01b1a174ba8c983cf90"}, + {file = "tomli_w-1.2.0.tar.gz", hash = "sha256:2dd14fac5a47c27be9cd4c976af5a12d87fb1f0b4512f81d69cce3b35ae25021"}, +] + [[package]] name = "tornado" version = "6.5.4" @@ -6082,26 +6218,29 @@ files = [ [[package]] name = "tox" -version = "4.35.0" +version = "4.49.1" description = "tox is a generic virtualenv management and test command line tool" optional = false python-versions = ">=3.10" groups = ["dev"] files = [ - {file = "tox-4.35.0-py3-none-any.whl", hash = "sha256:282aa2e1f96328ad197ee09878ff241610426cd8ec01e62a04eb51c987da922d"}, - {file = "tox-4.35.0.tar.gz", hash = "sha256:74d2fe33eb37233d506f854196bd7bd7e2fbb79e8d9b4bed214ab3da98740876"}, + {file = "tox-4.49.1-py3-none-any.whl", hash = "sha256:6dd2d7d4e4fd5895ce4ea20e258fce0d4b81e914b697d116a5ab0365f8303bad"}, + {file = "tox-4.49.1.tar.gz", hash = "sha256:4130d02e1d53648d7107d121ed79f69a27b717817c5e9da521d50319dd261212"}, ] [package.dependencies] -cachetools = ">=6.2.5" -chardet = ">=5.2" +cachetools = ">=7.0.3" colorama = ">=0.4.6" -filelock = ">=3.20.3" +filelock = ">=3.25" packaging = ">=26" -platformdirs = ">=4.5.1" +platformdirs = ">=4.9.4" pluggy = ">=1.6" pyproject-api = ">=1.10" -virtualenv = ">=20.36.1" +tomli-w = ">=1.2" +virtualenv = ">=21.1" + +[package.extras] +completion = ["argcomplete (>=3.6.3)"] [[package]] name = "tqdm" @@ -6196,21 +6335,6 @@ click = ">=8.2.1" rich = ">=12.3.0" shellingham = ">=1.3.0" -[[package]] -name = "typer-slim" -version = "0.24.0" -description = "Typer, build great CLIs. Easy to code. Based on Python type hints." -optional = false -python-versions = ">=3.10" -groups = ["main"] -files = [ - {file = "typer_slim-0.24.0-py3-none-any.whl", hash = "sha256:d5d7ee1ee2834d5020c7c616ed5e0d0f29b9a4b1dd283bdebae198ec09778d0e"}, - {file = "typer_slim-0.24.0.tar.gz", hash = "sha256:f0ed36127183f52ae6ced2ecb2521789995992c521a46083bfcdbb652d22ad34"}, -] - -[package.dependencies] -typer = ">=0.24.0" - [[package]] name = "types-requests" version = "2.32.4.20260107" @@ -6265,6 +6389,21 @@ files = [ {file = "tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7"}, ] +[[package]] +name = "uc-micro-py" +version = "2.0.0" +description = "Micro subset of unicode data files for linkify-it-py projects." +optional = false +python-versions = ">=3.10" +groups = ["main"] +files = [ + {file = "uc_micro_py-2.0.0-py3-none-any.whl", hash = "sha256:3603a3859af53e5a39bc7677713c78ea6589ff188d70f4fee165db88e22b242c"}, + {file = "uc_micro_py-2.0.0.tar.gz", hash = "sha256:c53691e495c8db60e16ffc4861a35469b0ba0821fe409a8a7a0a71864d33a811"}, +] + +[package.extras] +test = ["coverage", "pytest", "pytest-cov"] + [[package]] name = "unidecode" version = "1.4.0" @@ -6332,20 +6471,21 @@ standard = ["colorama (>=0.4) ; sys_platform == \"win32\"", "httptools (>=0.6.3) [[package]] name = "virtualenv" -version = "20.39.0" +version = "21.2.0" description = "Virtual Python Environment builder" optional = false python-versions = ">=3.8" groups = ["dev"] files = [ - {file = "virtualenv-20.39.0-py3-none-any.whl", hash = "sha256:44888bba3775990a152ea1f73f8e5f566d49f11bbd1de61d426fd7732770043e"}, - {file = "virtualenv-20.39.0.tar.gz", hash = "sha256:a15f0cebd00d50074fd336a169d53422436a12dfe15149efec7072cfe817df8b"}, + {file = "virtualenv-21.2.0-py3-none-any.whl", hash = "sha256:1bd755b504931164a5a496d217c014d098426cddc79363ad66ac78125f9d908f"}, + {file = "virtualenv-21.2.0.tar.gz", hash = "sha256:1720dc3a62ef5b443092e3f499228599045d7fea4c79199770499df8becf9098"}, ] [package.dependencies] distlib = ">=0.3.7,<1" filelock = {version = ">=3.24.2,<4", markers = "python_version >= \"3.10\""} platformdirs = ">=3.9.1,<5" +python-discovery = ">=1" [[package]] name = "watchdog" @@ -6446,142 +6586,140 @@ test = ["pytest", "websockets"] [[package]] name = "yarl" -version = "1.22.0" +version = "1.23.0" description = "Yet another URL library" optional = false -python-versions = ">=3.9" +python-versions = ">=3.10" groups = ["main"] files = [ - {file = "yarl-1.22.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c7bd6683587567e5a49ee6e336e0612bec8329be1b7d4c8af5687dcdeb67ee1e"}, - {file = "yarl-1.22.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5cdac20da754f3a723cceea5b3448e1a2074866406adeb4ef35b469d089adb8f"}, - {file = "yarl-1.22.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:07a524d84df0c10f41e3ee918846e1974aba4ec017f990dc735aad487a0bdfdf"}, - {file = "yarl-1.22.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1b329cb8146d7b736677a2440e422eadd775d1806a81db2d4cded80a48efc1a"}, - {file = "yarl-1.22.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:75976c6945d85dbb9ee6308cd7ff7b1fb9409380c82d6119bd778d8fcfe2931c"}, - {file = "yarl-1.22.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:80ddf7a5f8c86cb3eb4bc9028b07bbbf1f08a96c5c0bc1244be5e8fefcb94147"}, - {file = "yarl-1.22.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d332fc2e3c94dad927f2112395772a4e4fedbcf8f80efc21ed7cdfae4d574fdb"}, - {file = "yarl-1.22.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0cf71bf877efeac18b38d3930594c0948c82b64547c1cf420ba48722fe5509f6"}, - {file = "yarl-1.22.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:663e1cadaddae26be034a6ab6072449a8426ddb03d500f43daf952b74553bba0"}, - {file = "yarl-1.22.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:6dcbb0829c671f305be48a7227918cfcd11276c2d637a8033a99a02b67bf9eda"}, - {file = "yarl-1.22.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:f0d97c18dfd9a9af4490631905a3f131a8e4c9e80a39353919e2cfed8f00aedc"}, - {file = "yarl-1.22.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:437840083abe022c978470b942ff832c3940b2ad3734d424b7eaffcd07f76737"}, - {file = "yarl-1.22.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:a899cbd98dce6f5d8de1aad31cb712ec0a530abc0a86bd6edaa47c1090138467"}, - {file = "yarl-1.22.0-cp310-cp310-win32.whl", hash = "sha256:595697f68bd1f0c1c159fcb97b661fc9c3f5db46498043555d04805430e79bea"}, - {file = "yarl-1.22.0-cp310-cp310-win_amd64.whl", hash = "sha256:cb95a9b1adaa48e41815a55ae740cfda005758104049a640a398120bf02515ca"}, - {file = "yarl-1.22.0-cp310-cp310-win_arm64.whl", hash = "sha256:b85b982afde6df99ecc996990d4ad7ccbdbb70e2a4ba4de0aecde5922ba98a0b"}, - {file = "yarl-1.22.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ab72135b1f2db3fed3997d7e7dc1b80573c67138023852b6efb336a5eae6511"}, - {file = "yarl-1.22.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:669930400e375570189492dc8d8341301578e8493aec04aebc20d4717f899dd6"}, - {file = "yarl-1.22.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:792a2af6d58177ef7c19cbf0097aba92ca1b9cb3ffdd9c7470e156c8f9b5e028"}, - {file = "yarl-1.22.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ea66b1c11c9150f1372f69afb6b8116f2dd7286f38e14ea71a44eee9ec51b9d"}, - {file = "yarl-1.22.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3e2daa88dc91870215961e96a039ec73e4937da13cf77ce17f9cad0c18df3503"}, - {file = "yarl-1.22.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba440ae430c00eee41509353628600212112cd5018d5def7e9b05ea7ac34eb65"}, - {file = "yarl-1.22.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e6438cc8f23a9c1478633d216b16104a586b9761db62bfacb6425bac0a36679e"}, - {file = "yarl-1.22.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c52a6e78aef5cf47a98ef8e934755abf53953379b7d53e68b15ff4420e6683d"}, - {file = "yarl-1.22.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3b06bcadaac49c70f4c88af4ffcfbe3dc155aab3163e75777818092478bcbbe7"}, - {file = "yarl-1.22.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:6944b2dc72c4d7f7052683487e3677456050ff77fcf5e6204e98caf785ad1967"}, - {file = "yarl-1.22.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d5372ca1df0f91a86b047d1277c2aaf1edb32d78bbcefffc81b40ffd18f027ed"}, - {file = "yarl-1.22.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:51af598701f5299012b8416486b40fceef8c26fc87dc6d7d1f6fc30609ea0aa6"}, - {file = "yarl-1.22.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b266bd01fedeffeeac01a79ae181719ff848a5a13ce10075adbefc8f1daee70e"}, - {file = "yarl-1.22.0-cp311-cp311-win32.whl", hash = "sha256:a9b1ba5610a4e20f655258d5a1fdc7ebe3d837bb0e45b581398b99eb98b1f5ca"}, - {file = "yarl-1.22.0-cp311-cp311-win_amd64.whl", hash = "sha256:078278b9b0b11568937d9509b589ee83ef98ed6d561dfe2020e24a9fd08eaa2b"}, - {file = "yarl-1.22.0-cp311-cp311-win_arm64.whl", hash = "sha256:b6a6f620cfe13ccec221fa312139135166e47ae169f8253f72a0abc0dae94376"}, - {file = "yarl-1.22.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e340382d1afa5d32b892b3ff062436d592ec3d692aeea3bef3a5cfe11bbf8c6f"}, - {file = "yarl-1.22.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f1e09112a2c31ffe8d80be1b0988fa6a18c5d5cad92a9ffbb1c04c91bfe52ad2"}, - {file = "yarl-1.22.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:939fe60db294c786f6b7c2d2e121576628468f65453d86b0fe36cb52f987bd74"}, - {file = "yarl-1.22.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1651bf8e0398574646744c1885a41198eba53dc8a9312b954073f845c90a8df"}, - {file = "yarl-1.22.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b8a0588521a26bf92a57a1705b77b8b59044cdceccac7151bd8d229e66b8dedb"}, - {file = "yarl-1.22.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42188e6a615c1a75bcaa6e150c3fe8f3e8680471a6b10150c5f7e83f47cc34d2"}, - {file = "yarl-1.22.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6d2cb59377d99718913ad9a151030d6f83ef420a2b8f521d94609ecc106ee82"}, - {file = "yarl-1.22.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50678a3b71c751d58d7908edc96d332af328839eea883bb554a43f539101277a"}, - {file = "yarl-1.22.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e8fbaa7cec507aa24ea27a01456e8dd4b6fab829059b69844bd348f2d467124"}, - {file = "yarl-1.22.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:433885ab5431bc3d3d4f2f9bd15bfa1614c522b0f1405d62c4f926ccd69d04fa"}, - {file = "yarl-1.22.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b790b39c7e9a4192dc2e201a282109ed2985a1ddbd5ac08dc56d0e121400a8f7"}, - {file = "yarl-1.22.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31f0b53913220599446872d757257be5898019c85e7971599065bc55065dc99d"}, - {file = "yarl-1.22.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a49370e8f711daec68d09b821a34e1167792ee2d24d405cbc2387be4f158b520"}, - {file = "yarl-1.22.0-cp312-cp312-win32.whl", hash = "sha256:70dfd4f241c04bd9239d53b17f11e6ab672b9f1420364af63e8531198e3f5fe8"}, - {file = "yarl-1.22.0-cp312-cp312-win_amd64.whl", hash = "sha256:8884d8b332a5e9b88e23f60bb166890009429391864c685e17bd73a9eda9105c"}, - {file = "yarl-1.22.0-cp312-cp312-win_arm64.whl", hash = "sha256:ea70f61a47f3cc93bdf8b2f368ed359ef02a01ca6393916bc8ff877427181e74"}, - {file = "yarl-1.22.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8dee9c25c74997f6a750cd317b8ca63545169c098faee42c84aa5e506c819b53"}, - {file = "yarl-1.22.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:01e73b85a5434f89fc4fe27dcda2aff08ddf35e4d47bbbea3bdcd25321af538a"}, - {file = "yarl-1.22.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:22965c2af250d20c873cdbee8ff958fb809940aeb2e74ba5f20aaf6b7ac8c70c"}, - {file = "yarl-1.22.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4f15793aa49793ec8d1c708ab7f9eded1aa72edc5174cae703651555ed1b601"}, - {file = "yarl-1.22.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5542339dcf2747135c5c85f68680353d5cb9ffd741c0f2e8d832d054d41f35a"}, - {file = "yarl-1.22.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5c401e05ad47a75869c3ab3e35137f8468b846770587e70d71e11de797d113df"}, - {file = "yarl-1.22.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:243dda95d901c733f5b59214d28b0120893d91777cb8aa043e6ef059d3cddfe2"}, - {file = "yarl-1.22.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bec03d0d388060058f5d291a813f21c011041938a441c593374da6077fe21b1b"}, - {file = "yarl-1.22.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0748275abb8c1e1e09301ee3cf90c8a99678a4e92e4373705f2a2570d581273"}, - {file = "yarl-1.22.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:47fdb18187e2a4e18fda2c25c05d8251a9e4a521edaed757fef033e7d8498d9a"}, - {file = "yarl-1.22.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c7044802eec4524fde550afc28edda0dd5784c4c45f0be151a2d3ba017daca7d"}, - {file = "yarl-1.22.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:139718f35149ff544caba20fce6e8a2f71f1e39b92c700d8438a0b1d2a631a02"}, - {file = "yarl-1.22.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e1b51bebd221006d3d2f95fbe124b22b247136647ae5dcc8c7acafba66e5ee67"}, - {file = "yarl-1.22.0-cp313-cp313-win32.whl", hash = "sha256:d3e32536234a95f513bd374e93d717cf6b2231a791758de6c509e3653f234c95"}, - {file = "yarl-1.22.0-cp313-cp313-win_amd64.whl", hash = "sha256:47743b82b76d89a1d20b83e60d5c20314cbd5ba2befc9cda8f28300c4a08ed4d"}, - {file = "yarl-1.22.0-cp313-cp313-win_arm64.whl", hash = "sha256:5d0fcda9608875f7d052eff120c7a5da474a6796fe4d83e152e0e4d42f6d1a9b"}, - {file = "yarl-1.22.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:719ae08b6972befcba4310e49edb1161a88cdd331e3a694b84466bd938a6ab10"}, - {file = "yarl-1.22.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:47d8a5c446df1c4db9d21b49619ffdba90e77c89ec6e283f453856c74b50b9e3"}, - {file = "yarl-1.22.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cfebc0ac8333520d2d0423cbbe43ae43c8838862ddb898f5ca68565e395516e9"}, - {file = "yarl-1.22.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4398557cbf484207df000309235979c79c4356518fd5c99158c7d38203c4da4f"}, - {file = "yarl-1.22.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2ca6fd72a8cd803be290d42f2dec5cdcd5299eeb93c2d929bf060ad9efaf5de0"}, - {file = "yarl-1.22.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca1f59c4e1ab6e72f0a23c13fca5430f889634166be85dbf1013683e49e3278e"}, - {file = "yarl-1.22.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c5010a52015e7c70f86eb967db0f37f3c8bd503a695a49f8d45700144667708"}, - {file = "yarl-1.22.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d7672ecf7557476642c88497c2f8d8542f8e36596e928e9bcba0e42e1e7d71f"}, - {file = "yarl-1.22.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:3b7c88eeef021579d600e50363e0b6ee4f7f6f728cd3486b9d0f3ee7b946398d"}, - {file = "yarl-1.22.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f4afb5c34f2c6fecdcc182dfcfc6af6cccf1aa923eed4d6a12e9d96904e1a0d8"}, - {file = "yarl-1.22.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:59c189e3e99a59cf8d83cbb31d4db02d66cda5a1a4374e8a012b51255341abf5"}, - {file = "yarl-1.22.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:5a3bf7f62a289fa90f1990422dc8dff5a458469ea71d1624585ec3a4c8d6960f"}, - {file = "yarl-1.22.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:de6b9a04c606978fdfe72666fa216ffcf2d1a9f6a381058d4378f8d7b1e5de62"}, - {file = "yarl-1.22.0-cp313-cp313t-win32.whl", hash = "sha256:1834bb90991cc2999f10f97f5f01317f99b143284766d197e43cd5b45eb18d03"}, - {file = "yarl-1.22.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ff86011bd159a9d2dfc89c34cfd8aff12875980e3bd6a39ff097887520e60249"}, - {file = "yarl-1.22.0-cp313-cp313t-win_arm64.whl", hash = "sha256:7861058d0582b847bc4e3a4a4c46828a410bca738673f35a29ba3ca5db0b473b"}, - {file = "yarl-1.22.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:34b36c2c57124530884d89d50ed2c1478697ad7473efd59cfd479945c95650e4"}, - {file = "yarl-1.22.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:0dd9a702591ca2e543631c2a017e4a547e38a5c0f29eece37d9097e04a7ac683"}, - {file = "yarl-1.22.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:594fcab1032e2d2cc3321bb2e51271e7cd2b516c7d9aee780ece81b07ff8244b"}, - {file = "yarl-1.22.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3d7a87a78d46a2e3d5b72587ac14b4c16952dd0887dbb051451eceac774411e"}, - {file = "yarl-1.22.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:852863707010316c973162e703bddabec35e8757e67fcb8ad58829de1ebc8590"}, - {file = "yarl-1.22.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:131a085a53bfe839a477c0845acf21efc77457ba2bcf5899618136d64f3303a2"}, - {file = "yarl-1.22.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:078a8aefd263f4d4f923a9677b942b445a2be970ca24548a8102689a3a8ab8da"}, - {file = "yarl-1.22.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bca03b91c323036913993ff5c738d0842fc9c60c4648e5c8d98331526df89784"}, - {file = "yarl-1.22.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:68986a61557d37bb90d3051a45b91fa3d5c516d177dfc6dd6f2f436a07ff2b6b"}, - {file = "yarl-1.22.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4792b262d585ff0dff6bcb787f8492e40698443ec982a3568c2096433660c694"}, - {file = "yarl-1.22.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ebd4549b108d732dba1d4ace67614b9545b21ece30937a63a65dd34efa19732d"}, - {file = "yarl-1.22.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f87ac53513d22240c7d59203f25cc3beac1e574c6cd681bbfd321987b69f95fd"}, - {file = "yarl-1.22.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:22b029f2881599e2f1b06f8f1db2ee63bd309e2293ba2d566e008ba12778b8da"}, - {file = "yarl-1.22.0-cp314-cp314-win32.whl", hash = "sha256:6a635ea45ba4ea8238463b4f7d0e721bad669f80878b7bfd1f89266e2ae63da2"}, - {file = "yarl-1.22.0-cp314-cp314-win_amd64.whl", hash = "sha256:0d6e6885777af0f110b0e5d7e5dda8b704efed3894da26220b7f3d887b839a79"}, - {file = "yarl-1.22.0-cp314-cp314-win_arm64.whl", hash = "sha256:8218f4e98d3c10d683584cb40f0424f4b9fd6e95610232dd75e13743b070ee33"}, - {file = "yarl-1.22.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:45c2842ff0e0d1b35a6bf1cd6c690939dacb617a70827f715232b2e0494d55d1"}, - {file = "yarl-1.22.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d947071e6ebcf2e2bee8fce76e10faca8f7a14808ca36a910263acaacef08eca"}, - {file = "yarl-1.22.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:334b8721303e61b00019474cc103bdac3d7b1f65e91f0bfedeec2d56dfe74b53"}, - {file = "yarl-1.22.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e7ce67c34138a058fd092f67d07a72b8e31ff0c9236e751957465a24b28910c"}, - {file = "yarl-1.22.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d77e1b2c6d04711478cb1c4ab90db07f1609ccf06a287d5607fcd90dc9863acf"}, - {file = "yarl-1.22.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4647674b6150d2cae088fc07de2738a84b8bcedebef29802cf0b0a82ab6face"}, - {file = "yarl-1.22.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:efb07073be061c8f79d03d04139a80ba33cbd390ca8f0297aae9cce6411e4c6b"}, - {file = "yarl-1.22.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e51ac5435758ba97ad69617e13233da53908beccc6cfcd6c34bbed8dcbede486"}, - {file = "yarl-1.22.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33e32a0dd0c8205efa8e83d04fc9f19313772b78522d1bdc7d9aed706bfd6138"}, - {file = "yarl-1.22.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:bf4a21e58b9cde0e401e683ebd00f6ed30a06d14e93f7c8fd059f8b6e8f87b6a"}, - {file = "yarl-1.22.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e4b582bab49ac33c8deb97e058cd67c2c50dac0dd134874106d9c774fd272529"}, - {file = "yarl-1.22.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0b5bcc1a9c4839e7e30b7b30dd47fe5e7e44fb7054ec29b5bb8d526aa1041093"}, - {file = "yarl-1.22.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c0232bce2170103ec23c454e54a57008a9a72b5d1c3105dc2496750da8cfa47c"}, - {file = "yarl-1.22.0-cp314-cp314t-win32.whl", hash = "sha256:8009b3173bcd637be650922ac455946197d858b3630b6d8787aa9e5c4564533e"}, - {file = "yarl-1.22.0-cp314-cp314t-win_amd64.whl", hash = "sha256:9fb17ea16e972c63d25d4a97f016d235c78dd2344820eb35bc034bc32012ee27"}, - {file = "yarl-1.22.0-cp314-cp314t-win_arm64.whl", hash = "sha256:9f6d73c1436b934e3f01df1e1b21ff765cd1d28c77dfb9ace207f746d4610ee1"}, - {file = "yarl-1.22.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3aa27acb6de7a23785d81557577491f6c38a5209a254d1191519d07d8fe51748"}, - {file = "yarl-1.22.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:af74f05666a5e531289cb1cc9c883d1de2088b8e5b4de48004e5ca8a830ac859"}, - {file = "yarl-1.22.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:62441e55958977b8167b2709c164c91a6363e25da322d87ae6dd9c6019ceecf9"}, - {file = "yarl-1.22.0-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b580e71cac3f8113d3135888770903eaf2f507e9421e5697d6ee6d8cd1c7f054"}, - {file = "yarl-1.22.0-cp39-cp39-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e81fda2fb4a07eda1a2252b216aa0df23ebcd4d584894e9612e80999a78fd95b"}, - {file = "yarl-1.22.0-cp39-cp39-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:99b6fc1d55782461b78221e95fc357b47ad98b041e8e20f47c1411d0aacddc60"}, - {file = "yarl-1.22.0-cp39-cp39-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:088e4e08f033db4be2ccd1f34cf29fe994772fb54cfe004bbf54db320af56890"}, - {file = "yarl-1.22.0-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2e4e1f6f0b4da23e61188676e3ed027ef0baa833a2e633c29ff8530800edccba"}, - {file = "yarl-1.22.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:84fc3ec96fce86ce5aa305eb4aa9358279d1aa644b71fab7b8ed33fe3ba1a7ca"}, - {file = "yarl-1.22.0-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:5dbeefd6ca588b33576a01b0ad58aa934bc1b41ef89dee505bf2932b22ddffba"}, - {file = "yarl-1.22.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:14291620375b1060613f4aab9ebf21850058b6b1b438f386cc814813d901c60b"}, - {file = "yarl-1.22.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:a4fcfc8eb2c34148c118dfa02e6427ca278bfd0f3df7c5f99e33d2c0e81eae3e"}, - {file = "yarl-1.22.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:029866bde8d7b0878b9c160e72305bbf0a7342bcd20b9999381704ae03308dc8"}, - {file = "yarl-1.22.0-cp39-cp39-win32.whl", hash = "sha256:4dcc74149ccc8bba31ce1944acee24813e93cfdee2acda3c172df844948ddf7b"}, - {file = "yarl-1.22.0-cp39-cp39-win_amd64.whl", hash = "sha256:10619d9fdee46d20edc49d3479e2f8269d0779f1b031e6f7c2aa1c76be04b7ed"}, - {file = "yarl-1.22.0-cp39-cp39-win_arm64.whl", hash = "sha256:dd7afd3f8b0bfb4e0d9fc3c31bfe8a4ec7debe124cfd90619305def3c8ca8cd2"}, - {file = "yarl-1.22.0-py3-none-any.whl", hash = "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff"}, - {file = "yarl-1.22.0.tar.gz", hash = "sha256:bebf8557577d4401ba8bd9ff33906f1376c877aa78d1fe216ad01b4d6745af71"}, + {file = "yarl-1.23.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:cff6d44cb13d39db2663a22b22305d10855efa0fa8015ddeacc40bc59b9d8107"}, + {file = "yarl-1.23.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c53f8347cd4200f0d70a48ad059cabaf24f5adc6ba08622a23423bc7efa10d"}, + {file = "yarl-1.23.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a6940a074fb3c48356ed0158a3ca5699c955ee4185b4d7d619be3c327143e05"}, + {file = "yarl-1.23.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed5f69ce7be7902e5c70ea19eb72d20abf7d725ab5d49777d696e32d4fc1811d"}, + {file = "yarl-1.23.0-cp310-cp310-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:389871e65468400d6283c0308e791a640b5ab5c83bcee02a2f51295f95e09748"}, + {file = "yarl-1.23.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:dda608c88cf709b1d406bdfcd84d8d63cff7c9e577a403c6108ce8ce9dcc8764"}, + {file = "yarl-1.23.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8c4fe09e0780c6c3bf2b7d4af02ee2394439d11a523bbcf095cf4747c2932007"}, + {file = "yarl-1.23.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31c9921eb8bd12633b41ad27686bbb0b1a2a9b8452bfdf221e34f311e9942ed4"}, + {file = "yarl-1.23.0-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5f10fd85e4b75967468af655228fbfd212bdf66db1c0d135065ce288982eda26"}, + {file = "yarl-1.23.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:dbf507e9ef5688bada447a24d68b4b58dd389ba93b7afc065a2ba892bea54769"}, + {file = "yarl-1.23.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:85e9beda1f591bc73e77ea1c51965c68e98dafd0fec72cdd745f77d727466716"}, + {file = "yarl-1.23.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:0e1fdaa14ef51366d7757b45bde294e95f6c8c049194e793eedb8387c86d5993"}, + {file = "yarl-1.23.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:75e3026ab649bf48f9a10c0134512638725b521340293f202a69b567518d94e0"}, + {file = "yarl-1.23.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:80e6d33a3d42a7549b409f199857b4fb54e2103fc44fb87605b6663b7a7ff750"}, + {file = "yarl-1.23.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5ec2f42d41ccbd5df0270d7df31618a8ee267bfa50997f5d720ddba86c4a83a6"}, + {file = "yarl-1.23.0-cp310-cp310-win32.whl", hash = "sha256:debe9c4f41c32990771be5c22b56f810659f9ddf3d63f67abfdcaa2c6c9c5c1d"}, + {file = "yarl-1.23.0-cp310-cp310-win_amd64.whl", hash = "sha256:ab5f043cb8a2d71c981c09c510da013bc79fd661f5c60139f00dd3c3cc4f2ffb"}, + {file = "yarl-1.23.0-cp310-cp310-win_arm64.whl", hash = "sha256:263cd4f47159c09b8b685890af949195b51d1aa82ba451c5847ca9bc6413c220"}, + {file = "yarl-1.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b35d13d549077713e4414f927cdc388d62e543987c572baee613bf82f11a4b99"}, + {file = "yarl-1.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cbb0fef01f0c6b38cb0f39b1f78fc90b807e0e3c86a7ff3ce74ad77ce5c7880c"}, + {file = "yarl-1.23.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc52310451fc7c629e13c4e061cbe2dd01684d91f2f8ee2821b083c58bd72432"}, + {file = "yarl-1.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2c6b50c7b0464165472b56b42d4c76a7b864597007d9c085e8b63e185cf4a7a"}, + {file = "yarl-1.23.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:aafe5dcfda86c8af00386d7781d4c2181b5011b7be3f2add5e99899ea925df05"}, + {file = "yarl-1.23.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9ee33b875f0b390564c1fb7bc528abf18c8ee6073b201c6ae8524aca778e2d83"}, + {file = "yarl-1.23.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4c41e021bc6d7affb3364dc1e1e5fa9582b470f283748784bd6ea0558f87f42c"}, + {file = "yarl-1.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99c8a9ed30f4164bc4c14b37a90208836cbf50d4ce2a57c71d0f52c7fb4f7598"}, + {file = "yarl-1.23.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f2af5c81a1f124609d5f33507082fc3f739959d4719b56877ab1ee7e7b3d602b"}, + {file = "yarl-1.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6b41389c19b07c760c7e427a3462e8ab83c4bb087d127f0e854c706ce1b9215c"}, + {file = "yarl-1.23.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1dc702e42d0684f42d6519c8d581e49c96cefaaab16691f03566d30658ee8788"}, + {file = "yarl-1.23.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0e40111274f340d32ebcc0a5668d54d2b552a6cca84c9475859d364b380e3222"}, + {file = "yarl-1.23.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:4764a6a7588561a9aef92f65bda2c4fb58fe7c675c0883862e6df97559de0bfb"}, + {file = "yarl-1.23.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:03214408cfa590df47728b84c679ae4ef00be2428e11630277be0727eba2d7cc"}, + {file = "yarl-1.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:170e26584b060879e29fac213e4228ef063f39128723807a312e5c7fec28eff2"}, + {file = "yarl-1.23.0-cp311-cp311-win32.whl", hash = "sha256:51430653db848d258336cfa0244427b17d12db63d42603a55f0d4546f50f25b5"}, + {file = "yarl-1.23.0-cp311-cp311-win_amd64.whl", hash = "sha256:bf49a3ae946a87083ef3a34c8f677ae4243f5b824bfc4c69672e72b3d6719d46"}, + {file = "yarl-1.23.0-cp311-cp311-win_arm64.whl", hash = "sha256:b39cb32a6582750b6cc77bfb3c49c0f8760dc18dc96ec9fb55fbb0f04e08b928"}, + {file = "yarl-1.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:1932b6b8bba8d0160a9d1078aae5838a66039e8832d41d2992daa9a3a08f7860"}, + {file = "yarl-1.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:411225bae281f114067578891bc75534cfb3d92a3b4dfef7a6ca78ba354e6069"}, + {file = "yarl-1.23.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13a563739ae600a631c36ce096615fe307f131344588b0bc0daec108cdb47b25"}, + {file = "yarl-1.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cbf44c5cb4a7633d078788e1b56387e3d3cf2b8139a3be38040b22d6c3221c8"}, + {file = "yarl-1.23.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53ad387048f6f09a8969631e4de3f1bf70c50e93545d64af4f751b2498755072"}, + {file = "yarl-1.23.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4a59ba56f340334766f3a4442e0efd0af895fae9e2b204741ef885c446b3a1a8"}, + {file = "yarl-1.23.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:803a3c3ce4acc62eaf01eaca1208dcf0783025ef27572c3336502b9c232005e7"}, + {file = "yarl-1.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3d2bff8f37f8d0f96c7ec554d16945050d54462d6e95414babaa18bfafc7f51"}, + {file = "yarl-1.23.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c75eb09e8d55bceb4367e83496ff8ef2bc7ea6960efb38e978e8073ea59ecb67"}, + {file = "yarl-1.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877b0738624280e34c55680d6054a307aa94f7d52fa0e3034a9cc6e790871da7"}, + {file = "yarl-1.23.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:b5405bb8f0e783a988172993cfc627e4d9d00432d6bbac65a923041edacf997d"}, + {file = "yarl-1.23.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1c3a3598a832590c5a3ce56ab5576361b5688c12cb1d39429cf5dba30b510760"}, + {file = "yarl-1.23.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:8419ebd326430d1cbb7efb5292330a2cf39114e82df5cc3d83c9a0d5ebeaf2f2"}, + {file = "yarl-1.23.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:be61f6fff406ca40e3b1d84716fde398fc08bc63dd96d15f3a14230a0973ed86"}, + {file = "yarl-1.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3ceb13c5c858d01321b5d9bb65e4cf37a92169ea470b70fec6f236b2c9dd7e34"}, + {file = "yarl-1.23.0-cp312-cp312-win32.whl", hash = "sha256:fffc45637bcd6538de8b85f51e3df3223e4ad89bccbfca0481c08c7fc8b7ed7d"}, + {file = "yarl-1.23.0-cp312-cp312-win_amd64.whl", hash = "sha256:f69f57305656a4852f2a7203efc661d8c042e6cc67f7acd97d8667fb448a426e"}, + {file = "yarl-1.23.0-cp312-cp312-win_arm64.whl", hash = "sha256:6e87a6e8735b44816e7db0b2fbc9686932df473c826b0d9743148432e10bb9b9"}, + {file = "yarl-1.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:16c6994ac35c3e74fb0ae93323bf8b9c2a9088d55946109489667c510a7d010e"}, + {file = "yarl-1.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4a42e651629dafb64fd5b0286a3580613702b5809ad3f24934ea87595804f2c5"}, + {file = "yarl-1.23.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7c6b9461a2a8b47c65eef63bb1c76a4f1c119618ffa99ea79bc5bb1e46c5821b"}, + {file = "yarl-1.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2569b67d616eab450d262ca7cb9f9e19d2f718c70a8b88712859359d0ab17035"}, + {file = "yarl-1.23.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e9d9a4d06d3481eab79803beb4d9bd6f6a8e781ec078ac70d7ef2dcc29d1bea5"}, + {file = "yarl-1.23.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f514f6474e04179d3d33175ed3f3e31434d3130d42ec153540d5b157deefd735"}, + {file = "yarl-1.23.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fda207c815b253e34f7e1909840fd14299567b1c0eb4908f8c2ce01a41265401"}, + {file = "yarl-1.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34b6cf500e61c90f305094911f9acc9c86da1a05a7a3f5be9f68817043f486e4"}, + {file = "yarl-1.23.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d7504f2b476d21653e4d143f44a175f7f751cd41233525312696c76aa3dbb23f"}, + {file = "yarl-1.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:578110dd426f0d209d1509244e6d4a3f1a3e9077655d98c5f22583d63252a08a"}, + {file = "yarl-1.23.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:609d3614d78d74ebe35f54953c5bbd2ac647a7ddb9c30a5d877580f5e86b22f2"}, + {file = "yarl-1.23.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4966242ec68afc74c122f8459abd597afd7d8a60dc93d695c1334c5fd25f762f"}, + {file = "yarl-1.23.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e0fd068364a6759bc794459f0a735ab151d11304346332489c7972bacbe9e72b"}, + {file = "yarl-1.23.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:39004f0ad156da43e86aa71f44e033de68a44e5a31fc53507b36dd253970054a"}, + {file = "yarl-1.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e5723c01a56c5028c807c701aa66722916d2747ad737a046853f6c46f4875543"}, + {file = "yarl-1.23.0-cp313-cp313-win32.whl", hash = "sha256:1b6b572edd95b4fa8df75de10b04bc81acc87c1c7d16bcdd2035b09d30acc957"}, + {file = "yarl-1.23.0-cp313-cp313-win_amd64.whl", hash = "sha256:baaf55442359053c7d62f6f8413a62adba3205119bcb6f49594894d8be47e5e3"}, + {file = "yarl-1.23.0-cp313-cp313-win_arm64.whl", hash = "sha256:fb4948814a2a98e3912505f09c9e7493b1506226afb1f881825368d6fb776ee3"}, + {file = "yarl-1.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:aecfed0b41aa72b7881712c65cf764e39ce2ec352324f5e0837c7048d9e6daaa"}, + {file = "yarl-1.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a41bcf68efd19073376eb8cf948b8d9be0af26256403e512bb18f3966f1f9120"}, + {file = "yarl-1.23.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cde9a2ecd91668bcb7f077c4966d8ceddb60af01b52e6e3e2680e4cf00ad1a59"}, + {file = "yarl-1.23.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5023346c4ee7992febc0068e7593de5fa2bf611848c08404b35ebbb76b1b0512"}, + {file = "yarl-1.23.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d1009abedb49ae95b136a8904a3f71b342f849ffeced2d3747bf29caeda218c4"}, + {file = "yarl-1.23.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a8d00f29b42f534cc8aa3931cfe773b13b23e561e10d2b26f27a8d309b0e82a1"}, + {file = "yarl-1.23.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:95451e6ce06c3e104556d73b559f5da6c34a069b6b62946d3ad66afcd51642ea"}, + {file = "yarl-1.23.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531ef597132086b6cf96faa7c6c1dcd0361dd5f1694e5cc30375907b9b7d3ea9"}, + {file = "yarl-1.23.0-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:88f9fb0116fbfcefcab70f85cf4b74a2b6ce5d199c41345296f49d974ddb4123"}, + {file = "yarl-1.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e7b0460976dc75cb87ad9cc1f9899a4b97751e7d4e77ab840fc9b6d377b8fd24"}, + {file = "yarl-1.23.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:115136c4a426f9da976187d238e84139ff6b51a20839aa6e3720cd1026d768de"}, + {file = "yarl-1.23.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:ead11956716a940c1abc816b7df3fa2b84d06eaed8832ca32f5c5e058c65506b"}, + {file = "yarl-1.23.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:fe8f8f5e70e6dbdfca9882cd9deaac058729bcf323cf7a58660901e55c9c94f6"}, + {file = "yarl-1.23.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:a0e317df055958a0c1e79e5d2aa5a5eaa4a6d05a20d4b0c9c3f48918139c9fc6"}, + {file = "yarl-1.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f0fd84de0c957b2d280143522c4f91a73aada1923caee763e24a2b3fda9f8a5"}, + {file = "yarl-1.23.0-cp313-cp313t-win32.whl", hash = "sha256:93a784271881035ab4406a172edb0faecb6e7d00f4b53dc2f55919d6c9688595"}, + {file = "yarl-1.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:dd00607bffbf30250fe108065f07453ec124dbf223420f57f5e749b04295e090"}, + {file = "yarl-1.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ac09d42f48f80c9ee1635b2fcaa819496a44502737660d3c0f2ade7526d29144"}, + {file = "yarl-1.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:21d1b7305a71a15b4794b5ff22e8eef96ff4a6d7f9657155e5aa419444b28912"}, + {file = "yarl-1.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:85610b4f27f69984932a7abbe52703688de3724d9f72bceb1cca667deff27474"}, + {file = "yarl-1.23.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23f371bd662cf44a7630d4d113101eafc0cfa7518a2760d20760b26021454719"}, + {file = "yarl-1.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c4a80f77dc1acaaa61f0934176fccca7096d9b1ff08c8ba9cddf5ae034a24319"}, + {file = "yarl-1.23.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:bd654fad46d8d9e823afbb4f87c79160b5a374ed1ff5bde24e542e6ba8f41434"}, + {file = "yarl-1.23.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:682bae25f0a0dd23a056739f23a134db9f52a63e2afd6bfb37ddc76292bbd723"}, + {file = "yarl-1.23.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a82836cab5f197a0514235aaf7ffccdc886ccdaa2324bc0aafdd4ae898103039"}, + {file = "yarl-1.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1c57676bdedc94cd3bc37724cf6f8cd2779f02f6aba48de45feca073e714fe52"}, + {file = "yarl-1.23.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c7f8dc16c498ff06497c015642333219871effba93e4a2e8604a06264aca5c5c"}, + {file = "yarl-1.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5ee586fb17ff8f90c91cf73c6108a434b02d69925f44f5f8e0d7f2f260607eae"}, + {file = "yarl-1.23.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:17235362f580149742739cc3828b80e24029d08cbb9c4bda0242c7b5bc610a8e"}, + {file = "yarl-1.23.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:0793e2bd0cf14234983bbb371591e6bea9e876ddf6896cdcc93450996b0b5c85"}, + {file = "yarl-1.23.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3650dc2480f94f7116c364096bc84b1d602f44224ef7d5c7208425915c0475dd"}, + {file = "yarl-1.23.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f40e782d49630ad384db66d4d8b73ff4f1b8955dc12e26b09a3e3af064b3b9d6"}, + {file = "yarl-1.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:94f8575fbdf81749008d980c17796097e645574a3b8c28ee313931068dad14fe"}, + {file = "yarl-1.23.0-cp314-cp314-win32.whl", hash = "sha256:c8aa34a5c864db1087d911a0b902d60d203ea3607d91f615acd3f3108ac32169"}, + {file = "yarl-1.23.0-cp314-cp314-win_amd64.whl", hash = "sha256:63e92247f383c85ab00dd0091e8c3fa331a96e865459f5ee80353c70a4a42d70"}, + {file = "yarl-1.23.0-cp314-cp314-win_arm64.whl", hash = "sha256:70efd20be968c76ece7baa8dafe04c5be06abc57f754d6f36f3741f7aa7a208e"}, + {file = "yarl-1.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9a18d6f9359e45722c064c97464ec883eb0e0366d33eda61cb19a244bf222679"}, + {file = "yarl-1.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:2803ed8b21ca47a43da80a6fd1ed3019d30061f7061daa35ac54f63933409412"}, + {file = "yarl-1.23.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:394906945aa8b19fc14a61cf69743a868bb8c465efe85eee687109cc540b98f4"}, + {file = "yarl-1.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:71d006bee8397a4a89f469b8deb22469fe7508132d3c17fa6ed871e79832691c"}, + {file = "yarl-1.23.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:62694e275c93d54f7ccedcfef57d42761b2aad5234b6be1f3e3026cae4001cd4"}, + {file = "yarl-1.23.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31de1613658308efdb21ada98cbc86a97c181aa050ba22a808120bb5be3ab94"}, + {file = "yarl-1.23.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fb1e8b8d66c278b21d13b0a7ca22c41dd757a7c209c6b12c313e445c31dd3b28"}, + {file = "yarl-1.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50f9d8d531dfb767c565f348f33dd5139a6c43f5cbdf3f67da40d54241df93f6"}, + {file = "yarl-1.23.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:575aa4405a656e61a540f4a80eaa5260f2a38fff7bfdc4b5f611840d76e9e277"}, + {file = "yarl-1.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:041b1a4cefacf65840b4e295c6985f334ba83c30607441ae3cf206a0eed1a2e4"}, + {file = "yarl-1.23.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:d38c1e8231722c4ce40d7593f28d92b5fc72f3e9774fe73d7e800ec32299f63a"}, + {file = "yarl-1.23.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d53834e23c015ee83a99377db6e5e37d8484f333edb03bd15b4bc312cc7254fb"}, + {file = "yarl-1.23.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2e27c8841126e017dd2a054a95771569e6070b9ee1b133366d8b31beb5018a41"}, + {file = "yarl-1.23.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:76855800ac56f878847a09ce6dba727c93ca2d89c9e9d63002d26b916810b0a2"}, + {file = "yarl-1.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e09fd068c2e169a7070d83d3bde728a4d48de0549f975290be3c108c02e499b4"}, + {file = "yarl-1.23.0-cp314-cp314t-win32.whl", hash = "sha256:73309162a6a571d4cbd3b6a1dcc703c7311843ae0d1578df6f09be4e98df38d4"}, + {file = "yarl-1.23.0-cp314-cp314t-win_amd64.whl", hash = "sha256:4503053d296bc6e4cbd1fad61cf3b6e33b939886c4f249ba7c78b602214fabe2"}, + {file = "yarl-1.23.0-cp314-cp314t-win_arm64.whl", hash = "sha256:44bb7bef4ea409384e3f8bc36c063d77ea1b8d4a5b2706956c0d6695f07dcc25"}, + {file = "yarl-1.23.0-py3-none-any.whl", hash = "sha256:a2df6afe50dea8ae15fa34c9f824a3ee958d785fd5d089063d960bae1daa0a3f"}, + {file = "yarl-1.23.0.tar.gz", hash = "sha256:53b1ea6ca88ebd4420379c330aea57e258408dd0df9af0992e5de2078dc9f5d5"}, ] [package.dependencies] @@ -6612,4 +6750,4 @@ type = ["pytest-mypy"] [metadata] lock-version = "2.1" python-versions = "^3.11" -content-hash = "f330cc2b461500d6cc6e4c10494a185e31171c508801afe870c22ea6bbe1afb7" +content-hash = "b94c4b3c21e2d3634820597f293dcc875d49aeacc34ce3badcbefc2ae918302f" diff --git a/pyproject.toml b/pyproject.toml index dcb2cb6..882bcc1 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,7 +28,6 @@ tiktoken = ">=0.8.0,<0.13.0" aiofiles = ">=24.1.0,<26.0.0" aiohttp = "^3.9.3" aiolimiter = "^1.1.0" -asyncio = ">=3.0.0,<5.0.0" nest-asyncio = "^1.5.8" requests = "^2.32.3" pydantic = "^2.9.2" @@ -49,6 +48,7 @@ asknews = ">=0.9.1,<0.14.0" unidecode = "^1.4.0" hyperbrowser = ">=0.53.0,<0.84.0" pendulum = "^3.1.0" +textual = ">=3.0.0,<4.0.0" openai-agents = {extras = ["litellm"], version = ">=0.2.0,<0.10.0"} [tool.poetry.group.dev.dependencies]