diff --git a/.gitignore b/.gitignore index 9a38fbc04c535c..c40424b7fa0a6c 100644 --- a/.gitignore +++ b/.gitignore @@ -2,8 +2,10 @@ dist/ migration_scripts/ venv/ +.venv/ .ipynb_checkpoints .__pycache__ +__pycache__ dev_notebooks/ llamaindex_registry.txt packages_to_bump_deduped.txt diff --git a/docs/community/integrations/uptrain.md b/docs/community/integrations/uptrain.md index ee522f99e5da60..d07e25fcbf1b56 100644 --- a/docs/community/integrations/uptrain.md +++ b/docs/community/integrations/uptrain.md @@ -1,4 +1,4 @@ -# How to use UpTrain with LlamaIndex +# Perform Evaluations on LlamaIndex with UpTrain **Overview**: In this example, we will see how to use UpTrain with LlamaIndex. @@ -12,6 +12,365 @@ 1. LlamaIndex solves the first problem by allowing you to perform Retrieval Augmented Generation (RAG) with a retriever that is fine-tuned on your own data. This allows you to use your own data to fine-tune a retriever, and then use that retriever to perform RAG. 2. UpTrain solves the second problem by allowing you to perform evaluations on the generated responses. This helps you to ensure that the responses are relevant to the prompt, align with the desired tone or the context, and are not offensive etc. +# How to go about it? + +There two ways you can use UpTrain with LlamaIndex: + +1. **Using the UpTrain Callback Handler**: This method allows you to seamlessly integrate UpTrain with LlamaIndex. You can simply add UpTrainCallbackHandler to your existing LlamaIndex pipeline and it will take care of sending the generated responses to the UpTrain Managed Service for evaluations. This is the recommended method as it is the easiest to use and provides you with dashboards and insights with minimal effort. + +2. **Using UpTrain's EvalLlamaIndex**: This method allows you to use UpTrain to perform evaluations on the generated responses. You can use the EvalLlamaIndex object to generate responses for the queries and then perform evaluations on the responses. You can find a detailed tutorial on how to do this below. This method offers more flexibility and control over the evaluations, but requires more effort to set up and use. + +# 1. Using the UpTrain Callback Handler Open In Colab + +Three additional evaluations for Llamaindex have been introduced, complementing existing ones. These evaluations run automatically, with results displayed in the output. More details on UpTrain's evaluations can be found [here](https://github.com/uptrain-ai/uptrain?tab=readme-ov-file#pre-built-evaluations-we-offer-). + +Selected operators from the LlamaIndex pipeline are highlighted for demonstration: + +## 1. **RAG Query Engine Evaluations**: + +The RAG query engine plays a crucial role in retrieving context and generating responses. To ensure its performance and response quality, we conduct the following evaluations: + +- **Context Relevance**: Determines if the context extracted from the query is relevant to the response. +- **Factual Accuracy**: Assesses if the LLM is hallcuinating or providing incorrect information. +- **Response Completeness**: Checks if the response contains all the information requested by the query. + +## 2. **Sub-Question Query Generation Evaluation**: + +The SubQuestionQueryGeneration operator decomposes a question into sub-questions, generating responses for each using a RAG query engine. Given the complexity, we include the previous evaluations and add: + +- **Sub Query Completeness**: Assures that the sub-questions accurately and comprehensively cover the original query. + +## 3. **Re-Ranking Evaluations**: + +Re-ranking involves reordering nodes based on relevance to the query and choosing top n nodes. Different evaluations are performed based on the number of nodes returned after re-ranking. + +a. Same Number of Nodes + +- **Context Reranking**: Checks if the order of re-ranked nodes is more relevant to the query than the original order. + +b. Different Number of Nodes: + +- **Context Conciseness**: Examines whether the reduced number of nodes still provides all the required information. + +These evaluations collectively ensure the robustness and effectiveness of the RAG query engine, SubQuestionQueryGeneration operator, and the re-ranking process in the LlamaIndex pipeline. + +#### **Note:** + +- We have performed evaluations using basic RAG query engine, the same evaluations can be performed using the advanced RAG query engine as well. +- Same is true for Re-Ranking evaluations, we have performed evaluations using CohereRerank, the same evaluations can be performed using other re-rankers as well. + +## Install Dependencies and Import Libraries + +Install notebook dependencies. + +```bash +pip install -q html2text llama-index pandas tqdm uptrain cohere +``` + +Import libraries. + +```python +from llama_index import ( + ServiceContext, + VectorStoreIndex, +) +from llama_index.node_parser import SentenceSplitter +from llama_index.readers import SimpleWebPageReader +from llama_index.callbacks import CallbackManager, UpTrainCallbackHandler +from llama_index.postprocessor.cohere_rerank import CohereRerank +from llama_index.service_context import set_global_service_context +from llama_index.query_engine.sub_question_query_engine import ( + SubQuestionQueryEngine, +) +from llama_index.tools.query_engine import QueryEngineTool +from llama_index.tools.types import ToolMetadata +``` + +## Setup + +You can choose between the following options for evaluating using UpTrain: + +### 1. **UpTrain's Open-Source Software (OSS)**: + +You can use the open-source evaluation service to evaluate your model. +In this case, you will need to provide an OpenAI API key. You can get yours [here](https://platform.openai.com/account/api-keys). + +Parameters: + +- key_type="openai" +- api_key="OPENAI_API_KEY" +- project_name_prefix="PROJECT_NAME_PREFIX" + +### 2. **UpTrain Managed Service and Dashboards**: + +You can create a free UpTrain account [here](https://uptrain.ai/) and get free trial credits. If you want more trial credits, [book a call with the maintainers of UpTrain here](https://calendly.com/uptrain-sourabh/30min). + +UpTrain Managed service provides: + +1. Dashboards with advanced drill-down and filtering options +1. Insights and common topics among failing cases +1. Observability and real-time monitoring of production data +1. Regression testing via seamless integration with your CI/CD pipelines + +The notebook contains some screenshots of the dashboards and the insights that you can get from the UpTrain managed service. + +Parameters: + +- key_type="uptrain" +- api_key="UPTRAIN_API_KEY" +- project_name_prefix="PROJECT_NAME_PREFIX" + +**Note:** The `project_name_prefix` will be used as prefix for the project names in the UpTrain dashboard. These will be different for different types of evals. For example, if you set project_name_prefix="llama" and perform the sub_question evaluation, the project name will be "llama_sub_question_answering". + +```python +callback_handler = UpTrainCallbackHandler( + key_type="openai", + api_key="sk-******************************", + project_name_prefix="llama", +) +callback_manager = CallbackManager([callback_handler]) +service_context = ServiceContext.from_defaults( + callback_manager=callback_manager +) +set_global_service_context(service_context) +``` + +## Load and Parse Documents + +Load documents from Paul Graham's essay "What I Worked On". + +```python +documents = SimpleWebPageReader().load_data( + [ + "https://raw.githubusercontent.com/run-llama/llama_index/main/docs/examples/data/paul_graham/paul_graham_essay.txt" + ] +) +``` + +Parse the document into nodes. + +```python +parser = SentenceSplitter() +nodes = parser.get_nodes_from_documents(documents) +``` + +# 1. RAG Query Engine Evaluation + +UpTrain callback handler will automatically capture the query, context and response once generated and will run the following three evaluations _(Graded from 0 to 1)_ on the response: + +- **Context Relevance**: Check if the context extractedfrom the query is relevant to the response. +- **Factual Accuracy**: Check how factually accurate the response is. +- **Response Completeness**: Check if the response contains all the information that the query is asking for. + +```python +index = VectorStoreIndex.from_documents( + documents, service_context=service_context +) +query_engine = index.as_query_engine() + +max_characters_per_line = 80 +queries = [ + "What did Paul Graham do growing up?", + "When and how did Paul Graham's mother die?", + "What, in Paul Graham's opinion, is the most distinctive thing about YC?", + "When and how did Paul Graham meet Jessica Livingston?", + "What is Bel, and when and where was it written?", +] +for query in queries: + response = query_engine.query(query) +``` + + Question: What did Paul Graham do growing up? + Context Relevance Score: 0.0 + Factual Accuracy Score: 1.0 + Response Completeness Score: 0.0 + + + Question: When and how did Paul Graham's mother die? + Context Relevance Score: 0.0 + Factual Accuracy Score: 1.0 + Response Completeness Score: 0.0 + + + Question: What, in Paul Graham's opinion, is the most distinctive thing about YC? + Context Relevance Score: 1.0 + Factual Accuracy Score: 1.0 + Response Completeness Score: 1.0 + + + Question: When and how did Paul Graham meet Jessica Livingston? + Context Relevance Score: 1.0 + Factual Accuracy Score: 1.0 + Response Completeness Score: 0.5 + + + Question: What is Bel, and when and where was it written? + Context Relevance Score: 1.0 + Factual Accuracy Score: 1.0 + Response Completeness Score: 0.0 + +Here's an example of the dashboard showing how you can filter and drill down to the failing cases and get insights on the failing cases: +![image-2.png](https://uptrain-assets.s3.ap-south-1.amazonaws.com/images/llamaindex/image-2.png) + +# 2. Sub-Question Query Engine Evaluation + +The **sub question query engine** is used to tackle the problem of answering a complex query using multiple data sources. It first breaks down the complex query into sub questions for each relevant data source, then gather all the intermediate responses and synthesizes a final response. + +UpTrain callback handler will automatically capture the sub-question and the responses for each of them once generated and will run the following three evaluations _(Graded from 0 to 1)_ on the response: + +- **Context Relevance**: Check if the context extractedfrom the query is relevant to the response. +- **Factual Accuracy**: Check how factually accurate the response is. +- **Response Completeness**: Check if the response contains all the information that the query is asking for. + +In addition to the above evaluations, the callback handler will also run the following evaluation: + +- **Sub Query Completeness**: Checks if the sub-questions accurately and completely cover the original query. + +```python +# build index and query engine +vector_query_engine = VectorStoreIndex.from_documents( + documents=documents, use_async=True, service_context=service_context +).as_query_engine() + +query_engine_tools = [ + QueryEngineTool( + query_engine=vector_query_engine, + metadata=ToolMetadata( + name="documents", + description="Paul Graham essay on What I Worked On", + ), + ), +] + +query_engine = SubQuestionQueryEngine.from_defaults( + query_engine_tools=query_engine_tools, + service_context=service_context, + use_async=True, +) + +response = query_engine.query( + "How was Paul Grahams life different before, during, and after YC?" +) +``` + + Question: What did Paul Graham work on during YC? + Context Relevance Score: 0.5 + Factual Accuracy Score: 1.0 + Response Completeness Score: 0.5 + + + Question: What did Paul Graham work on after YC? + Context Relevance Score: 0.5 + Factual Accuracy Score: 1.0 + Response Completeness Score: 0.5 + + + Question: What did Paul Graham work on before YC? + Context Relevance Score: 1.0 + Factual Accuracy Score: 1.0 + Response Completeness Score: 0.0 + + + Question: How was Paul Grahams life different before, during, and after YC? + Sub Query Completeness Score: 1.0 + +Here's an example of the dashboard visualizing the scores of the sub-questions in the form of a bar chart: + +![image.png](https://uptrain-assets.s3.ap-south-1.amazonaws.com/images/llamaindex/image.png) + +# 3. Re-ranking + +Re-ranking is the process of reordering the nodes based on their relevance to the query. There are multiple classes of re-ranking algorithms offered by Llamaindex. We have used CohereRerank for this example. + +The re-ranker allows you to enter the number of top n nodes that will be returned after re-ranking. If this value remains the same as the original number of nodes, the re-ranker will only re-rank the nodes and not change the number of nodes. Otherwise, it will re-rank the nodes and return the top n nodes. + +We will perform different evaluations based on the number of nodes returned after re-ranking. + +## 3a. Re-ranking (With same number of nodes) + +If the number of nodes returned after re-ranking is the same as the original number of nodes, the following evaluation will be performed: + +- **Context Reranking**: Check if the order of the re-ranked nodes is more relevant to the query than the original order. + +```python +api_key = "**********************************" # Insert cohere API key here +cohere_rerank = CohereRerank( + api_key=api_key, top_n=5 +) # In this example, the number of nodes before re-ranking is 5 and after re-ranking is also 5. + +index = VectorStoreIndex.from_documents( + documents=documents, service_context=service_context +) + +query_engine = index.as_query_engine( + similarity_top_k=10, + node_postprocessors=[cohere_rerank], + service_context=service_context, +) + +response = query_engine.query( + "What did Sam Altman do in this essay?", +) +``` + + Question: What did Sam Altman do in this essay? + Context Reranking Score: 0.0 + +# 3b. Re-ranking (With different number of nodes) + +If the number of nodes returned after re-ranking is the lesser as the original number of nodes, the following evaluation will be performed: + +- **Context Conciseness**: If the re-ranked nodes are able to provide all the information required by the query. + +```python +api_key = "**********************************" # insert cohere API key here +cohere_rerank = CohereRerank( + api_key=api_key, top_n=2 +) # In this example, the number of nodes before re-ranking is 5 and after re-ranking is 2. + +index = VectorStoreIndex.from_documents( + documents=documents, service_context=service_context +) +query_engine = index.as_query_engine( + similarity_top_k=10, + node_postprocessors=[cohere_rerank], + service_context=service_context, +) + +# Use your advanced RAG +response = query_engine.query( + "What did Sam Altman do in this essay?", +) +``` + + Question: What did Sam Altman do in this essay? + Context Conciseness Score: 1.0 + +# UpTrain's Managed Service Dashboard and Insights + +The UpTrain Managed Service offers the following features: + +1. Advanced dashboards with drill-down and filtering options. +1. Identification of insights and common themes among unsuccessful cases. +1. Real-time observability and monitoring of production data. +1. Integration with CI/CD pipelines for seamless regression testing. + +To define the UpTrain callback handler, the only change required is to set the `key_type` and `api_key` parameters. The rest of the code remains the same. + +```python +callback_handler = UpTrainCallbackHandler( + key_type="uptrain", + api_key="up-******************************", + project_name_prefix="llama", +) +``` + +Here's a short GIF showcasing the dashboard and the insights that you can get from the UpTrain managed service: + +![output.gif](https://uptrain-assets.s3.ap-south-1.amazonaws.com/images/llamaindex/output.gif) + +# 2. Using EvalLlamaIndex Open In Colab + ## Install UpTrain and LlamaIndex ```bash @@ -182,16 +541,17 @@ pd.DataFrame(results) Histogram of score vs number of cases with that score -![image.png](UpTrain_files/image.png) +![dashboard.png](https://uptrain-assets.s3.ap-south-1.amazonaws.com/images/llamaindex/nyc_wiki_results.png) ### Insights: You can filter failure cases and generate common topics among them. This can help identify the core issue and help fix it -![LlamaIndex_Integration.gif](UpTrain_files/LlamaIndex_Integration.gif) +![LlamaIndex_Integration.gif](https://uptrain-assets.s3.ap-south-1.amazonaws.com/images/llamaindex/LlamaIndex_Integration.gif) ## Learn More -1. [Colab Notebook on UpTrain Integration with LlamaIndex](https://colab.research.google.com/github/uptrain-ai/llama_index/blob/uptrain_integration/docs/examples/evaluation/UpTrain.ipynb) +1. [Colab Notebook on UpTrainCallbackHandler](https://colab.research.google.com/github/run-llama/llama_index/blob/main/docs/examples/callbacks/UpTrainCallback.ipynb) +1. [Colab Notebook on UpTrain Integration with LlamaIndex](https://colab.research.google.com/github/run-llama/llama_index/blob/main/docs/examples/evaluation/UpTrain.ipynb) 1. [UpTrain Github Repository](https://github.com/uptrain-ai/uptrain) 1. [UpTrain Documentation](https://docs.uptrain.ai/) diff --git a/docs/examples/callbacks/UpTrainCallback.ipynb b/docs/examples/callbacks/UpTrainCallback.ipynb new file mode 100644 index 00000000000000..7ccc72565c127e --- /dev/null +++ b/docs/examples/callbacks/UpTrainCallback.ipynb @@ -0,0 +1,643 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"Open" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# UpTrain Callback Handler\n", + "\n", + "This notebook showcases the UpTrain callback handler seamlessly integrating into your pipeline, facilitating diverse evaluations. Three additional evaluations for Llamaindex have been introduced, complementing existing ones. These evaluations run automatically, with results displayed in the output. More details on UpTrain's evaluations can be found [here](https://github.com/uptrain-ai/uptrain?tab=readme-ov-file#pre-built-evaluations-we-offer-). \n", + "\n", + "Selected operators from the LlamaIndex pipeline are highlighted for demonstration:\n", + "\n", + "## 1. **RAG Query Engine Evaluations**:\n", + "The RAG query engine plays a crucial role in retrieving context and generating responses. To ensure its performance and response quality, we conduct the following evaluations:\n", + "\n", + "- **Context Relevance**: Determines if the context extracted from the query is relevant to the response.\n", + "- **Factual Accuracy**: Assesses if the LLM is hallcuinating or providing incorrect information.\n", + "- **Response Completeness**: Checks if the response contains all the information requested by the query.\n", + "\n", + "## 2. **Sub-Question Query Generation Evaluation**:\n", + "The SubQuestionQueryGeneration operator decomposes a question into sub-questions, generating responses for each using a RAG query engine. Given the complexity, we include the previous evaluations and add:\n", + "\n", + "- **Sub Query Completeness**: Assures that the sub-questions accurately and comprehensively cover the original query.\n", + "\n", + "## 3. **Re-Ranking Evaluations**:\n", + "Re-ranking involves reordering nodes based on relevance to the query and chosing top n nodes. Different evaluations are performed based on the number of nodes returned after re-ranking.\n", + "\n", + "a. Same Number of Nodes\n", + "- **Context Reranking**: Checks if the order of re-ranked nodes is more relevant to the query than the original order.\n", + "\n", + "b. Different Number of Nodes:\n", + "- **Context Conciseness**: Examines whether the reduced number of nodes still provides all the required information.\n", + "\n", + "These evaluations collectively ensure the robustness and effectiveness of the RAG query engine, SubQuestionQueryGeneration operator, and the re-ranking process in the LlamaIndex pipeline." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### **Note:** \n", + "- We have performed evaluations using basic RAG query engine, the same evaluations can be performed using the advanced RAG query engine as well.\n", + "- Same is true for Re-Ranking evaluations, we have performed evaluations using CohereRerank, the same evaluations can be performed using other re-rankers as well." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Install Dependencies and Import Libraries\n", + "\n", + "Install notebook dependencies." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%pip install llama-index-postprocessor-cohere-rerank\n", + "%pip install llama-index-readers-web\n", + "%pip install llama-index-callback-uptrain\n", + "%pip install -q html2text llama-index pandas tqdm uptrain cohere" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Import libraries.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from llama_index.core.settings import Settings\n", + "from llama_index.core import VectorStoreIndex\n", + "from llama_index.core.node_parser import SentenceSplitter\n", + "from llama_index.readers.web import SimpleWebPageReader\n", + "from llama_index.core.callbacks import CallbackManager\n", + "from llama_index.callbacks.uptrain.base import UpTrainCallbackHandler\n", + "from llama_index.core.query_engine import SubQuestionQueryEngine\n", + "from llama_index.core.tools import QueryEngineTool, ToolMetadata\n", + "from llama_index.core.postprocessor.llm_rerank import LLMRerank\n", + "from llama_index.llms.openai import OpenAI\n", + "\n", + "import os" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "You can choose between the following options for evaluating using UpTrain:\n", + "### 1. **UpTrain's Open-Source Software (OSS)**: \n", + "You can use the open-source evaluation service to evaluate your model.\n", + "In this case, you will need to provie an OpenAI API key. You can get yours [here](https://platform.openai.com/account/api-keys).\n", + "\n", + "Parameters:\n", + "- key_type=\"openai\"\n", + "- api_key=\"OPENAI_API_KEY\"\n", + "- project_name_prefix=\"PROJECT_NAME_PREFIX\"\n", + "\n", + "\n", + "### 2. **UpTrain Managed Service and Dashboards**: \n", + "You can create a free UpTrain account [here](https://uptrain.ai/) and get free trial credits. If you want more trial credits, [book a call with the maintainers of UpTrain here](https://calendly.com/uptrain-sourabh/30min).\n", + "\n", + "UpTrain Managed service provides:\n", + "1. Dashboards with advanced drill-down and filtering options\n", + "1. Insights and common topics among failing cases\n", + "1. Observability and real-time monitoring of production data\n", + "1. Regression testing via seamless integration with your CI/CD pipelines\n", + "\n", + "The notebook contains some screenshots of the dashboards and the insights that you can get from the UpTrain managed service.\n", + "\n", + "Parameters:\n", + "- key_type=\"uptrain\"\n", + "- api_key=\"UPTRAIN_API_KEY\"\n", + "- project_name_prefix=\"PROJECT_NAME_PREFIX\"\n", + "\n", + "\n", + "**Note:** The `project_name_prefix` will be used as prefix for the project names in the UpTrain dashboard. These will be different for different types of evals. For example, if you set project_name_prefix=\"llama\" and perform the sub_question evaluation, the project name will be \"llama_sub_question_answering\"." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "callback_handler = UpTrainCallbackHandler(\n", + " key_type=\"openai\",\n", + " api_key=\"sk-...\", # replace with your OpenAI API key\n", + " project_name_prefix=\"llama\",\n", + ")\n", + "Settings.callback_manager = CallbackManager([callback_handler])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load and Parse Documents\n", + "\n", + "Load documents from Paul Graham's essay \"What I Worked On\"." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "documents = SimpleWebPageReader().load_data(\n", + " [\n", + " \"https://raw.githubusercontent.com/run-llama/llama_index/main/docs/examples/data/paul_graham/paul_graham_essay.txt\"\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Parse the document into nodes." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "parser = SentenceSplitter()\n", + "nodes = parser.get_nodes_from_documents(documents)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1. RAG Query Engine Evaluation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "UpTrain callback handler will automatically capture the query, context and response once generated and will run the following three evaluations *(Graded from 0 to 1)* on the response:\n", + "- **Context Relevance**: Check if the context extractedfrom the query is relevant to the response.\n", + "- **Factual Accuracy**: Check how factually accurate the response is.\n", + "- **Response Completeness**: Check if the response contains all the information that the query is asking for." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2024-02-14 16:04:09.869\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m110\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Question: What did Paul Graham do growing up?\n", + "Response: Growing up, Paul Graham worked on writing and programming. He wrote short stories and also tried his hand at programming on the IBM 1401 computer that his school district had. He later got a microcomputer, a TRS-80, and started programming more extensively, creating simple games and even a word processor.\n", + "Context Relevance Score: 0.5\n", + "Factual Accuracy Score: 1.0\n", + "Response Completeness Score: 1.0\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2024-02-14 16:04:36.895\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m110\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Question: When and how did Paul Graham's mother die?\n", + "Response: The context information does not provide any information about Paul Graham's mother or her death.\n", + "Context Relevance Score: 0.0\n", + "Factual Accuracy Score: 0.0\n", + "Response Completeness Score: 0.0\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2024-02-14 16:04:55.245\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m110\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Question: What, in Paul Graham's opinion, is the most distinctive thing about YC?\n", + "Response: The most distinctive thing about YC, according to Paul Graham's opinion, is that it provides a sense of community and support for startup founders. It solves the problem of isolation that founders often face by connecting them with colleagues who understand the challenges they are going through and can offer guidance and support. Additionally, YC fosters a tight-knit alumni community where startups can help each other and even become each other's customers.\n", + "Context Relevance Score: 0.0\n", + "Factual Accuracy Score: 1.0\n", + "Response Completeness Score: 0.5\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2024-02-14 16:05:24.705\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m110\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Question: When and how did Paul Graham meet Jessica Livingston?\n", + "Response: Paul Graham met Jessica Livingston at a party at his house in October 2003. They were introduced to each other by a mutual friend named Maria Daniels. A couple of days later, Paul asked Jessica out and they started dating.\n", + "Context Relevance Score: 0.5\n", + "Factual Accuracy Score: 1.0\n", + "Response Completeness Score: 1.0\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2024-02-14 16:05:52.062\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m110\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Question: What is Bel, and when and where was it written?\n", + "Response: Bel is a new Lisp that was written in Arc. It was written over a period of 4 years, from March 26, 2015, to October 12, 2019. The majority of Bel was written in England, as the author moved there in the summer of 2016.\n", + "Context Relevance Score: 1.0\n", + "Factual Accuracy Score: 1.0\n", + "Response Completeness Score: 0.5\n", + "\n" + ] + } + ], + "source": [ + "index = VectorStoreIndex.from_documents(\n", + " documents,\n", + ")\n", + "query_engine = index.as_query_engine()\n", + "\n", + "max_characters_per_line = 80\n", + "queries = [\n", + " \"What did Paul Graham do growing up?\",\n", + " \"When and how did Paul Graham's mother die?\",\n", + " \"What, in Paul Graham's opinion, is the most distinctive thing about YC?\",\n", + " \"When and how did Paul Graham meet Jessica Livingston?\",\n", + " \"What is Bel, and when and where was it written?\",\n", + "]\n", + "for query in queries:\n", + " response = query_engine.query(query)" + ] + }, + { + "attachments": { + "image-2.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's an example of the dashboard showing how you can filter and drill down to the failing cases and get insights on the failing cases:\n", + "![image-2.png](attachment:image-2.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2. Sub-Question Query Engine Evaluation\n", + "\n", + "The **sub question query engine** is used to tackle the problem of answering a complex query using multiple data sources. It first breaks down the complex query into sub questions for each relevant data source, then gather all the intermediate reponses and synthesizes a final response.\n", + "\n", + "UpTrain callback handler will automatically capture the sub-question and the responses for each of them once generated and will run the following three evaluations *(Graded from 0 to 1)* on the response:\n", + "- **Context Relevance**: Check if the context extractedfrom the query is relevant to the response.\n", + "- **Factual Accuracy**: Check how factually accurate the response is.\n", + "- **Response Completeness**: Check if the response contains all the information that the query is asking for.\n", + "\n", + "In addition to the above evaluations, the callback handler will also run the following evaluation:\n", + "- **Sub Query Completeness**: Checks if the sub-questions accurately and completely cover the original query." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated 3 sub questions.\n", + "\u001b[1;3;38;2;237;90;200m[documents] Q: What did Paul Graham work on before YC?\n", + "\u001b[0m\u001b[1;3;38;2;90;149;237m[documents] Q: What did Paul Graham work on during YC?\n", + "\u001b[0m\u001b[1;3;38;2;11;159;203m[documents] Q: What did Paul Graham work on after YC?\n", + "\u001b[0m\u001b[1;3;38;2;237;90;200m[documents] A: Before Y Combinator (YC), Paul Graham worked on a startup called Viaweb.\n", + "\u001b[0m\u001b[1;3;38;2;11;159;203m[documents] A: After leaving Y Combinator, Paul Graham focused on painting. He wanted to see how good he could get at painting if he dedicated his time and effort to it. He spent most of 2014 working on his painting skills, but eventually ran out of steam in November.\n", + "\u001b[0m\u001b[1;3;38;2;90;149;237m[documents] A: During his time at Y Combinator (YC), Paul Graham worked on various projects. He initially intended to work on three things: hacking, writing essays, and working on YC. However, as YC grew and he became more excited about it, it started to take up a lot more of his attention. He also worked on writing essays and was responsible for writing all of YC's internal software in Arc.\n", + "\u001b[0m" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2024-02-14 08:24:08.958\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m110\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n", + "\u001b[32m2024-02-14 08:24:34.450\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m110\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Question: What did Paul Graham work on before YC?\n", + "Response: Before Y Combinator (YC), Paul Graham worked on a startup called Viaweb.\n", + "Context Relevance Score: 0.0\n", + "Factual Accuracy Score: 1.0\n", + "Response Completeness Score: 0.5\n", + "\n", + "\n", + "Question: What did Paul Graham work on after YC?\n", + "Response: After leaving Y Combinator, Paul Graham focused on painting. He wanted to see how good he could get at painting if he dedicated his time and effort to it. He spent most of 2014 working on his painting skills, but eventually ran out of steam in November.\n", + "Context Relevance Score: 1.0\n", + "Factual Accuracy Score: 0.0\n", + "Response Completeness Score: 0.0\n", + "\n", + "\n", + "Question: What did Paul Graham work on during YC?\n", + "Response: During his time at Y Combinator (YC), Paul Graham worked on various projects. He initially intended to work on three things: hacking, writing essays, and working on YC. However, as YC grew and he became more excited about it, it started to take up a lot more of his attention. He also worked on writing essays and was responsible for writing all of YC's internal software in Arc.\n", + "Context Relevance Score: 0.5\n", + "Factual Accuracy Score: 1.0\n", + "Response Completeness Score: 0.5\n", + "\n", + "\n", + "Question: How was Paul Grahams life different before, during, and after YC?\n", + "Sub Query Completeness Score: 1.0\n", + "\n" + ] + } + ], + "source": [ + "# build index and query engine\n", + "vector_query_engine = VectorStoreIndex.from_documents(\n", + " documents=documents,\n", + " use_async=True,\n", + ").as_query_engine()\n", + "\n", + "query_engine_tools = [\n", + " QueryEngineTool(\n", + " query_engine=vector_query_engine,\n", + " metadata=ToolMetadata(\n", + " name=\"documents\",\n", + " description=\"Paul Graham essay on What I Worked On\",\n", + " ),\n", + " ),\n", + "]\n", + "\n", + "query_engine = SubQuestionQueryEngine.from_defaults(\n", + " query_engine_tools=query_engine_tools,\n", + " use_async=True,\n", + ")\n", + "\n", + "response = query_engine.query(\n", + " \"How was Paul Grahams life different before, during, and after YC?\"\n", + ")" + ] + }, + { + "attachments": { + "image.png": { + "image/png": "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" + } + }, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's an example of the dashboard visualizing the scores of the sub-questions in the form of a bar chart:\n", + "\n", + "![image.png](attachment:image.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3. Re-ranking \n", + "\n", + "Re-ranking is the process of reordering the nodes based on their relevance to the query. There are multiple classes of re-ranking algorithms offered by Llamaindex. We have used CohereRerank for this example.\n", + "\n", + "The re-ranker allows you to enter the number of top n nodes that will be returned after re-ranking. If this value remains the same as the original number of nodes, the re-ranker will only re-rank the nodes and not change the number of nodes. Otherwise, it will re-rank the nodes and return the top n nodes.\n", + "\n", + "We will perform different evaluations based on the number of nodes returned after re-ranking." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3a. Re-ranking (With same number of nodes)\n", + "\n", + "If the number of nodes returned after re-ranking is the same as the original number of nodes, the following evaluation will be performed:\n", + "- **Context Reranking**: Check if the order of the re-ranked nodes is more relevant to the query than the original order." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2024-02-13 20:00:17.459\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m110\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Question: What did Sam Altman do in this essay?\n", + "Context Relevance Score: 1.0\n", + "Factual Accuracy Score: 1.0\n", + "Response Completeness Score: 1.0\n", + "\n" + ] + } + ], + "source": [ + "os.environ[\"OPENAI_API_KEY\"] = \"sk-...\" # Replace with your OpenAI API key\n", + "llm = OpenAI(model=\"gpt-4-turbo-preview\")\n", + "\n", + "cohere_rerank = LLMRerank(\n", + " llm=llm, top_n=5\n", + ") # In this example, the number of nodes before re-ranking is 5 and after re-ranking is also 5.\n", + "\n", + "index = VectorStoreIndex.from_documents(\n", + " documents=documents,\n", + ")\n", + "\n", + "query_engine = index.as_query_engine(\n", + " similarity_top_k=10,\n", + " node_postprocessors=[cohere_rerank],\n", + ")\n", + "\n", + "response = query_engine.query(\n", + " \"What did Sam Altman do in this essay?\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3b. Re-ranking (With different number of nodes)\n", + "\n", + "If the number of nodes returned after re-ranking is the lesser as the original number of nodes, the following evaluation will be performed:\n", + "- **Context Conciseness**: If the re-ranked nodes are able to provide all the information required by the query." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[32m2024-02-13 20:01:39.343\u001b[0m | \u001b[1mINFO \u001b[0m | \u001b[36muptrain.framework.evalllm\u001b[0m:\u001b[36mevaluate\u001b[0m:\u001b[36m110\u001b[0m - \u001b[1mSending evaluation request for rows 0 to <50 to the Uptrain\u001b[0m\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Question: What did Sam Altman do in this essay?\n", + "Context Relevance Score: 0.5\n", + "Factual Accuracy Score: 1.0\n", + "Response Completeness Score: 1.0\n", + "\n" + ] + } + ], + "source": [ + "os.environ[\"OPENAI_API_KEY\"] = \"sk-...\" # Replace with your OpenAI API key\n", + "llm = OpenAI(model=\"gpt-4-turbo-preview\")\n", + "\n", + "cohere_rerank = LLMRerank(\n", + " llm=llm, top_n=2\n", + ") # In this example, the number of nodes before re-ranking is 5 and after re-ranking is 2.\n", + "\n", + "index = VectorStoreIndex.from_documents(\n", + " documents=documents,\n", + ")\n", + "query_engine = index.as_query_engine(\n", + " similarity_top_k=10,\n", + " node_postprocessors=[cohere_rerank],\n", + ")\n", + "\n", + "# Use your advanced RAG\n", + "response = query_engine.query(\n", + " \"What did Sam Altman do in this essay?\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# UpTrain's Managed Service Dashboard and Insights\n", + "\n", + "The UpTrain Managed Service offers the following features:\n", + "\n", + "1. Advanced dashboards with drill-down and filtering options.\n", + "1. Identification of insights and common themes among unsuccessful cases.\n", + "1. Real-time observability and monitoring of production data.\n", + "1. Integration with CI/CD pipelines for seamless regression testing.\n", + "\n", + "To define the UpTrain callback handler, the only change required is to set the `key_type` and `api_key` parameters. The rest of the code remains the same.\n", + "\n", + "```python\n", + "callback_handler = UpTrainCallbackHandler(\n", + " key_type=\"uptrain\",\n", + " api_key=\"up-******************************\",\n", + " project_name_prefix=\"llama\",\n", + ")\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's a short GIF showcasing the dashboard and the insights that you can get from the UpTrain managed service:\n", + "\n", + "![output.gif](https://uptrain-assets.s3.ap-south-1.amazonaws.com/images/llamaindex/output.gif)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "phoenixdev", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/evaluation/UpTrain.ipynb b/docs/examples/evaluation/UpTrain.ipynb index 285bc8a5cbb749..6cb85c2340c9ed 100644 --- a/docs/examples/evaluation/UpTrain.ipynb +++ b/docs/examples/evaluation/UpTrain.ipynb @@ -5,7 +5,7 @@ "id": "ec212316", "metadata": {}, "source": [ - "\"Open" + "\"Open" ] }, { diff --git a/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/BUILD b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/BUILD new file mode 100644 index 00000000000000..0896ca890d8bff --- /dev/null +++ b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/BUILD @@ -0,0 +1,3 @@ +poetry_requirements( + name="poetry", +) diff --git a/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/Makefile b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/Makefile new file mode 100644 index 00000000000000..b9eab05aa37062 --- /dev/null +++ b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/Makefile @@ -0,0 +1,17 @@ +GIT_ROOT ?= $(shell git rev-parse --show-toplevel) + +help: ## Show all Makefile targets. + @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[33m%-30s\033[0m %s\n", $$1, $$2}' + +format: ## Run code autoformatters (black). + pre-commit install + git ls-files | xargs pre-commit run black --files + +lint: ## Run linters: pre-commit (black, ruff, codespell) and mypy + pre-commit install && git ls-files | xargs pre-commit run --show-diff-on-failure --files + +test: ## Run tests via pytest. + pytest tests + +watch-docs: ## Build and watch documentation. + sphinx-autobuild docs/ docs/_build/html --open-browser --watch $(GIT_ROOT)/llama_index/ diff --git a/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/README.md b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/README.md new file mode 100644 index 00000000000000..f9c12773deaa9e --- /dev/null +++ b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/README.md @@ -0,0 +1,35 @@ +# LlamaIndex Callbacks Integration: UpTrain + +UpTrain is an open-source tool to evaluate and monitor the performance of language models. It provides a set of pre-built evaluations to assess the quality of responses generated by the model. Once you add UpTrainCallbackHandler to your existing LlamaIndex pipeline, it will take care of sending the generated responses to the UpTrain Managed Service for evaluations and display the results in the output. + +Three additional evaluations for Llamaindex have been introduced, complementing existing ones. These evaluations run automatically, with results displayed in the output. More details on UpTrain's evaluations can be found [here](https://github.com/uptrain-ai/uptrain?tab=readme-ov-file#pre-built-evaluations-we-offer-). + +Selected operators from the LlamaIndex pipeline are highlighted for demonstration: + +## 1. **RAG Query Engine Evaluations**: + +The RAG query engine plays a crucial role in retrieving context and generating responses. To ensure its performance and response quality, we conduct the following evaluations: + +- **Context Relevance**: Determines if the context extracted from the query is relevant to the response. +- **Factual Accuracy**: Assesses if the LLM is hallcuinating or providing incorrect information. +- **Response Completeness**: Checks if the response contains all the information requested by the query. + +## 2. **Sub-Question Query Generation Evaluation**: + +The SubQuestionQueryGeneration operator decomposes a question into sub-questions, generating responses for each using a RAG query engine. Given the complexity, we include the previous evaluations and add: + +- **Sub Query Completeness**: Assures that the sub-questions accurately and comprehensively cover the original query. + +## 3. **Re-Ranking Evaluations**: + +Re-ranking involves reordering nodes based on relevance to the query and choosing top n nodes. Different evaluations are performed based on the number of nodes returned after re-ranking. + +a. Same Number of Nodes + +- **Context Reranking**: Checks if the order of re-ranked nodes is more relevant to the query than the original order. + +b. Different Number of Nodes: + +- **Context Conciseness**: Examines whether the reduced number of nodes still provides all the required information. + +These evaluations collectively ensure the robustness and effectiveness of the RAG query engine, SubQuestionQueryGeneration operator, and the re-ranking process in the LlamaIndex pipeline. diff --git a/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/llama_index/callbacks/uptrain/BUILD b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/llama_index/callbacks/uptrain/BUILD new file mode 100644 index 00000000000000..db46e8d6c978c6 --- /dev/null +++ b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/llama_index/callbacks/uptrain/BUILD @@ -0,0 +1 @@ +python_sources() diff --git a/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/llama_index/callbacks/uptrain/__init__.py b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/llama_index/callbacks/uptrain/__init__.py new file mode 100644 index 00000000000000..438dd5f6c5fb3e --- /dev/null +++ b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/llama_index/callbacks/uptrain/__init__.py @@ -0,0 +1,3 @@ +from llama_index.callbacks.uptrain.base import UpTrainCallbackHandler + +__all__ = ["UpTrainCallbackHandler"] diff --git a/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/llama_index/callbacks/uptrain/base.py b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/llama_index/callbacks/uptrain/base.py new file mode 100644 index 00000000000000..69ab6de8e509bc --- /dev/null +++ b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/llama_index/callbacks/uptrain/base.py @@ -0,0 +1,320 @@ +from collections import defaultdict +from typing import Any, DefaultDict, Dict, List, Literal, Optional, Set + +import nest_asyncio + +from llama_index.core.callbacks.base_handler import BaseCallbackHandler +from llama_index.core.callbacks.schema import ( + CBEvent, + CBEventType, +) + + +class UpTrainDataSchema: + """UpTrain data schema.""" + + def __init__(self, project_name_prefix: str) -> None: + """Initialize the UpTrain data schema.""" + # For tracking project name and results + self.project_name_prefix: str = project_name_prefix + self.uptrain_results: DefaultDict[str, Any] = defaultdict(list) + + # For tracking event types - reranking, sub_question + self.eval_types: Set[str] = set() + + ## SYNTHESIZE + self.question: str = "" + self.context: str = "" + self.response: str = "" + + ## RERANKING + self.old_context: List[str] = [] + self.new_context: List[str] = [] + + ## SUB_QUESTION + # Map of sub question ID to question, context, and response + self.sub_question_map: DefaultDict[str, dict] = defaultdict(dict) + # Parent ID of sub questions + self.sub_question_parent_id: str = "" + # Parent question + self.parent_question: str = "" + + +class UpTrainCallbackHandler(BaseCallbackHandler): + """ + UpTrain callback handler. + + This class is responsible for handling the UpTrain API and logging events to UpTrain. + + """ + + def __init__( + self, + api_key: str, + key_type: Literal["uptrain", "openai"], + project_name_prefix: str = "llama", + ) -> None: + """Initialize the UpTrain callback handler.""" + try: + from uptrain import APIClient, EvalLLM, Settings + except ImportError: + raise ImportError( + "UpTrainCallbackHandler requires the 'uptrain' package. " + "Please install it using 'pip install uptrain'." + ) + nest_asyncio.apply() + super().__init__( + event_starts_to_ignore=[], + event_ends_to_ignore=[], + ) + self.schema = UpTrainDataSchema(project_name_prefix=project_name_prefix) + self._event_pairs_by_id: Dict[str, List[CBEvent]] = defaultdict(list) + self._trace_map: Dict[str, List[str]] = defaultdict(list) + + # Based on whether the user enters an UpTrain API key or an OpenAI API key, the client is initialized + # If both are entered, the UpTrain API key is used + if key_type == "uptrain": + settings = Settings(uptrain_access_token=api_key) + self.uptrain_client = APIClient(settings=settings) + elif key_type == "openai": + settings = Settings(openai_api_key=api_key) + self.uptrain_client = EvalLLM(settings=settings) + else: + raise ValueError("Invalid key type: Must be 'uptrain' or 'openai'") + + def uptrain_evaluate( + self, + project_name: str, + data: List[Dict[str, str]], + checks: List[str], + ) -> None: + """Run an evaluation on the UpTrain server using UpTrain client.""" + if self.uptrain_client.__class__.__name__ == "APIClient": + uptrain_result = self.uptrain_client.log_and_evaluate( + project_name=project_name, + data=data, + checks=checks, + ) + else: + uptrain_result = self.uptrain_client.evaluate( + data=data, + checks=checks, + ) + self.schema.uptrain_results[project_name].append(uptrain_result) + + score_name_map = { + "score_context_relevance": "Context Relevance Score", + "score_factual_accuracy": "Factual Accuracy Score", + "score_response_completeness": "Response Completeness Score", + "score_sub_query_completeness": "Sub Query Completeness Score", + "score_context_reranking": "Context Reranking Score", + "score_context_conciseness": "Context Conciseness Score", + } + + # Print the results + for row in uptrain_result: + columns = list(row.keys()) + for column in columns: + if column == "question": + print(f"\nQuestion: {row[column]}") + elif column == "response": + print(f"Response: {row[column]}") + elif column.startswith("score"): + if column in score_name_map: + print(f"{score_name_map[column]}: {row[column]}") + else: + print(f"{column}: {row[column]}") + print() + + def on_event_start( + self, + event_type: CBEventType, + payload: Any = None, + event_id: str = "", + parent_id: str = "", + **kwargs: Any, + ) -> str: + """Run when an event starts and return id of event.""" + event = CBEvent(event_type, payload=payload, id_=event_id) + self._event_pairs_by_id[event.id_].append(event) + + if event_type is CBEventType.QUERY: + self.schema.question = payload["query_str"] + if event_type is CBEventType.TEMPLATING and "template_vars" in payload: + template_vars = payload["template_vars"] + self.schema.context = template_vars.get("context_str", "") + elif event_type is CBEventType.RERANKING and "nodes" in payload: + self.schema.eval_types.add("reranking") + # Store old context data + self.schema.old_context = [node.text for node in payload["nodes"]] + elif event_type is CBEventType.SUB_QUESTION: + # For the first sub question, store parent question and parent id + if "sub_question" not in self.schema.eval_types: + self.schema.parent_question = self.schema.question + self.schema.eval_types.add("sub_question") + # Store sub question data - question and parent id + self.schema.sub_question_parent_id = parent_id + return event_id + + def on_event_end( + self, + event_type: CBEventType, + payload: Any = None, + event_id: str = "", + **kwargs: Any, + ) -> None: + """Run when an event ends.""" + try: + from uptrain import Evals + except ImportError: + raise ImportError( + "UpTrainCallbackHandler requires the 'uptrain' package. " + "Please install it using 'pip install uptrain'." + ) + event = CBEvent(event_type, payload=payload, id_=event_id) + self._event_pairs_by_id[event.id_].append(event) + self._trace_map = defaultdict(list) + if event_id == self.schema.sub_question_parent_id: + # Perform individual evaluations for sub questions (but send all sub questions at once) + self.uptrain_evaluate( + project_name=f"{self.schema.project_name_prefix}_sub_question_answering", + data=list(self.schema.sub_question_map.values()), + checks=[ + Evals.CONTEXT_RELEVANCE, + Evals.FACTUAL_ACCURACY, + Evals.RESPONSE_COMPLETENESS, + ], + ) + # Perform evaluation for question and all sub questions (as a whole) + sub_questions = [ + sub_question["question"] + for sub_question in self.schema.sub_question_map.values() + ] + sub_questions_formatted = "\n".join( + [ + f"{index}. {string}" + for index, string in enumerate(sub_questions, start=1) + ] + ) + self.uptrain_evaluate( + project_name=f"{self.schema.project_name_prefix}_sub_query_completeness", + data=[ + { + "question": self.schema.parent_question, + "sub_questions": sub_questions_formatted, + } + ], + checks=[Evals.SUB_QUERY_COMPLETENESS], + ) + # Should not be called for sub questions + if ( + event_type is CBEventType.SYNTHESIZE + and "sub_question" not in self.schema.eval_types + ): + self.schema.response = payload["response"].response + # Perform evaluation for synthesization + self.uptrain_evaluate( + project_name=f"{self.schema.project_name_prefix}_question_answering", + data=[ + { + "question": self.schema.question, + "context": self.schema.context, + "response": self.schema.response, + } + ], + checks=[ + Evals.CONTEXT_RELEVANCE, + Evals.FACTUAL_ACCURACY, + Evals.RESPONSE_COMPLETENESS, + ], + ) + + elif event_type is CBEventType.RERANKING: + # Store new context data + self.schema.new_context = [node.text for node in payload["nodes"]] + if len(self.schema.old_context) == len(self.schema.new_context): + context = "\n".join( + [ + f"{index}. {string}" + for index, string in enumerate(self.schema.old_context, start=1) + ] + ) + reranked_context = "\n".join( + [ + f"{index}. {string}" + for index, string in enumerate(self.schema.new_context, start=1) + ] + ) + # Perform evaluation for reranking + self.uptrain_evaluate( + project_name=f"{self.schema.project_name_prefix}_context_reranking", + data=[ + { + "question": self.schema.question, + "context": context, + "reranked_context": reranked_context, + } + ], + checks=[ + Evals.CONTEXT_RERANKING, + ], + ) + else: + context = "\n".join(self.schema.old_context) + concise_context = "\n".join(self.schema.new_context) + # Perform evaluation for resizing + self.uptrain_evaluate( + project_name=f"{self.schema.project_name_prefix}_context_conciseness", + data=[ + { + "question": self.schema.question, + "context": context, + "concise_context": concise_context, + } + ], + checks=[ + Evals.CONTEXT_CONCISENESS, + ], + ) + elif event_type is CBEventType.SUB_QUESTION: + # Store sub question data + self.schema.sub_question_map[event_id]["question"] = payload[ + "sub_question" + ].sub_q.sub_question + self.schema.sub_question_map[event_id]["context"] = ( + payload["sub_question"].sources[0].node.text + ) + self.schema.sub_question_map[event_id]["response"] = payload[ + "sub_question" + ].answer + + def start_trace(self, trace_id: Optional[str] = None) -> None: + self._trace_map = defaultdict(list) + return super().start_trace(trace_id) + + def end_trace( + self, + trace_id: Optional[str] = None, + trace_map: Optional[Dict[str, List[str]]] = None, + ) -> None: + self._trace_map = trace_map or defaultdict(list) + return super().end_trace(trace_id, trace_map) + + def build_trace_map( + self, + cur_event_id: str, + trace_map: Any, + ) -> Dict[str, Any]: + event_pair = self._event_pairs_by_id[cur_event_id] + if event_pair: + event_data = { + "event_type": event_pair[0].event_type, + "event_id": event_pair[0].id_, + "children": {}, + } + trace_map[cur_event_id] = event_data + + child_event_ids = self._trace_map[cur_event_id] + for child_event_id in child_event_ids: + self.build_trace_map(child_event_id, event_data["children"]) + return trace_map diff --git a/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/poetry.lock b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/poetry.lock new file mode 100644 index 00000000000000..64f1cf4b053cc4 --- /dev/null +++ b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/poetry.lock @@ -0,0 +1,4595 @@ +# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand. + +[[package]] +name = "aiohttp" +version = "3.9.3" +description = "Async http client/server framework (asyncio)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "aiohttp-3.9.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:939677b61f9d72a4fa2a042a5eee2a99a24001a67c13da113b2e30396567db54"}, + {file = "aiohttp-3.9.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1f5cd333fcf7590a18334c90f8c9147c837a6ec8a178e88d90a9b96ea03194cc"}, + {file = "aiohttp-3.9.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:82e6aa28dd46374f72093eda8bcd142f7771ee1eb9d1e223ff0fa7177a96b4a5"}, + {file = "aiohttp-3.9.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f56455b0c2c7cc3b0c584815264461d07b177f903a04481dfc33e08a89f0c26b"}, + {file = "aiohttp-3.9.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bca77a198bb6e69795ef2f09a5f4c12758487f83f33d63acde5f0d4919815768"}, + {file = "aiohttp-3.9.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e083c285857b78ee21a96ba1eb1b5339733c3563f72980728ca2b08b53826ca5"}, + {file = "aiohttp-3.9.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab40e6251c3873d86ea9b30a1ac6d7478c09277b32e14745d0d3c6e76e3c7e29"}, + {file = "aiohttp-3.9.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:df822ee7feaaeffb99c1a9e5e608800bd8eda6e5f18f5cfb0dc7eeb2eaa6bbec"}, + {file = "aiohttp-3.9.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:acef0899fea7492145d2bbaaaec7b345c87753168589cc7faf0afec9afe9b747"}, + {file = "aiohttp-3.9.3-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:cd73265a9e5ea618014802ab01babf1940cecb90c9762d8b9e7d2cc1e1969ec6"}, + {file = "aiohttp-3.9.3-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:a78ed8a53a1221393d9637c01870248a6f4ea5b214a59a92a36f18151739452c"}, + {file = "aiohttp-3.9.3-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:6b0e029353361f1746bac2e4cc19b32f972ec03f0f943b390c4ab3371840aabf"}, + {file = "aiohttp-3.9.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:7cf5c9458e1e90e3c390c2639f1017a0379a99a94fdfad3a1fd966a2874bba52"}, + {file = "aiohttp-3.9.3-cp310-cp310-win32.whl", hash = "sha256:3e59c23c52765951b69ec45ddbbc9403a8761ee6f57253250c6e1536cacc758b"}, + {file = "aiohttp-3.9.3-cp310-cp310-win_amd64.whl", hash = "sha256:055ce4f74b82551678291473f66dc9fb9048a50d8324278751926ff0ae7715e5"}, + {file = "aiohttp-3.9.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6b88f9386ff1ad91ace19d2a1c0225896e28815ee09fc6a8932fded8cda97c3d"}, + {file = "aiohttp-3.9.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c46956ed82961e31557b6857a5ca153c67e5476972e5f7190015018760938da2"}, + {file = "aiohttp-3.9.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:07b837ef0d2f252f96009e9b8435ec1fef68ef8b1461933253d318748ec1acdc"}, + {file = "aiohttp-3.9.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad46e6f620574b3b4801c68255492e0159d1712271cc99d8bdf35f2043ec266"}, + {file = "aiohttp-3.9.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ed3e046ea7b14938112ccd53d91c1539af3e6679b222f9469981e3dac7ba1ce"}, + {file = "aiohttp-3.9.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:039df344b45ae0b34ac885ab5b53940b174530d4dd8a14ed8b0e2155b9dddccb"}, + {file = "aiohttp-3.9.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7943c414d3a8d9235f5f15c22ace69787c140c80b718dcd57caaade95f7cd93b"}, + {file = "aiohttp-3.9.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:84871a243359bb42c12728f04d181a389718710129b36b6aad0fc4655a7647d4"}, + {file = "aiohttp-3.9.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5eafe2c065df5401ba06821b9a054d9cb2848867f3c59801b5d07a0be3a380ae"}, + {file = "aiohttp-3.9.3-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:9d3c9b50f19704552f23b4eaea1fc082fdd82c63429a6506446cbd8737823da3"}, + {file = "aiohttp-3.9.3-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:f033d80bc6283092613882dfe40419c6a6a1527e04fc69350e87a9df02bbc283"}, + {file = "aiohttp-3.9.3-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:2c895a656dd7e061b2fd6bb77d971cc38f2afc277229ce7dd3552de8313a483e"}, + {file = "aiohttp-3.9.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1f5a71d25cd8106eab05f8704cd9167b6e5187bcdf8f090a66c6d88b634802b4"}, + {file = "aiohttp-3.9.3-cp311-cp311-win32.whl", hash = "sha256:50fca156d718f8ced687a373f9e140c1bb765ca16e3d6f4fe116e3df7c05b2c5"}, + {file = "aiohttp-3.9.3-cp311-cp311-win_amd64.whl", hash = "sha256:5fe9ce6c09668063b8447f85d43b8d1c4e5d3d7e92c63173e6180b2ac5d46dd8"}, + {file = "aiohttp-3.9.3-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:38a19bc3b686ad55804ae931012f78f7a534cce165d089a2059f658f6c91fa60"}, + {file = "aiohttp-3.9.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:770d015888c2a598b377bd2f663adfd947d78c0124cfe7b959e1ef39f5b13869"}, + {file = "aiohttp-3.9.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ee43080e75fc92bf36219926c8e6de497f9b247301bbf88c5c7593d931426679"}, + {file = "aiohttp-3.9.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:52df73f14ed99cee84865b95a3d9e044f226320a87af208f068ecc33e0c35b96"}, + {file = "aiohttp-3.9.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dc9b311743a78043b26ffaeeb9715dc360335e5517832f5a8e339f8a43581e4d"}, + {file = "aiohttp-3.9.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b955ed993491f1a5da7f92e98d5dad3c1e14dc175f74517c4e610b1f2456fb11"}, + {file = "aiohttp-3.9.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:504b6981675ace64c28bf4a05a508af5cde526e36492c98916127f5a02354d53"}, + {file = "aiohttp-3.9.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a6fe5571784af92b6bc2fda8d1925cccdf24642d49546d3144948a6a1ed58ca5"}, + {file = "aiohttp-3.9.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:ba39e9c8627edc56544c8628cc180d88605df3892beeb2b94c9bc857774848ca"}, + {file = "aiohttp-3.9.3-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:e5e46b578c0e9db71d04c4b506a2121c0cb371dd89af17a0586ff6769d4c58c1"}, + {file = "aiohttp-3.9.3-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:938a9653e1e0c592053f815f7028e41a3062e902095e5a7dc84617c87267ebd5"}, + {file = "aiohttp-3.9.3-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:c3452ea726c76e92f3b9fae4b34a151981a9ec0a4847a627c43d71a15ac32aa6"}, + {file = "aiohttp-3.9.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ff30218887e62209942f91ac1be902cc80cddb86bf00fbc6783b7a43b2bea26f"}, + {file = "aiohttp-3.9.3-cp312-cp312-win32.whl", hash = "sha256:38f307b41e0bea3294a9a2a87833191e4bcf89bb0365e83a8be3a58b31fb7f38"}, + {file = "aiohttp-3.9.3-cp312-cp312-win_amd64.whl", hash = "sha256:b791a3143681a520c0a17e26ae7465f1b6f99461a28019d1a2f425236e6eedb5"}, + {file = "aiohttp-3.9.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:0ed621426d961df79aa3b963ac7af0d40392956ffa9be022024cd16297b30c8c"}, + {file = "aiohttp-3.9.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7f46acd6a194287b7e41e87957bfe2ad1ad88318d447caf5b090012f2c5bb528"}, + {file = "aiohttp-3.9.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:feeb18a801aacb098220e2c3eea59a512362eb408d4afd0c242044c33ad6d542"}, + {file = "aiohttp-3.9.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f734e38fd8666f53da904c52a23ce517f1b07722118d750405af7e4123933511"}, + {file = "aiohttp-3.9.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b40670ec7e2156d8e57f70aec34a7216407848dfe6c693ef131ddf6e76feb672"}, + {file = "aiohttp-3.9.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fdd215b7b7fd4a53994f238d0f46b7ba4ac4c0adb12452beee724ddd0743ae5d"}, + {file = "aiohttp-3.9.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:017a21b0df49039c8f46ca0971b3a7fdc1f56741ab1240cb90ca408049766168"}, + {file = "aiohttp-3.9.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e99abf0bba688259a496f966211c49a514e65afa9b3073a1fcee08856e04425b"}, + {file = "aiohttp-3.9.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:648056db9a9fa565d3fa851880f99f45e3f9a771dd3ff3bb0c048ea83fb28194"}, + {file = "aiohttp-3.9.3-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:8aacb477dc26797ee089721536a292a664846489c49d3ef9725f992449eda5a8"}, + {file = "aiohttp-3.9.3-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:522a11c934ea660ff8953eda090dcd2154d367dec1ae3c540aff9f8a5c109ab4"}, + {file = "aiohttp-3.9.3-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:5bce0dc147ca85caa5d33debc4f4d65e8e8b5c97c7f9f660f215fa74fc49a321"}, + {file = "aiohttp-3.9.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:4b4af9f25b49a7be47c0972139e59ec0e8285c371049df1a63b6ca81fdd216a2"}, + {file = "aiohttp-3.9.3-cp38-cp38-win32.whl", hash = "sha256:298abd678033b8571995650ccee753d9458dfa0377be4dba91e4491da3f2be63"}, + {file = "aiohttp-3.9.3-cp38-cp38-win_amd64.whl", hash = "sha256:69361bfdca5468c0488d7017b9b1e5ce769d40b46a9f4a2eed26b78619e9396c"}, + {file = "aiohttp-3.9.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:0fa43c32d1643f518491d9d3a730f85f5bbaedcbd7fbcae27435bb8b7a061b29"}, + {file = "aiohttp-3.9.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:835a55b7ca49468aaaac0b217092dfdff370e6c215c9224c52f30daaa735c1c1"}, + {file = "aiohttp-3.9.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:06a9b2c8837d9a94fae16c6223acc14b4dfdff216ab9b7202e07a9a09541168f"}, + {file = "aiohttp-3.9.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:abf151955990d23f84205286938796c55ff11bbfb4ccfada8c9c83ae6b3c89a3"}, + {file = "aiohttp-3.9.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:59c26c95975f26e662ca78fdf543d4eeaef70e533a672b4113dd888bd2423caa"}, + {file = "aiohttp-3.9.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f95511dd5d0e05fd9728bac4096319f80615aaef4acbecb35a990afebe953b0e"}, + {file = "aiohttp-3.9.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:595f105710293e76b9dc09f52e0dd896bd064a79346234b521f6b968ffdd8e58"}, + {file = "aiohttp-3.9.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7c8b816c2b5af5c8a436df44ca08258fc1a13b449393a91484225fcb7545533"}, + {file = "aiohttp-3.9.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f1088fa100bf46e7b398ffd9904f4808a0612e1d966b4aa43baa535d1b6341eb"}, + {file = "aiohttp-3.9.3-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f59dfe57bb1ec82ac0698ebfcdb7bcd0e99c255bd637ff613760d5f33e7c81b3"}, + {file = "aiohttp-3.9.3-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:361a1026c9dd4aba0109e4040e2aecf9884f5cfe1b1b1bd3d09419c205e2e53d"}, + {file = "aiohttp-3.9.3-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:363afe77cfcbe3a36353d8ea133e904b108feea505aa4792dad6585a8192c55a"}, + {file = "aiohttp-3.9.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8e2c45c208c62e955e8256949eb225bd8b66a4c9b6865729a786f2aa79b72e9d"}, + {file = "aiohttp-3.9.3-cp39-cp39-win32.whl", hash = "sha256:f7217af2e14da0856e082e96ff637f14ae45c10a5714b63c77f26d8884cf1051"}, + {file = "aiohttp-3.9.3-cp39-cp39-win_amd64.whl", hash = "sha256:27468897f628c627230dba07ec65dc8d0db566923c48f29e084ce382119802bc"}, + {file = "aiohttp-3.9.3.tar.gz", hash = "sha256:90842933e5d1ff760fae6caca4b2b3edba53ba8f4b71e95dacf2818a2aca06f7"}, +] + +[package.dependencies] +aiosignal = ">=1.1.2" +async-timeout = {version = ">=4.0,<5.0", markers = "python_version < \"3.11\""} +attrs = ">=17.3.0" +frozenlist = ">=1.1.1" +multidict = ">=4.5,<7.0" +yarl = ">=1.0,<2.0" + +[package.extras] +speedups = ["Brotli", "aiodns", "brotlicffi"] + +[[package]] +name = "aiosignal" +version = "1.3.1" +description = "aiosignal: a list of registered asynchronous callbacks" +optional = false +python-versions = ">=3.7" +files = [ + {file = "aiosignal-1.3.1-py3-none-any.whl", hash = "sha256:f8376fb07dd1e86a584e4fcdec80b36b7f81aac666ebc724e2c090300dd83b17"}, + {file = "aiosignal-1.3.1.tar.gz", hash = "sha256:54cd96e15e1649b75d6c87526a6ff0b6c1b0dd3459f43d9ca11d48c339b68cfc"}, +] + +[package.dependencies] +frozenlist = ">=1.1.0" + +[[package]] +name = "anyio" +version = "4.2.0" +description = "High level compatibility layer for multiple asynchronous event loop implementations" +optional = false +python-versions = ">=3.8" +files = [ + {file = "anyio-4.2.0-py3-none-any.whl", hash = "sha256:745843b39e829e108e518c489b31dc757de7d2131d53fac32bd8df268227bfee"}, + {file = "anyio-4.2.0.tar.gz", hash = "sha256:e1875bb4b4e2de1669f4bc7869b6d3f54231cdced71605e6e64c9be77e3be50f"}, +] + +[package.dependencies] +exceptiongroup = {version = ">=1.0.2", markers = "python_version < \"3.11\""} +idna = ">=2.8" +sniffio = ">=1.1" +typing-extensions = {version = ">=4.1", markers = "python_version < \"3.11\""} + +[package.extras] +doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)", "sphinx-rtd-theme"] +test = ["anyio[trio]", "coverage[toml] (>=7)", "exceptiongroup (>=1.2.0)", "hypothesis (>=4.0)", "psutil (>=5.9)", "pytest (>=7.0)", "pytest-mock (>=3.6.1)", "trustme", "uvloop (>=0.17)"] +trio = ["trio (>=0.23)"] + +[[package]] +name = "appnope" +version = "0.1.4" +description = "Disable App Nap on macOS >= 10.9" +optional = false +python-versions = ">=3.6" +files = [ + {file = "appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c"}, + {file = "appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee"}, +] + +[[package]] +name = "argon2-cffi" +version = "23.1.0" +description = "Argon2 for Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "argon2_cffi-23.1.0-py3-none-any.whl", hash = "sha256:c670642b78ba29641818ab2e68bd4e6a78ba53b7eff7b4c3815ae16abf91c7ea"}, + {file = "argon2_cffi-23.1.0.tar.gz", hash = "sha256:879c3e79a2729ce768ebb7d36d4609e3a78a4ca2ec3a9f12286ca057e3d0db08"}, +] + +[package.dependencies] +argon2-cffi-bindings = "*" + +[package.extras] +dev = ["argon2-cffi[tests,typing]", "tox (>4)"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-copybutton", "sphinx-notfound-page"] +tests = ["hypothesis", "pytest"] +typing = ["mypy"] + +[[package]] +name = "argon2-cffi-bindings" +version = "21.2.0" +description = "Low-level CFFI bindings for Argon2" +optional = false +python-versions = ">=3.6" +files = [ + {file = "argon2-cffi-bindings-21.2.0.tar.gz", hash = "sha256:bb89ceffa6c791807d1305ceb77dbfacc5aa499891d2c55661c6459651fc39e3"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ccb949252cb2ab3a08c02024acb77cfb179492d5701c7cbdbfd776124d4d2367"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9524464572e12979364b7d600abf96181d3541da11e23ddf565a32e70bd4dc0d"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b746dba803a79238e925d9046a63aa26bf86ab2a2fe74ce6b009a1c3f5c8f2ae"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:58ed19212051f49a523abb1dbe954337dc82d947fb6e5a0da60f7c8471a8476c"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:bd46088725ef7f58b5a1ef7ca06647ebaf0eb4baff7d1d0d177c6cc8744abd86"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_i686.whl", hash = "sha256:8cd69c07dd875537a824deec19f978e0f2078fdda07fd5c42ac29668dda5f40f"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:f1152ac548bd5b8bcecfb0b0371f082037e47128653df2e8ba6e914d384f3c3e"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win32.whl", hash = "sha256:603ca0aba86b1349b147cab91ae970c63118a0f30444d4bc80355937c950c082"}, + {file = "argon2_cffi_bindings-21.2.0-cp36-abi3-win_amd64.whl", hash = "sha256:b2ef1c30440dbbcba7a5dc3e319408b59676e2e039e2ae11a8775ecf482b192f"}, + {file = "argon2_cffi_bindings-21.2.0-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:e415e3f62c8d124ee16018e491a009937f8cf7ebf5eb430ffc5de21b900dad93"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3e385d1c39c520c08b53d63300c3ecc28622f076f4c2b0e6d7e796e9f6502194"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c3e3cc67fdb7d82c4718f19b4e7a87123caf8a93fde7e23cf66ac0337d3cb3f"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6a22ad9800121b71099d0fb0a65323810a15f2e292f2ba450810a7316e128ee5"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f9f8b450ed0547e3d473fdc8612083fd08dd2120d6ac8f73828df9b7d45bb351"}, + {file = "argon2_cffi_bindings-21.2.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:93f9bf70084f97245ba10ee36575f0c3f1e7d7724d67d8e5b08e61787c320ed7"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3b9ef65804859d335dc6b31582cad2c5166f0c3e7975f324d9ffaa34ee7e6583"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4966ef5848d820776f5f562a7d45fdd70c2f330c961d0d745b784034bd9f48d"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ef543a89dee4db46a1a6e206cd015360e5a75822f76df533845c3cbaf72670"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed2937d286e2ad0cc79a7087d3c272832865f779430e0cc2b4f3718d3159b0cb"}, + {file = "argon2_cffi_bindings-21.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:5e00316dabdaea0b2dd82d141cc66889ced0cdcbfa599e8b471cf22c620c329a"}, +] + +[package.dependencies] +cffi = ">=1.0.1" + +[package.extras] +dev = ["cogapp", "pre-commit", "pytest", "wheel"] +tests = ["pytest"] + +[[package]] +name = "arrow" +version = "1.3.0" +description = "Better dates & times for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "arrow-1.3.0-py3-none-any.whl", hash = "sha256:c728b120ebc00eb84e01882a6f5e7927a53960aa990ce7dd2b10f39005a67f80"}, + {file = "arrow-1.3.0.tar.gz", hash = "sha256:d4540617648cb5f895730f1ad8c82a65f2dad0166f57b75f3ca54759c4d67a85"}, +] + +[package.dependencies] +python-dateutil = ">=2.7.0" +types-python-dateutil = ">=2.8.10" + +[package.extras] +doc = ["doc8", "sphinx (>=7.0.0)", "sphinx-autobuild", "sphinx-autodoc-typehints", "sphinx_rtd_theme (>=1.3.0)"] +test = ["dateparser (==1.*)", "pre-commit", "pytest", "pytest-cov", "pytest-mock", "pytz (==2021.1)", "simplejson (==3.*)"] + +[[package]] +name = "astroid" +version = "2.13.5" +description = "An abstract syntax tree for Python with inference support." +optional = false +python-versions = ">=3.7.2" +files = [ + {file = "astroid-2.13.5-py3-none-any.whl", hash = "sha256:6891f444625b6edb2ac798829b689e95297e100ddf89dbed5a8c610e34901501"}, + {file = "astroid-2.13.5.tar.gz", hash = "sha256:df164d5ac811b9f44105a72b8f9d5edfb7b5b2d7e979b04ea377a77b3229114a"}, +] + +[package.dependencies] +lazy-object-proxy = ">=1.4.0" +typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""} +wrapt = [ + {version = ">=1.11,<2", markers = "python_version < \"3.11\""}, + {version = ">=1.14,<2", markers = "python_version >= \"3.11\""}, +] + +[[package]] +name = "asttokens" +version = "2.4.1" +description = "Annotate AST trees with source code positions" +optional = false +python-versions = "*" +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[package.dependencies] +six = ">=1.12.0" + +[package.extras] +astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"] +test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"] + +[[package]] +name = "async-lru" +version = "2.0.4" +description = "Simple LRU cache for asyncio" +optional = false +python-versions = ">=3.8" +files = [ + {file = "async-lru-2.0.4.tar.gz", hash = "sha256:b8a59a5df60805ff63220b2a0c5b5393da5521b113cd5465a44eb037d81a5627"}, + {file = "async_lru-2.0.4-py3-none-any.whl", hash = "sha256:ff02944ce3c288c5be660c42dbcca0742b32c3b279d6dceda655190240b99224"}, +] + +[package.dependencies] +typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""} + +[[package]] +name = "async-timeout" +version = "4.0.3" +description = "Timeout context manager for asyncio programs" +optional = false +python-versions = ">=3.7" +files = [ + {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"}, + {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"}, +] + +[[package]] +name = "attrs" +version = "23.2.0" +description = "Classes Without Boilerplate" +optional = false +python-versions = ">=3.7" +files = [ + {file = "attrs-23.2.0-py3-none-any.whl", hash = "sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1"}, + {file = "attrs-23.2.0.tar.gz", hash = "sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30"}, +] + +[package.extras] +cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] +dev = ["attrs[tests]", "pre-commit"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] +tests = ["attrs[tests-no-zope]", "zope-interface"] +tests-mypy = ["mypy (>=1.6)", "pytest-mypy-plugins"] +tests-no-zope = ["attrs[tests-mypy]", "cloudpickle", "hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist[psutil]"] + +[[package]] +name = "babel" +version = "2.14.0" +description = "Internationalization utilities" +optional = false +python-versions = ">=3.7" +files = [ + {file = "Babel-2.14.0-py3-none-any.whl", hash = "sha256:efb1a25b7118e67ce3a259bed20545c29cb68be8ad2c784c83689981b7a57287"}, + {file = "Babel-2.14.0.tar.gz", hash = "sha256:6919867db036398ba21eb5c7a0f6b28ab8cbc3ae7a73a44ebe34ae74a4e7d363"}, +] + +[package.dependencies] +pytz = {version = ">=2015.7", markers = "python_version < \"3.9\""} + +[package.extras] +dev = ["freezegun (>=1.0,<2.0)", "pytest (>=6.0)", "pytest-cov"] + +[[package]] +name = "backcall" +version = "0.2.0" +description = "Specifications for callback functions passed in to an API" +optional = false +python-versions = "*" +files = [ + {file = "backcall-0.2.0-py2.py3-none-any.whl", hash = "sha256:fbbce6a29f263178a1f7915c1940bde0ec2b2a967566fe1c65c1dfb7422bd255"}, + {file = "backcall-0.2.0.tar.gz", hash = "sha256:5cbdbf27be5e7cfadb448baf0aa95508f91f2bbc6c6437cd9cd06e2a4c215e1e"}, +] + +[[package]] +name = "beautifulsoup4" +version = "4.12.3" +description = "Screen-scraping library" +optional = false +python-versions = ">=3.6.0" +files = [ + {file = "beautifulsoup4-4.12.3-py3-none-any.whl", hash = "sha256:b80878c9f40111313e55da8ba20bdba06d8fa3969fc68304167741bbf9e082ed"}, + {file = "beautifulsoup4-4.12.3.tar.gz", hash = "sha256:74e3d1928edc070d21748185c46e3fb33490f22f52a3addee9aee0f4f7781051"}, +] + +[package.dependencies] +soupsieve = ">1.2" + +[package.extras] +cchardet = ["cchardet"] +chardet = ["chardet"] +charset-normalizer = ["charset-normalizer"] +html5lib = ["html5lib"] +lxml = ["lxml"] + +[[package]] +name = "black" +version = "23.9.1" +description = "The uncompromising code formatter." +optional = false +python-versions = ">=3.8" +files = [ + {file = "black-23.9.1-cp310-cp310-macosx_10_16_arm64.whl", hash = "sha256:d6bc09188020c9ac2555a498949401ab35bb6bf76d4e0f8ee251694664df6301"}, + {file = "black-23.9.1-cp310-cp310-macosx_10_16_universal2.whl", hash = "sha256:13ef033794029b85dfea8032c9d3b92b42b526f1ff4bf13b2182ce4e917f5100"}, + {file = "black-23.9.1-cp310-cp310-macosx_10_16_x86_64.whl", hash = "sha256:75a2dc41b183d4872d3a500d2b9c9016e67ed95738a3624f4751a0cb4818fe71"}, + {file = "black-23.9.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13a2e4a93bb8ca74a749b6974925c27219bb3df4d42fc45e948a5d9feb5122b7"}, + {file = "black-23.9.1-cp310-cp310-win_amd64.whl", hash = "sha256:adc3e4442eef57f99b5590b245a328aad19c99552e0bdc7f0b04db6656debd80"}, + {file = "black-23.9.1-cp311-cp311-macosx_10_16_arm64.whl", hash = "sha256:8431445bf62d2a914b541da7ab3e2b4f3bc052d2ccbf157ebad18ea126efb91f"}, + {file = "black-23.9.1-cp311-cp311-macosx_10_16_universal2.whl", hash = "sha256:8fc1ddcf83f996247505db6b715294eba56ea9372e107fd54963c7553f2b6dfe"}, + {file = "black-23.9.1-cp311-cp311-macosx_10_16_x86_64.whl", hash = "sha256:7d30ec46de88091e4316b17ae58bbbfc12b2de05e069030f6b747dfc649ad186"}, + {file = "black-23.9.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:031e8c69f3d3b09e1aa471a926a1eeb0b9071f80b17689a655f7885ac9325a6f"}, + {file = "black-23.9.1-cp311-cp311-win_amd64.whl", hash = "sha256:538efb451cd50f43aba394e9ec7ad55a37598faae3348d723b59ea8e91616300"}, + {file = "black-23.9.1-cp38-cp38-macosx_10_16_arm64.whl", hash = "sha256:638619a559280de0c2aa4d76f504891c9860bb8fa214267358f0a20f27c12948"}, + {file = "black-23.9.1-cp38-cp38-macosx_10_16_universal2.whl", hash = "sha256:a732b82747235e0542c03bf352c126052c0fbc458d8a239a94701175b17d4855"}, + {file = "black-23.9.1-cp38-cp38-macosx_10_16_x86_64.whl", hash = "sha256:cf3a4d00e4cdb6734b64bf23cd4341421e8953615cba6b3670453737a72ec204"}, + {file = "black-23.9.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf99f3de8b3273a8317681d8194ea222f10e0133a24a7548c73ce44ea1679377"}, + {file = "black-23.9.1-cp38-cp38-win_amd64.whl", hash = "sha256:14f04c990259576acd093871e7e9b14918eb28f1866f91968ff5524293f9c573"}, + {file = "black-23.9.1-cp39-cp39-macosx_10_16_arm64.whl", hash = "sha256:c619f063c2d68f19b2d7270f4cf3192cb81c9ec5bc5ba02df91471d0b88c4c5c"}, + {file = "black-23.9.1-cp39-cp39-macosx_10_16_universal2.whl", hash = "sha256:6a3b50e4b93f43b34a9d3ef00d9b6728b4a722c997c99ab09102fd5efdb88325"}, + {file = "black-23.9.1-cp39-cp39-macosx_10_16_x86_64.whl", hash = "sha256:c46767e8df1b7beefb0899c4a95fb43058fa8500b6db144f4ff3ca38eb2f6393"}, + {file = "black-23.9.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:50254ebfa56aa46a9fdd5d651f9637485068a1adf42270148cd101cdf56e0ad9"}, + {file = "black-23.9.1-cp39-cp39-win_amd64.whl", hash = "sha256:403397c033adbc45c2bd41747da1f7fc7eaa44efbee256b53842470d4ac5a70f"}, + {file = "black-23.9.1-py3-none-any.whl", hash = "sha256:6ccd59584cc834b6d127628713e4b6b968e5f79572da66284532525a042549f9"}, + {file = "black-23.9.1.tar.gz", hash = "sha256:24b6b3ff5c6d9ea08a8888f6977eae858e1f340d7260cf56d70a49823236b62d"}, +] + +[package.dependencies] +click = ">=8.0.0" +ipython = {version = ">=7.8.0", optional = true, markers = "extra == \"jupyter\""} +mypy-extensions = ">=0.4.3" +packaging = ">=22.0" +pathspec = ">=0.9.0" +platformdirs = ">=2" +tokenize-rt = {version = ">=3.2.0", optional = true, markers = "extra == \"jupyter\""} +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +typing-extensions = {version = ">=4.0.1", markers = "python_version < \"3.11\""} + +[package.extras] +colorama = ["colorama (>=0.4.3)"] +d = ["aiohttp (>=3.7.4)"] +jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"] +uvloop = ["uvloop (>=0.15.2)"] + +[[package]] +name = "bleach" +version = "6.1.0" +description = "An easy safelist-based HTML-sanitizing tool." +optional = false +python-versions = ">=3.8" +files = [ + {file = "bleach-6.1.0-py3-none-any.whl", hash = "sha256:3225f354cfc436b9789c66c4ee030194bee0568fbf9cbdad3bc8b5c26c5f12b6"}, + {file = "bleach-6.1.0.tar.gz", hash = "sha256:0a31f1837963c41d46bbf1331b8778e1308ea0791db03cc4e7357b97cf42a8fe"}, +] + +[package.dependencies] +six = ">=1.9.0" +webencodings = "*" + +[package.extras] +css = ["tinycss2 (>=1.1.0,<1.3)"] + +[[package]] +name = "certifi" +version = "2024.2.2" +description = "Python package for providing Mozilla's CA Bundle." +optional = false +python-versions = ">=3.6" +files = [ + {file = "certifi-2024.2.2-py3-none-any.whl", hash = "sha256:dc383c07b76109f368f6106eee2b593b04a011ea4d55f652c6ca24a754d1cdd1"}, + {file = "certifi-2024.2.2.tar.gz", hash = "sha256:0569859f95fc761b18b45ef421b1290a0f65f147e92a1e5eb3e635f9a5e4e66f"}, +] + +[[package]] +name = "cffi" +version = "1.16.0" +description = "Foreign Function Interface for Python calling C code." +optional = false +python-versions = ">=3.8" +files = [ + {file = "cffi-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088"}, + {file = "cffi-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d"}, + {file = "cffi-1.16.0-cp310-cp310-win32.whl", hash = "sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a"}, + {file = "cffi-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb"}, + {file = "cffi-1.16.0-cp311-cp311-win32.whl", hash = "sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab"}, + {file = "cffi-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969"}, + {file = "cffi-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520"}, + {file = "cffi-1.16.0-cp312-cp312-win32.whl", hash = "sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b"}, + {file = "cffi-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235"}, + {file = "cffi-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324"}, + {file = "cffi-1.16.0-cp38-cp38-win32.whl", hash = "sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a"}, + {file = "cffi-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe"}, + {file = "cffi-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4"}, + {file = "cffi-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8"}, + {file = "cffi-1.16.0.tar.gz", hash = "sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0"}, +] + +[package.dependencies] +pycparser = "*" + +[[package]] +name = "cfgv" +version = "3.4.0" +description = "Validate configuration and produce human readable error messages." +optional = false +python-versions = ">=3.8" +files = [ + {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"}, + {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.3.2" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win32.whl", hash = "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win32.whl", hash = "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + +[[package]] +name = "click" +version = "8.1.7" +description = "Composable command line interface toolkit" +optional = false +python-versions = ">=3.7" +files = [ + {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, + {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + +[[package]] +name = "codespell" +version = "2.2.6" +description = "Codespell" +optional = false +python-versions = ">=3.8" +files = [ + {file = "codespell-2.2.6-py3-none-any.whl", hash = "sha256:9ee9a3e5df0990604013ac2a9f22fa8e57669c827124a2e961fe8a1da4cacc07"}, + {file = "codespell-2.2.6.tar.gz", hash = "sha256:a8c65d8eb3faa03deabab6b3bbe798bea72e1799c7e9e955d57eca4096abcff9"}, +] + +[package.dependencies] +tomli = {version = "*", optional = true, markers = "python_version < \"3.11\" and extra == \"toml\""} + +[package.extras] +dev = ["Pygments", "build", "chardet", "pre-commit", "pytest", "pytest-cov", "pytest-dependency", "ruff", "tomli", "twine"] +hard-encoding-detection = ["chardet"] +toml = ["tomli"] +types = ["chardet (>=5.1.0)", "mypy", "pytest", "pytest-cov", "pytest-dependency"] + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "comm" +version = "0.2.1" +description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +optional = false +python-versions = ">=3.8" +files = [ + {file = "comm-0.2.1-py3-none-any.whl", hash = "sha256:87928485c0dfc0e7976fd89fc1e187023cf587e7c353e4a9b417555b44adf021"}, + {file = "comm-0.2.1.tar.gz", hash = "sha256:0bc91edae1344d39d3661dcbc36937181fdaddb304790458f8b044dbc064b89a"}, +] + +[package.dependencies] +traitlets = ">=4" + +[package.extras] +test = ["pytest"] + +[[package]] +name = "cryptography" +version = "42.0.2" +description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers." +optional = false +python-versions = ">=3.7" +files = [ + {file = "cryptography-42.0.2-cp37-abi3-macosx_10_12_universal2.whl", hash = "sha256:701171f825dcab90969596ce2af253143b93b08f1a716d4b2a9d2db5084ef7be"}, + {file = "cryptography-42.0.2-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:61321672b3ac7aade25c40449ccedbc6db72c7f5f0fdf34def5e2f8b51ca530d"}, + {file = "cryptography-42.0.2-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea2c3ffb662fec8bbbfce5602e2c159ff097a4631d96235fcf0fb00e59e3ece4"}, + {file = "cryptography-42.0.2-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b15c678f27d66d247132cbf13df2f75255627bcc9b6a570f7d2fd08e8c081d2"}, + {file = "cryptography-42.0.2-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:8e88bb9eafbf6a4014d55fb222e7360eef53e613215085e65a13290577394529"}, + {file = "cryptography-42.0.2-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:a047682d324ba56e61b7ea7c7299d51e61fd3bca7dad2ccc39b72bd0118d60a1"}, + {file = "cryptography-42.0.2-cp37-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:36d4b7c4be6411f58f60d9ce555a73df8406d484ba12a63549c88bd64f7967f1"}, + {file = "cryptography-42.0.2-cp37-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:a00aee5d1b6c20620161984f8ab2ab69134466c51f58c052c11b076715e72929"}, + {file = "cryptography-42.0.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:b97fe7d7991c25e6a31e5d5e795986b18fbbb3107b873d5f3ae6dc9a103278e9"}, + {file = "cryptography-42.0.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5fa82a26f92871eca593b53359c12ad7949772462f887c35edaf36f87953c0e2"}, + {file = "cryptography-42.0.2-cp37-abi3-win32.whl", hash = "sha256:4b063d3413f853e056161eb0c7724822a9740ad3caa24b8424d776cebf98e7ee"}, + {file = "cryptography-42.0.2-cp37-abi3-win_amd64.whl", hash = "sha256:841ec8af7a8491ac76ec5a9522226e287187a3107e12b7d686ad354bb78facee"}, + {file = "cryptography-42.0.2-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:55d1580e2d7e17f45d19d3b12098e352f3a37fe86d380bf45846ef257054b242"}, + {file = "cryptography-42.0.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28cb2c41f131a5758d6ba6a0504150d644054fd9f3203a1e8e8d7ac3aea7f73a"}, + {file = "cryptography-42.0.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b9097a208875fc7bbeb1286d0125d90bdfed961f61f214d3f5be62cd4ed8a446"}, + {file = "cryptography-42.0.2-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:44c95c0e96b3cb628e8452ec060413a49002a247b2b9938989e23a2c8291fc90"}, + {file = "cryptography-42.0.2-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2f9f14185962e6a04ab32d1abe34eae8a9001569ee4edb64d2304bf0d65c53f3"}, + {file = "cryptography-42.0.2-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:09a77e5b2e8ca732a19a90c5bca2d124621a1edb5438c5daa2d2738bfeb02589"}, + {file = "cryptography-42.0.2-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:ad28cff53f60d99a928dfcf1e861e0b2ceb2bc1f08a074fdd601b314e1cc9e0a"}, + {file = "cryptography-42.0.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:130c0f77022b2b9c99d8cebcdd834d81705f61c68e91ddd614ce74c657f8b3ea"}, + {file = "cryptography-42.0.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:fa3dec4ba8fb6e662770b74f62f1a0c7d4e37e25b58b2bf2c1be4c95372b4a33"}, + {file = "cryptography-42.0.2-cp39-abi3-win32.whl", hash = "sha256:3dbd37e14ce795b4af61b89b037d4bc157f2cb23e676fa16932185a04dfbf635"}, + {file = "cryptography-42.0.2-cp39-abi3-win_amd64.whl", hash = "sha256:8a06641fb07d4e8f6c7dda4fc3f8871d327803ab6542e33831c7ccfdcb4d0ad6"}, + {file = "cryptography-42.0.2-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:087887e55e0b9c8724cf05361357875adb5c20dec27e5816b653492980d20380"}, + {file = "cryptography-42.0.2-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:a7ef8dd0bf2e1d0a27042b231a3baac6883cdd5557036f5e8df7139255feaac6"}, + {file = "cryptography-42.0.2-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4383b47f45b14459cab66048d384614019965ba6c1a1a141f11b5a551cace1b2"}, + {file = "cryptography-42.0.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:fbeb725c9dc799a574518109336acccaf1303c30d45c075c665c0793c2f79a7f"}, + {file = "cryptography-42.0.2-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:320948ab49883557a256eab46149df79435a22d2fefd6a66fe6946f1b9d9d008"}, + {file = "cryptography-42.0.2-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:5ef9bc3d046ce83c4bbf4c25e1e0547b9c441c01d30922d812e887dc5f125c12"}, + {file = "cryptography-42.0.2-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:52ed9ebf8ac602385126c9a2fe951db36f2cb0c2538d22971487f89d0de4065a"}, + {file = "cryptography-42.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:141e2aa5ba100d3788c0ad7919b288f89d1fe015878b9659b307c9ef867d3a65"}, + {file = "cryptography-42.0.2.tar.gz", hash = "sha256:e0ec52ba3c7f1b7d813cd52649a5b3ef1fc0d433219dc8c93827c57eab6cf888"}, +] + +[package.dependencies] +cffi = {version = ">=1.12", markers = "platform_python_implementation != \"PyPy\""} + +[package.extras] +docs = ["sphinx (>=5.3.0)", "sphinx-rtd-theme (>=1.1.1)"] +docstest = ["pyenchant (>=1.6.11)", "readme-renderer", "sphinxcontrib-spelling (>=4.0.1)"] +nox = ["nox"] +pep8test = ["check-sdist", "click", "mypy", "ruff"] +sdist = ["build"] +ssh = ["bcrypt (>=3.1.5)"] +test = ["certifi", "pretend", "pytest (>=6.2.0)", "pytest-benchmark", "pytest-cov", "pytest-xdist"] +test-randomorder = ["pytest-randomly"] + +[[package]] +name = "dataclasses-json" +version = "0.6.4" +description = "Easily serialize dataclasses to and from JSON." +optional = false +python-versions = ">=3.7,<4.0" +files = [ + {file = "dataclasses_json-0.6.4-py3-none-any.whl", hash = "sha256:f90578b8a3177f7552f4e1a6e535e84293cd5da421fcce0642d49c0d7bdf8df2"}, + {file = "dataclasses_json-0.6.4.tar.gz", hash = "sha256:73696ebf24936560cca79a2430cbc4f3dd23ac7bf46ed17f38e5e5e7657a6377"}, +] + +[package.dependencies] +marshmallow = ">=3.18.0,<4.0.0" +typing-inspect = ">=0.4.0,<1" + +[[package]] +name = "debugpy" +version = "1.8.1" +description = "An implementation of the Debug Adapter Protocol for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "debugpy-1.8.1-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:3bda0f1e943d386cc7a0e71bfa59f4137909e2ed947fb3946c506e113000f741"}, + {file = "debugpy-1.8.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dda73bf69ea479c8577a0448f8c707691152e6c4de7f0c4dec5a4bc11dee516e"}, + {file = "debugpy-1.8.1-cp310-cp310-win32.whl", hash = "sha256:3a79c6f62adef994b2dbe9fc2cc9cc3864a23575b6e387339ab739873bea53d0"}, + {file = "debugpy-1.8.1-cp310-cp310-win_amd64.whl", hash = "sha256:7eb7bd2b56ea3bedb009616d9e2f64aab8fc7000d481faec3cd26c98a964bcdd"}, + {file = "debugpy-1.8.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:016a9fcfc2c6b57f939673c874310d8581d51a0fe0858e7fac4e240c5eb743cb"}, + {file = "debugpy-1.8.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd97ed11a4c7f6d042d320ce03d83b20c3fb40da892f994bc041bbc415d7a099"}, + {file = "debugpy-1.8.1-cp311-cp311-win32.whl", hash = "sha256:0de56aba8249c28a300bdb0672a9b94785074eb82eb672db66c8144fff673146"}, + {file = "debugpy-1.8.1-cp311-cp311-win_amd64.whl", hash = "sha256:1a9fe0829c2b854757b4fd0a338d93bc17249a3bf69ecf765c61d4c522bb92a8"}, + {file = "debugpy-1.8.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:3ebb70ba1a6524d19fa7bb122f44b74170c447d5746a503e36adc244a20ac539"}, + {file = "debugpy-1.8.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a2e658a9630f27534e63922ebf655a6ab60c370f4d2fc5c02a5b19baf4410ace"}, + {file = "debugpy-1.8.1-cp312-cp312-win32.whl", hash = "sha256:caad2846e21188797a1f17fc09c31b84c7c3c23baf2516fed5b40b378515bbf0"}, + {file = "debugpy-1.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:edcc9f58ec0fd121a25bc950d4578df47428d72e1a0d66c07403b04eb93bcf98"}, + {file = "debugpy-1.8.1-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:7a3afa222f6fd3d9dfecd52729bc2e12c93e22a7491405a0ecbf9e1d32d45b39"}, + {file = "debugpy-1.8.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d915a18f0597ef685e88bb35e5d7ab968964b7befefe1aaea1eb5b2640b586c7"}, + {file = "debugpy-1.8.1-cp38-cp38-win32.whl", hash = "sha256:92116039b5500633cc8d44ecc187abe2dfa9b90f7a82bbf81d079fcdd506bae9"}, + {file = "debugpy-1.8.1-cp38-cp38-win_amd64.whl", hash = "sha256:e38beb7992b5afd9d5244e96ad5fa9135e94993b0c551ceebf3fe1a5d9beb234"}, + {file = "debugpy-1.8.1-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:bfb20cb57486c8e4793d41996652e5a6a885b4d9175dd369045dad59eaacea42"}, + {file = "debugpy-1.8.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efd3fdd3f67a7e576dd869c184c5dd71d9aaa36ded271939da352880c012e703"}, + {file = "debugpy-1.8.1-cp39-cp39-win32.whl", hash = "sha256:58911e8521ca0c785ac7a0539f1e77e0ce2df753f786188f382229278b4cdf23"}, + {file = "debugpy-1.8.1-cp39-cp39-win_amd64.whl", hash = "sha256:6df9aa9599eb05ca179fb0b810282255202a66835c6efb1d112d21ecb830ddd3"}, + {file = "debugpy-1.8.1-py2.py3-none-any.whl", hash = "sha256:28acbe2241222b87e255260c76741e1fbf04fdc3b6d094fcf57b6c6f75ce1242"}, + {file = "debugpy-1.8.1.zip", hash = "sha256:f696d6be15be87aef621917585f9bb94b1dc9e8aced570db1b8a6fc14e8f9b42"}, +] + +[[package]] +name = "decorator" +version = "5.1.1" +description = "Decorators for Humans" +optional = false +python-versions = ">=3.5" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "defusedxml" +version = "0.7.1" +description = "XML bomb protection for Python stdlib modules" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, + {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, +] + +[[package]] +name = "deprecated" +version = "1.2.14" +description = "Python @deprecated decorator to deprecate old python classes, functions or methods." +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "Deprecated-1.2.14-py2.py3-none-any.whl", hash = "sha256:6fac8b097794a90302bdbb17b9b815e732d3c4720583ff1b198499d78470466c"}, + {file = "Deprecated-1.2.14.tar.gz", hash = "sha256:e5323eb936458dccc2582dc6f9c322c852a775a27065ff2b0c4970b9d53d01b3"}, +] + +[package.dependencies] +wrapt = ">=1.10,<2" + +[package.extras] +dev = ["PyTest", "PyTest-Cov", "bump2version (<1)", "sphinx (<2)", "tox"] + +[[package]] +name = "dill" +version = "0.3.8" +description = "serialize all of Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "dill-0.3.8-py3-none-any.whl", hash = "sha256:c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7"}, + {file = "dill-0.3.8.tar.gz", hash = "sha256:3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca"}, +] + +[package.extras] +graph = ["objgraph (>=1.7.2)"] +profile = ["gprof2dot (>=2022.7.29)"] + +[[package]] +name = "dirtyjson" +version = "1.0.8" +description = "JSON decoder for Python that can extract data from the muck" +optional = false +python-versions = "*" +files = [ + {file = "dirtyjson-1.0.8-py3-none-any.whl", hash = "sha256:125e27248435a58acace26d5c2c4c11a1c0de0a9c5124c5a94ba78e517d74f53"}, + {file = "dirtyjson-1.0.8.tar.gz", hash = "sha256:90ca4a18f3ff30ce849d100dcf4a003953c79d3a2348ef056f1d9c22231a25fd"}, +] + +[[package]] +name = "distlib" +version = "0.3.8" +description = "Distribution utilities" +optional = false +python-versions = "*" +files = [ + {file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"}, + {file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"}, +] + +[[package]] +name = "distro" +version = "1.9.0" +description = "Distro - an OS platform information API" +optional = false +python-versions = ">=3.6" +files = [ + {file = "distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2"}, + {file = "distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed"}, +] + +[[package]] +name = "exceptiongroup" +version = "1.2.0" +description = "Backport of PEP 654 (exception groups)" +optional = false +python-versions = ">=3.7" +files = [ + {file = "exceptiongroup-1.2.0-py3-none-any.whl", hash = "sha256:4bfd3996ac73b41e9b9628b04e079f193850720ea5945fc96a08633c66912f14"}, + {file = "exceptiongroup-1.2.0.tar.gz", hash = "sha256:91f5c769735f051a4290d52edd0858999b57e5876e9f85937691bd4c9fa3ed68"}, +] + +[package.extras] +test = ["pytest (>=6)"] + +[[package]] +name = "executing" +version = "2.0.1" +description = "Get the currently executing AST node of a frame, and other information" +optional = false +python-versions = ">=3.5" +files = [ + {file = "executing-2.0.1-py2.py3-none-any.whl", hash = "sha256:eac49ca94516ccc753f9fb5ce82603156e590b27525a8bc32cce8ae302eb61bc"}, + {file = "executing-2.0.1.tar.gz", hash = "sha256:35afe2ce3affba8ee97f2d69927fa823b08b472b7b994e36a52a964b93d16147"}, +] + +[package.extras] +tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"] + +[[package]] +name = "fastjsonschema" +version = "2.19.1" +description = "Fastest Python implementation of JSON schema" +optional = false +python-versions = "*" +files = [ + {file = "fastjsonschema-2.19.1-py3-none-any.whl", hash = "sha256:3672b47bc94178c9f23dbb654bf47440155d4db9df5f7bc47643315f9c405cd0"}, + {file = "fastjsonschema-2.19.1.tar.gz", hash = "sha256:e3126a94bdc4623d3de4485f8d468a12f02a67921315ddc87836d6e456dc789d"}, +] + +[package.extras] +devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"] + +[[package]] +name = "filelock" +version = "3.13.1" +description = "A platform independent file lock." +optional = false +python-versions = ">=3.8" +files = [ + {file = "filelock-3.13.1-py3-none-any.whl", hash = "sha256:57dbda9b35157b05fb3e58ee91448612eb674172fab98ee235ccb0b5bee19a1c"}, + {file = "filelock-3.13.1.tar.gz", hash = "sha256:521f5f56c50f8426f5e03ad3b281b490a87ef15bc6c526f168290f0c7148d44e"}, +] + +[package.extras] +docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.24)"] +testing = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "diff-cover (>=8)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)", "pytest-timeout (>=2.2)"] +typing = ["typing-extensions (>=4.8)"] + +[[package]] +name = "fqdn" +version = "1.5.1" +description = "Validates fully-qualified domain names against RFC 1123, so that they are acceptable to modern bowsers" +optional = false +python-versions = ">=2.7, !=3.0, !=3.1, !=3.2, !=3.3, !=3.4, <4" +files = [ + {file = "fqdn-1.5.1-py3-none-any.whl", hash = "sha256:3a179af3761e4df6eb2e026ff9e1a3033d3587bf980a0b1b2e1e5d08d7358014"}, + {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, +] + +[[package]] +name = "frozenlist" +version = "1.4.1" +description = "A list-like structure which implements collections.abc.MutableSequence" +optional = false +python-versions = ">=3.8" +files = [ + {file = "frozenlist-1.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f9aa1878d1083b276b0196f2dfbe00c9b7e752475ed3b682025ff20c1c1f51ac"}, + {file = "frozenlist-1.4.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:29acab3f66f0f24674b7dc4736477bcd4bc3ad4b896f5f45379a67bce8b96868"}, + {file = "frozenlist-1.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:74fb4bee6880b529a0c6560885fce4dc95936920f9f20f53d99a213f7bf66776"}, + {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:590344787a90ae57d62511dd7c736ed56b428f04cd8c161fcc5e7232c130c69a"}, + {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:068b63f23b17df8569b7fdca5517edef76171cf3897eb68beb01341131fbd2ad"}, + {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5c849d495bf5154cd8da18a9eb15db127d4dba2968d88831aff6f0331ea9bd4c"}, + {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9750cc7fe1ae3b1611bb8cfc3f9ec11d532244235d75901fb6b8e42ce9229dfe"}, + {file = "frozenlist-1.4.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9b2de4cf0cdd5bd2dee4c4f63a653c61d2408055ab77b151c1957f221cabf2a"}, + {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0633c8d5337cb5c77acbccc6357ac49a1770b8c487e5b3505c57b949b4b82e98"}, + {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:27657df69e8801be6c3638054e202a135c7f299267f1a55ed3a598934f6c0d75"}, + {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:f9a3ea26252bd92f570600098783d1371354d89d5f6b7dfd87359d669f2109b5"}, + {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:4f57dab5fe3407b6c0c1cc907ac98e8a189f9e418f3b6e54d65a718aaafe3950"}, + {file = "frozenlist-1.4.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e02a0e11cf6597299b9f3bbd3f93d79217cb90cfd1411aec33848b13f5c656cc"}, + {file = "frozenlist-1.4.1-cp310-cp310-win32.whl", hash = "sha256:a828c57f00f729620a442881cc60e57cfcec6842ba38e1b19fd3e47ac0ff8dc1"}, + {file = "frozenlist-1.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:f56e2333dda1fe0f909e7cc59f021eba0d2307bc6f012a1ccf2beca6ba362439"}, + {file = "frozenlist-1.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a0cb6f11204443f27a1628b0e460f37fb30f624be6051d490fa7d7e26d4af3d0"}, + {file = "frozenlist-1.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b46c8ae3a8f1f41a0d2ef350c0b6e65822d80772fe46b653ab6b6274f61d4a49"}, + {file = "frozenlist-1.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fde5bd59ab5357e3853313127f4d3565fc7dad314a74d7b5d43c22c6a5ed2ced"}, + {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:722e1124aec435320ae01ee3ac7bec11a5d47f25d0ed6328f2273d287bc3abb0"}, + {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2471c201b70d58a0f0c1f91261542a03d9a5e088ed3dc6c160d614c01649c106"}, + {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c757a9dd70d72b076d6f68efdbb9bc943665ae954dad2801b874c8c69e185068"}, + {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f146e0911cb2f1da549fc58fc7bcd2b836a44b79ef871980d605ec392ff6b0d2"}, + {file = "frozenlist-1.4.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f9c515e7914626b2a2e1e311794b4c35720a0be87af52b79ff8e1429fc25f19"}, + {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c302220494f5c1ebeb0912ea782bcd5e2f8308037b3c7553fad0e48ebad6ad82"}, + {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:442acde1e068288a4ba7acfe05f5f343e19fac87bfc96d89eb886b0363e977ec"}, + {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:1b280e6507ea8a4fa0c0a7150b4e526a8d113989e28eaaef946cc77ffd7efc0a"}, + {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:fe1a06da377e3a1062ae5fe0926e12b84eceb8a50b350ddca72dc85015873f74"}, + {file = "frozenlist-1.4.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:db9e724bebd621d9beca794f2a4ff1d26eed5965b004a97f1f1685a173b869c2"}, + {file = "frozenlist-1.4.1-cp311-cp311-win32.whl", hash = "sha256:e774d53b1a477a67838a904131c4b0eef6b3d8a651f8b138b04f748fccfefe17"}, + {file = "frozenlist-1.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:fb3c2db03683b5767dedb5769b8a40ebb47d6f7f45b1b3e3b4b51ec8ad9d9825"}, + {file = "frozenlist-1.4.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:1979bc0aeb89b33b588c51c54ab0161791149f2461ea7c7c946d95d5f93b56ae"}, + {file = "frozenlist-1.4.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cc7b01b3754ea68a62bd77ce6020afaffb44a590c2289089289363472d13aedb"}, + {file = "frozenlist-1.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c9c92be9fd329ac801cc420e08452b70e7aeab94ea4233a4804f0915c14eba9b"}, + {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5c3894db91f5a489fc8fa6a9991820f368f0b3cbdb9cd8849547ccfab3392d86"}, + {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ba60bb19387e13597fb059f32cd4d59445d7b18b69a745b8f8e5db0346f33480"}, + {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8aefbba5f69d42246543407ed2461db31006b0f76c4e32dfd6f42215a2c41d09"}, + {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:780d3a35680ced9ce682fbcf4cb9c2bad3136eeff760ab33707b71db84664e3a"}, + {file = "frozenlist-1.4.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9acbb16f06fe7f52f441bb6f413ebae6c37baa6ef9edd49cdd567216da8600cd"}, + {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:23b701e65c7b36e4bf15546a89279bd4d8675faabc287d06bbcfac7d3c33e1e6"}, + {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:3e0153a805a98f5ada7e09826255ba99fb4f7524bb81bf6b47fb702666484ae1"}, + {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:dd9b1baec094d91bf36ec729445f7769d0d0cf6b64d04d86e45baf89e2b9059b"}, + {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:1a4471094e146b6790f61b98616ab8e44f72661879cc63fa1049d13ef711e71e"}, + {file = "frozenlist-1.4.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5667ed53d68d91920defdf4035d1cdaa3c3121dc0b113255124bcfada1cfa1b8"}, + {file = "frozenlist-1.4.1-cp312-cp312-win32.whl", hash = "sha256:beee944ae828747fd7cb216a70f120767fc9f4f00bacae8543c14a6831673f89"}, + {file = "frozenlist-1.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:64536573d0a2cb6e625cf309984e2d873979709f2cf22839bf2d61790b448ad5"}, + {file = "frozenlist-1.4.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:20b51fa3f588ff2fe658663db52a41a4f7aa6c04f6201449c6c7c476bd255c0d"}, + {file = "frozenlist-1.4.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:410478a0c562d1a5bcc2f7ea448359fcb050ed48b3c6f6f4f18c313a9bdb1826"}, + {file = "frozenlist-1.4.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c6321c9efe29975232da3bd0af0ad216800a47e93d763ce64f291917a381b8eb"}, + {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:48f6a4533887e189dae092f1cf981f2e3885175f7a0f33c91fb5b7b682b6bab6"}, + {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6eb73fa5426ea69ee0e012fb59cdc76a15b1283d6e32e4f8dc4482ec67d1194d"}, + {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fbeb989b5cc29e8daf7f976b421c220f1b8c731cbf22b9130d8815418ea45887"}, + {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:32453c1de775c889eb4e22f1197fe3bdfe457d16476ea407472b9442e6295f7a"}, + {file = "frozenlist-1.4.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693945278a31f2086d9bf3df0fe8254bbeaef1fe71e1351c3bd730aa7d31c41b"}, + {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:1d0ce09d36d53bbbe566fe296965b23b961764c0bcf3ce2fa45f463745c04701"}, + {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:3a670dc61eb0d0eb7080890c13de3066790f9049b47b0de04007090807c776b0"}, + {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:dca69045298ce5c11fd539682cff879cc1e664c245d1c64da929813e54241d11"}, + {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:a06339f38e9ed3a64e4c4e43aec7f59084033647f908e4259d279a52d3757d09"}, + {file = "frozenlist-1.4.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b7f2f9f912dca3934c1baec2e4585a674ef16fe00218d833856408c48d5beee7"}, + {file = "frozenlist-1.4.1-cp38-cp38-win32.whl", hash = "sha256:e7004be74cbb7d9f34553a5ce5fb08be14fb33bc86f332fb71cbe5216362a497"}, + {file = "frozenlist-1.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:5a7d70357e7cee13f470c7883a063aae5fe209a493c57d86eb7f5a6f910fae09"}, + {file = "frozenlist-1.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:bfa4a17e17ce9abf47a74ae02f32d014c5e9404b6d9ac7f729e01562bbee601e"}, + {file = "frozenlist-1.4.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b7e3ed87d4138356775346e6845cccbe66cd9e207f3cd11d2f0b9fd13681359d"}, + {file = "frozenlist-1.4.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c99169d4ff810155ca50b4da3b075cbde79752443117d89429595c2e8e37fed8"}, + {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:edb678da49d9f72c9f6c609fbe41a5dfb9a9282f9e6a2253d5a91e0fc382d7c0"}, + {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6db4667b187a6742b33afbbaf05a7bc551ffcf1ced0000a571aedbb4aa42fc7b"}, + {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55fdc093b5a3cb41d420884cdaf37a1e74c3c37a31f46e66286d9145d2063bd0"}, + {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:82e8211d69a4f4bc360ea22cd6555f8e61a1bd211d1d5d39d3d228b48c83a897"}, + {file = "frozenlist-1.4.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89aa2c2eeb20957be2d950b85974b30a01a762f3308cd02bb15e1ad632e22dc7"}, + {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9d3e0c25a2350080e9319724dede4f31f43a6c9779be48021a7f4ebde8b2d742"}, + {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:7268252af60904bf52c26173cbadc3a071cece75f873705419c8681f24d3edea"}, + {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:0c250a29735d4f15321007fb02865f0e6b6a41a6b88f1f523ca1596ab5f50bd5"}, + {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:96ec70beabbd3b10e8bfe52616a13561e58fe84c0101dd031dc78f250d5128b9"}, + {file = "frozenlist-1.4.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:23b2d7679b73fe0e5a4560b672a39f98dfc6f60df63823b0a9970525325b95f6"}, + {file = "frozenlist-1.4.1-cp39-cp39-win32.whl", hash = "sha256:a7496bfe1da7fb1a4e1cc23bb67c58fab69311cc7d32b5a99c2007b4b2a0e932"}, + {file = "frozenlist-1.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:e6a20a581f9ce92d389a8c7d7c3dd47c81fd5d6e655c8dddf341e14aa48659d0"}, + {file = "frozenlist-1.4.1-py3-none-any.whl", hash = "sha256:04ced3e6a46b4cfffe20f9ae482818e34eba9b5fb0ce4056e4cc9b6e212d09b7"}, + {file = "frozenlist-1.4.1.tar.gz", hash = "sha256:c037a86e8513059a2613aaba4d817bb90b9d9b6b69aace3ce9c877e8c8ed402b"}, +] + +[[package]] +name = "fsspec" +version = "2024.2.0" +description = "File-system specification" +optional = false +python-versions = ">=3.8" +files = [ + {file = "fsspec-2024.2.0-py3-none-any.whl", hash = "sha256:817f969556fa5916bc682e02ca2045f96ff7f586d45110fcb76022063ad2c7d8"}, + {file = "fsspec-2024.2.0.tar.gz", hash = "sha256:b6ad1a679f760dda52b1168c859d01b7b80648ea6f7f7c7f5a8a91dc3f3ecb84"}, +] + +[package.extras] +abfs = ["adlfs"] +adl = ["adlfs"] +arrow = ["pyarrow (>=1)"] +dask = ["dask", "distributed"] +devel = ["pytest", "pytest-cov"] +dropbox = ["dropbox", "dropboxdrivefs", "requests"] +full = ["adlfs", "aiohttp (!=4.0.0a0,!=4.0.0a1)", "dask", "distributed", "dropbox", "dropboxdrivefs", "fusepy", "gcsfs", "libarchive-c", "ocifs", "panel", "paramiko", "pyarrow (>=1)", "pygit2", "requests", "s3fs", "smbprotocol", "tqdm"] +fuse = ["fusepy"] +gcs = ["gcsfs"] +git = ["pygit2"] +github = ["requests"] +gs = ["gcsfs"] +gui = ["panel"] +hdfs = ["pyarrow (>=1)"] +http = ["aiohttp (!=4.0.0a0,!=4.0.0a1)"] +libarchive = ["libarchive-c"] +oci = ["ocifs"] +s3 = ["s3fs"] +sftp = ["paramiko"] +smb = ["smbprotocol"] +ssh = ["paramiko"] +tqdm = ["tqdm"] + +[[package]] +name = "greenlet" +version = "3.0.3" +description = "Lightweight in-process concurrent programming" +optional = false +python-versions = ">=3.7" +files = [ + {file = "greenlet-3.0.3-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:9da2bd29ed9e4f15955dd1595ad7bc9320308a3b766ef7f837e23ad4b4aac31a"}, + {file = "greenlet-3.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d353cadd6083fdb056bb46ed07e4340b0869c305c8ca54ef9da3421acbdf6881"}, + {file = "greenlet-3.0.3-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dca1e2f3ca00b84a396bc1bce13dd21f680f035314d2379c4160c98153b2059b"}, + {file = "greenlet-3.0.3-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3ed7fb269f15dc662787f4119ec300ad0702fa1b19d2135a37c2c4de6fadfd4a"}, + {file = "greenlet-3.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd4f49ae60e10adbc94b45c0b5e6a179acc1736cf7a90160b404076ee283cf83"}, + {file = "greenlet-3.0.3-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:73a411ef564e0e097dbe7e866bb2dda0f027e072b04da387282b02c308807405"}, + {file = "greenlet-3.0.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:7f362975f2d179f9e26928c5b517524e89dd48530a0202570d55ad6ca5d8a56f"}, + {file = "greenlet-3.0.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:649dde7de1a5eceb258f9cb00bdf50e978c9db1b996964cd80703614c86495eb"}, + {file = "greenlet-3.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:68834da854554926fbedd38c76e60c4a2e3198c6fbed520b106a8986445caaf9"}, + {file = "greenlet-3.0.3-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:b1b5667cced97081bf57b8fa1d6bfca67814b0afd38208d52538316e9422fc61"}, + {file = "greenlet-3.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:52f59dd9c96ad2fc0d5724107444f76eb20aaccb675bf825df6435acb7703559"}, + {file = "greenlet-3.0.3-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:afaff6cf5200befd5cec055b07d1c0a5a06c040fe5ad148abcd11ba6ab9b114e"}, + {file = "greenlet-3.0.3-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fe754d231288e1e64323cfad462fcee8f0288654c10bdf4f603a39ed923bef33"}, + {file = "greenlet-3.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2797aa5aedac23af156bbb5a6aa2cd3427ada2972c828244eb7d1b9255846379"}, + {file = "greenlet-3.0.3-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7f009caad047246ed379e1c4dbcb8b020f0a390667ea74d2387be2998f58a22"}, + {file = "greenlet-3.0.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c5e1536de2aad7bf62e27baf79225d0d64360d4168cf2e6becb91baf1ed074f3"}, + {file = "greenlet-3.0.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:894393ce10ceac937e56ec00bb71c4c2f8209ad516e96033e4b3b1de270e200d"}, + {file = "greenlet-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:1ea188d4f49089fc6fb283845ab18a2518d279c7cd9da1065d7a84e991748728"}, + {file = "greenlet-3.0.3-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:70fb482fdf2c707765ab5f0b6655e9cfcf3780d8d87355a063547b41177599be"}, + {file = "greenlet-3.0.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4d1ac74f5c0c0524e4a24335350edad7e5f03b9532da7ea4d3c54d527784f2e"}, + {file = "greenlet-3.0.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:149e94a2dd82d19838fe4b2259f1b6b9957d5ba1b25640d2380bea9c5df37676"}, + {file = "greenlet-3.0.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:15d79dd26056573940fcb8c7413d84118086f2ec1a8acdfa854631084393efcc"}, + {file = "greenlet-3.0.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:881b7db1ebff4ba09aaaeae6aa491daeb226c8150fc20e836ad00041bcb11230"}, + {file = "greenlet-3.0.3-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fcd2469d6a2cf298f198f0487e0a5b1a47a42ca0fa4dfd1b6862c999f018ebbf"}, + {file = "greenlet-3.0.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1f672519db1796ca0d8753f9e78ec02355e862d0998193038c7073045899f305"}, + {file = "greenlet-3.0.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2516a9957eed41dd8f1ec0c604f1cdc86758b587d964668b5b196a9db5bfcde6"}, + {file = "greenlet-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:bba5387a6975598857d86de9eac14210a49d554a77eb8261cc68b7d082f78ce2"}, + {file = "greenlet-3.0.3-cp37-cp37m-macosx_11_0_universal2.whl", hash = "sha256:5b51e85cb5ceda94e79d019ed36b35386e8c37d22f07d6a751cb659b180d5274"}, + {file = "greenlet-3.0.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:daf3cb43b7cf2ba96d614252ce1684c1bccee6b2183a01328c98d36fcd7d5cb0"}, + {file = "greenlet-3.0.3-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:99bf650dc5d69546e076f413a87481ee1d2d09aaaaaca058c9251b6d8c14783f"}, + {file = "greenlet-3.0.3-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2dd6e660effd852586b6a8478a1d244b8dc90ab5b1321751d2ea15deb49ed414"}, + {file = "greenlet-3.0.3-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e3391d1e16e2a5a1507d83e4a8b100f4ee626e8eca43cf2cadb543de69827c4c"}, + {file = "greenlet-3.0.3-cp37-cp37m-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e1f145462f1fa6e4a4ae3c0f782e580ce44d57c8f2c7aae1b6fa88c0b2efdb41"}, + {file = "greenlet-3.0.3-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:1a7191e42732df52cb5f39d3527217e7ab73cae2cb3694d241e18f53d84ea9a7"}, + {file = "greenlet-3.0.3-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:0448abc479fab28b00cb472d278828b3ccca164531daab4e970a0458786055d6"}, + {file = "greenlet-3.0.3-cp37-cp37m-win32.whl", hash = "sha256:b542be2440edc2d48547b5923c408cbe0fc94afb9f18741faa6ae970dbcb9b6d"}, + {file = "greenlet-3.0.3-cp37-cp37m-win_amd64.whl", hash = "sha256:01bc7ea167cf943b4c802068e178bbf70ae2e8c080467070d01bfa02f337ee67"}, + {file = "greenlet-3.0.3-cp38-cp38-macosx_11_0_universal2.whl", hash = "sha256:1996cb9306c8595335bb157d133daf5cf9f693ef413e7673cb07e3e5871379ca"}, + {file = "greenlet-3.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ddc0f794e6ad661e321caa8d2f0a55ce01213c74722587256fb6566049a8b04"}, + {file = "greenlet-3.0.3-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c9db1c18f0eaad2f804728c67d6c610778456e3e1cc4ab4bbd5eeb8e6053c6fc"}, + {file = "greenlet-3.0.3-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7170375bcc99f1a2fbd9c306f5be8764eaf3ac6b5cb968862cad4c7057756506"}, + {file = "greenlet-3.0.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6b66c9c1e7ccabad3a7d037b2bcb740122a7b17a53734b7d72a344ce39882a1b"}, + {file = "greenlet-3.0.3-cp38-cp38-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:098d86f528c855ead3479afe84b49242e174ed262456c342d70fc7f972bc13c4"}, + {file = "greenlet-3.0.3-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:81bb9c6d52e8321f09c3d165b2a78c680506d9af285bfccbad9fb7ad5a5da3e5"}, + {file = "greenlet-3.0.3-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:fd096eb7ffef17c456cfa587523c5f92321ae02427ff955bebe9e3c63bc9f0da"}, + {file = "greenlet-3.0.3-cp38-cp38-win32.whl", hash = "sha256:d46677c85c5ba00a9cb6f7a00b2bfa6f812192d2c9f7d9c4f6a55b60216712f3"}, + {file = "greenlet-3.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:419b386f84949bf0e7c73e6032e3457b82a787c1ab4a0e43732898a761cc9dbf"}, + {file = "greenlet-3.0.3-cp39-cp39-macosx_11_0_universal2.whl", hash = "sha256:da70d4d51c8b306bb7a031d5cff6cc25ad253affe89b70352af5f1cb68e74b53"}, + {file = "greenlet-3.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:086152f8fbc5955df88382e8a75984e2bb1c892ad2e3c80a2508954e52295257"}, + {file = "greenlet-3.0.3-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d73a9fe764d77f87f8ec26a0c85144d6a951a6c438dfe50487df5595c6373eac"}, + {file = "greenlet-3.0.3-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7dcbe92cc99f08c8dd11f930de4d99ef756c3591a5377d1d9cd7dd5e896da71"}, + {file = "greenlet-3.0.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1551a8195c0d4a68fac7a4325efac0d541b48def35feb49d803674ac32582f61"}, + {file = "greenlet-3.0.3-cp39-cp39-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:64d7675ad83578e3fc149b617a444fab8efdafc9385471f868eb5ff83e446b8b"}, + {file = "greenlet-3.0.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b37eef18ea55f2ffd8f00ff8fe7c8d3818abd3e25fb73fae2ca3b672e333a7a6"}, + {file = "greenlet-3.0.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:77457465d89b8263bca14759d7c1684df840b6811b2499838cc5b040a8b5b113"}, + {file = "greenlet-3.0.3-cp39-cp39-win32.whl", hash = "sha256:57e8974f23e47dac22b83436bdcf23080ade568ce77df33159e019d161ce1d1e"}, + {file = "greenlet-3.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:c5ee858cfe08f34712f548c3c363e807e7186f03ad7a5039ebadb29e8c6be067"}, + {file = "greenlet-3.0.3.tar.gz", hash = "sha256:43374442353259554ce33599da8b692d5aa96f8976d567d4badf263371fbe491"}, +] + +[package.extras] +docs = ["Sphinx", "furo"] +test = ["objgraph", "psutil"] + +[[package]] +name = "h11" +version = "0.14.0" +description = "A pure-Python, bring-your-own-I/O implementation of HTTP/1.1" +optional = false +python-versions = ">=3.7" +files = [ + {file = "h11-0.14.0-py3-none-any.whl", hash = "sha256:e3fe4ac4b851c468cc8363d500db52c2ead036020723024a109d37346efaa761"}, + {file = "h11-0.14.0.tar.gz", hash = "sha256:8f19fbbe99e72420ff35c00b27a34cb9937e902a8b810e2c88300c6f0a3b699d"}, +] + +[[package]] +name = "httpcore" +version = "1.0.2" +description = "A minimal low-level HTTP client." +optional = false +python-versions = ">=3.8" +files = [ + {file = "httpcore-1.0.2-py3-none-any.whl", hash = "sha256:096cc05bca73b8e459a1fc3dcf585148f63e534eae4339559c9b8a8d6399acc7"}, + {file = "httpcore-1.0.2.tar.gz", hash = "sha256:9fc092e4799b26174648e54b74ed5f683132a464e95643b226e00c2ed2fa6535"}, +] + +[package.dependencies] +certifi = "*" +h11 = ">=0.13,<0.15" + +[package.extras] +asyncio = ["anyio (>=4.0,<5.0)"] +http2 = ["h2 (>=3,<5)"] +socks = ["socksio (==1.*)"] +trio = ["trio (>=0.22.0,<0.23.0)"] + +[[package]] +name = "httpx" +version = "0.26.0" +description = "The next generation HTTP client." +optional = false +python-versions = ">=3.8" +files = [ + {file = "httpx-0.26.0-py3-none-any.whl", hash = "sha256:8915f5a3627c4d47b73e8202457cb28f1266982d1159bd5779d86a80c0eab1cd"}, + {file = "httpx-0.26.0.tar.gz", hash = "sha256:451b55c30d5185ea6b23c2c793abf9bb237d2a7dfb901ced6ff69ad37ec1dfaf"}, +] + +[package.dependencies] +anyio = "*" +certifi = "*" +httpcore = "==1.*" +idna = "*" +sniffio = "*" + +[package.extras] +brotli = ["brotli", "brotlicffi"] +cli = ["click (==8.*)", "pygments (==2.*)", "rich (>=10,<14)"] +http2 = ["h2 (>=3,<5)"] +socks = ["socksio (==1.*)"] + +[[package]] +name = "identify" +version = "2.5.34" +description = "File identification library for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "identify-2.5.34-py2.py3-none-any.whl", hash = "sha256:a4316013779e433d08b96e5eabb7f641e6c7942e4ab5d4c509ebd2e7a8994aed"}, + {file = "identify-2.5.34.tar.gz", hash = "sha256:ee17bc9d499899bc9eaec1ac7bf2dc9eedd480db9d88b96d123d3b64a9d34f5d"}, +] + +[package.extras] +license = ["ukkonen"] + +[[package]] +name = "idna" +version = "3.6" +description = "Internationalized Domain Names in Applications (IDNA)" +optional = false +python-versions = ">=3.5" +files = [ + {file = "idna-3.6-py3-none-any.whl", hash = "sha256:c05567e9c24a6b9faaa835c4821bad0590fbb9d5779e7caa6e1cc4978e7eb24f"}, + {file = "idna-3.6.tar.gz", hash = "sha256:9ecdbbd083b06798ae1e86adcbfe8ab1479cf864e4ee30fe4e46a003d12491ca"}, +] + +[[package]] +name = "importlib-metadata" +version = "7.0.1" +description = "Read metadata from Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "importlib_metadata-7.0.1-py3-none-any.whl", hash = "sha256:4805911c3a4ec7c3966410053e9ec6a1fecd629117df5adee56dfc9432a1081e"}, + {file = "importlib_metadata-7.0.1.tar.gz", hash = "sha256:f238736bb06590ae52ac1fab06a3a9ef1d8dce2b7a35b5ab329371d6c8f5d2cc"}, +] + +[package.dependencies] +zipp = ">=0.5" + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"] +perf = ["ipython"] +testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-perf (>=0.9.2)", "pytest-ruff"] + +[[package]] +name = "importlib-resources" +version = "6.1.1" +description = "Read resources from Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "importlib_resources-6.1.1-py3-none-any.whl", hash = "sha256:e8bf90d8213b486f428c9c39714b920041cb02c184686a3dee24905aaa8105d6"}, + {file = "importlib_resources-6.1.1.tar.gz", hash = "sha256:3893a00122eafde6894c59914446a512f728a0c1a45f9bb9b63721b6bacf0b4a"}, +] + +[package.dependencies] +zipp = {version = ">=3.1.0", markers = "python_version < \"3.10\""} + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-ruff", "zipp (>=3.17)"] + +[[package]] +name = "iniconfig" +version = "2.0.0" +description = "brain-dead simple config-ini parsing" +optional = false +python-versions = ">=3.7" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "ipykernel" +version = "6.29.2" +description = "IPython Kernel for Jupyter" +optional = false +python-versions = ">=3.8" +files = [ + {file = "ipykernel-6.29.2-py3-none-any.whl", hash = "sha256:50384f5c577a260a1d53f1f59a828c7266d321c9b7d00d345693783f66616055"}, + {file = "ipykernel-6.29.2.tar.gz", hash = "sha256:3bade28004e3ff624ed57974948116670604ac5f676d12339693f3142176d3f0"}, +] + +[package.dependencies] +appnope = {version = "*", markers = "platform_system == \"Darwin\""} +comm = ">=0.1.1" +debugpy = ">=1.6.5" +ipython = ">=7.23.1" +jupyter-client = ">=6.1.12" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +matplotlib-inline = ">=0.1" +nest-asyncio = "*" +packaging = "*" +psutil = "*" +pyzmq = ">=24" +tornado = ">=6.1" +traitlets = ">=5.4.0" + +[package.extras] +cov = ["coverage[toml]", "curio", "matplotlib", "pytest-cov", "trio"] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "trio"] +pyqt5 = ["pyqt5"] +pyside6 = ["pyside6"] +test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (==0.23.4)", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "ipython" +version = "8.10.0" +description = "IPython: Productive Interactive Computing" +optional = false +python-versions = ">=3.8" +files = [ + {file = "ipython-8.10.0-py3-none-any.whl", hash = "sha256:b38c31e8fc7eff642fc7c597061fff462537cf2314e3225a19c906b7b0d8a345"}, + {file = "ipython-8.10.0.tar.gz", hash = "sha256:b13a1d6c1f5818bd388db53b7107d17454129a70de2b87481d555daede5eb49e"}, +] + +[package.dependencies] +appnope = {version = "*", markers = "sys_platform == \"darwin\""} +backcall = "*" +colorama = {version = "*", markers = "sys_platform == \"win32\""} +decorator = "*" +jedi = ">=0.16" +matplotlib-inline = "*" +pexpect = {version = ">4.3", markers = "sys_platform != \"win32\""} +pickleshare = "*" +prompt-toolkit = ">=3.0.30,<3.1.0" +pygments = ">=2.4.0" +stack-data = "*" +traitlets = ">=5" + +[package.extras] +all = ["black", "curio", "docrepr", "ipykernel", "ipyparallel", "ipywidgets", "matplotlib", "matplotlib (!=3.2.0)", "nbconvert", "nbformat", "notebook", "numpy (>=1.21)", "pandas", "pytest (<7)", "pytest (<7.1)", "pytest-asyncio", "qtconsole", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "trio", "typing-extensions"] +black = ["black"] +doc = ["docrepr", "ipykernel", "matplotlib", "pytest (<7)", "pytest (<7.1)", "pytest-asyncio", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "typing-extensions"] +kernel = ["ipykernel"] +nbconvert = ["nbconvert"] +nbformat = ["nbformat"] +notebook = ["ipywidgets", "notebook"] +parallel = ["ipyparallel"] +qtconsole = ["qtconsole"] +test = ["pytest (<7.1)", "pytest-asyncio", "testpath"] +test-extra = ["curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.21)", "pandas", "pytest (<7.1)", "pytest-asyncio", "testpath", "trio"] + +[[package]] +name = "ipywidgets" +version = "8.1.2" +description = "Jupyter interactive widgets" +optional = false +python-versions = ">=3.7" +files = [ + {file = "ipywidgets-8.1.2-py3-none-any.whl", hash = "sha256:bbe43850d79fb5e906b14801d6c01402857996864d1e5b6fa62dd2ee35559f60"}, + {file = "ipywidgets-8.1.2.tar.gz", hash = "sha256:d0b9b41e49bae926a866e613a39b0f0097745d2b9f1f3dd406641b4a57ec42c9"}, +] + +[package.dependencies] +comm = ">=0.1.3" +ipython = ">=6.1.0" +jupyterlab-widgets = ">=3.0.10,<3.1.0" +traitlets = ">=4.3.1" +widgetsnbextension = ">=4.0.10,<4.1.0" + +[package.extras] +test = ["ipykernel", "jsonschema", "pytest (>=3.6.0)", "pytest-cov", "pytz"] + +[[package]] +name = "isoduration" +version = "20.11.0" +description = "Operations with ISO 8601 durations" +optional = false +python-versions = ">=3.7" +files = [ + {file = "isoduration-20.11.0-py3-none-any.whl", hash = "sha256:b2904c2a4228c3d44f409c8ae8e2370eb21a26f7ac2ec5446df141dde3452042"}, + {file = "isoduration-20.11.0.tar.gz", hash = "sha256:ac2f9015137935279eac671f94f89eb00584f940f5dc49462a0c4ee692ba1bd9"}, +] + +[package.dependencies] +arrow = ">=0.15.0" + +[[package]] +name = "isort" +version = "5.13.2" +description = "A Python utility / library to sort Python imports." +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "isort-5.13.2-py3-none-any.whl", hash = "sha256:8ca5e72a8d85860d5a3fa69b8745237f2939afe12dbf656afbcb47fe72d947a6"}, + {file = "isort-5.13.2.tar.gz", hash = "sha256:48fdfcb9face5d58a4f6dde2e72a1fb8dcaf8ab26f95ab49fab84c2ddefb0109"}, +] + +[package.extras] +colors = ["colorama (>=0.4.6)"] + +[[package]] +name = "jedi" +version = "0.19.1" +description = "An autocompletion tool for Python that can be used for text editors." +optional = false +python-versions = ">=3.6" +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[package.dependencies] +parso = ">=0.8.3,<0.9.0" + +[package.extras] +docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alabaster (==0.7.12)", "babel (==2.9.1)", "chardet (==4.0.0)", "commonmark (==0.8.1)", "docutils (==0.17.1)", "future (==0.18.2)", "idna (==2.10)", "imagesize (==1.2.0)", "mock (==1.0.1)", "packaging (==20.9)", "pyparsing (==2.4.7)", "pytz (==2021.1)", "readthedocs-sphinx-ext (==2.1.4)", "recommonmark (==0.5.0)", "requests (==2.25.1)", "six (==1.15.0)", "snowballstemmer (==2.1.0)", "sphinx (==1.8.5)", "sphinx-rtd-theme (==0.4.3)", "sphinxcontrib-serializinghtml (==1.1.4)", "sphinxcontrib-websupport (==1.2.4)", "urllib3 (==1.26.4)"] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["Django", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] + +[[package]] +name = "jinja2" +version = "3.1.3" +description = "A very fast and expressive template engine." +optional = false +python-versions = ">=3.7" +files = [ + {file = "Jinja2-3.1.3-py3-none-any.whl", hash = "sha256:7d6d50dd97d52cbc355597bd845fabfbac3f551e1f99619e39a35ce8c370b5fa"}, + {file = "Jinja2-3.1.3.tar.gz", hash = "sha256:ac8bd6544d4bb2c9792bf3a159e80bba8fda7f07e81bc3aed565432d5925ba90"}, +] + +[package.dependencies] +MarkupSafe = ">=2.0" + +[package.extras] +i18n = ["Babel (>=2.7)"] + +[[package]] +name = "joblib" +version = "1.3.2" +description = "Lightweight pipelining with Python functions" +optional = false +python-versions = ">=3.7" +files = [ + {file = "joblib-1.3.2-py3-none-any.whl", hash = "sha256:ef4331c65f239985f3f2220ecc87db222f08fd22097a3dd5698f693875f8cbb9"}, + {file = "joblib-1.3.2.tar.gz", hash = "sha256:92f865e621e17784e7955080b6d042489e3b8e294949cc44c6eac304f59772b1"}, +] + +[[package]] +name = "json5" +version = "0.9.14" +description = "A Python implementation of the JSON5 data format." +optional = false +python-versions = "*" +files = [ + {file = "json5-0.9.14-py2.py3-none-any.whl", hash = "sha256:740c7f1b9e584a468dbb2939d8d458db3427f2c93ae2139d05f47e453eae964f"}, + {file = "json5-0.9.14.tar.gz", hash = "sha256:9ed66c3a6ca3510a976a9ef9b8c0787de24802724ab1860bc0153c7fdd589b02"}, +] + +[package.extras] +dev = ["hypothesis"] + +[[package]] +name = "jsonpointer" +version = "2.4" +description = "Identify specific nodes in a JSON document (RFC 6901)" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*" +files = [ + {file = "jsonpointer-2.4-py2.py3-none-any.whl", hash = "sha256:15d51bba20eea3165644553647711d150376234112651b4f1811022aecad7d7a"}, + {file = "jsonpointer-2.4.tar.gz", hash = "sha256:585cee82b70211fa9e6043b7bb89db6e1aa49524340dde8ad6b63206ea689d88"}, +] + +[[package]] +name = "jsonschema" +version = "4.21.1" +description = "An implementation of JSON Schema validation for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema-4.21.1-py3-none-any.whl", hash = "sha256:7996507afae316306f9e2290407761157c6f78002dcf7419acb99822143d1c6f"}, + {file = "jsonschema-4.21.1.tar.gz", hash = "sha256:85727c00279f5fa6bedbe6238d2aa6403bedd8b4864ab11207d07df3cc1b2ee5"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +fqdn = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +idna = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +importlib-resources = {version = ">=1.4.0", markers = "python_version < \"3.9\""} +isoduration = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +jsonpointer = {version = ">1.13", optional = true, markers = "extra == \"format-nongpl\""} +jsonschema-specifications = ">=2023.03.6" +pkgutil-resolve-name = {version = ">=1.3.10", markers = "python_version < \"3.9\""} +referencing = ">=0.28.4" +rfc3339-validator = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +rfc3986-validator = {version = ">0.1.0", optional = true, markers = "extra == \"format-nongpl\""} +rpds-py = ">=0.7.1" +uri-template = {version = "*", optional = true, markers = "extra == \"format-nongpl\""} +webcolors = {version = ">=1.11", optional = true, markers = "extra == \"format-nongpl\""} + +[package.extras] +format = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3987", "uri-template", "webcolors (>=1.11)"] +format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339-validator", "rfc3986-validator (>0.1.0)", "uri-template", "webcolors (>=1.11)"] + +[[package]] +name = "jsonschema-specifications" +version = "2023.12.1" +description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jsonschema_specifications-2023.12.1-py3-none-any.whl", hash = "sha256:87e4fdf3a94858b8a2ba2778d9ba57d8a9cafca7c7489c46ba0d30a8bc6a9c3c"}, + {file = "jsonschema_specifications-2023.12.1.tar.gz", hash = "sha256:48a76787b3e70f5ed53f1160d2b81f586e4ca6d1548c5de7085d1682674764cc"}, +] + +[package.dependencies] +importlib-resources = {version = ">=1.4.0", markers = "python_version < \"3.9\""} +referencing = ">=0.31.0" + +[[package]] +name = "jupyter" +version = "1.0.0" +description = "Jupyter metapackage. Install all the Jupyter components in one go." +optional = false +python-versions = "*" +files = [ + {file = "jupyter-1.0.0-py2.py3-none-any.whl", hash = "sha256:5b290f93b98ffbc21c0c7e749f054b3267782166d72fa5e3ed1ed4eaf34a2b78"}, + {file = "jupyter-1.0.0.tar.gz", hash = "sha256:d9dc4b3318f310e34c82951ea5d6683f67bed7def4b259fafbfe4f1beb1d8e5f"}, + {file = "jupyter-1.0.0.zip", hash = "sha256:3e1f86076bbb7c8c207829390305a2b1fe836d471ed54be66a3b8c41e7f46cc7"}, +] + +[package.dependencies] +ipykernel = "*" +ipywidgets = "*" +jupyter-console = "*" +nbconvert = "*" +notebook = "*" +qtconsole = "*" + +[[package]] +name = "jupyter-client" +version = "8.6.0" +description = "Jupyter protocol implementation and client libraries" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_client-8.6.0-py3-none-any.whl", hash = "sha256:909c474dbe62582ae62b758bca86d6518c85234bdee2d908c778db6d72f39d99"}, + {file = "jupyter_client-8.6.0.tar.gz", hash = "sha256:0642244bb83b4764ae60d07e010e15f0e2d275ec4e918a8f7b80fbbef3ca60c7"}, +] + +[package.dependencies] +importlib-metadata = {version = ">=4.8.3", markers = "python_version < \"3.10\""} +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +python-dateutil = ">=2.8.2" +pyzmq = ">=23.0" +tornado = ">=6.2" +traitlets = ">=5.3" + +[package.extras] +docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] + +[[package]] +name = "jupyter-console" +version = "6.6.3" +description = "Jupyter terminal console" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyter_console-6.6.3-py3-none-any.whl", hash = "sha256:309d33409fcc92ffdad25f0bcdf9a4a9daa61b6f341177570fdac03de5352485"}, + {file = "jupyter_console-6.6.3.tar.gz", hash = "sha256:566a4bf31c87adbfadf22cdf846e3069b59a71ed5da71d6ba4d8aaad14a53539"}, +] + +[package.dependencies] +ipykernel = ">=6.14" +ipython = "*" +jupyter-client = ">=7.0.0" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +prompt-toolkit = ">=3.0.30" +pygments = "*" +pyzmq = ">=17" +traitlets = ">=5.4" + +[package.extras] +test = ["flaky", "pexpect", "pytest"] + +[[package]] +name = "jupyter-core" +version = "5.7.1" +description = "Jupyter core package. A base package on which Jupyter projects rely." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_core-5.7.1-py3-none-any.whl", hash = "sha256:c65c82126453a723a2804aa52409930434598fd9d35091d63dfb919d2b765bb7"}, + {file = "jupyter_core-5.7.1.tar.gz", hash = "sha256:de61a9d7fc71240f688b2fb5ab659fbb56979458dc66a71decd098e03c79e218"}, +] + +[package.dependencies] +platformdirs = ">=2.5" +pywin32 = {version = ">=300", markers = "sys_platform == \"win32\" and platform_python_implementation != \"PyPy\""} +traitlets = ">=5.3" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"] +test = ["ipykernel", "pre-commit", "pytest", "pytest-cov", "pytest-timeout"] + +[[package]] +name = "jupyter-events" +version = "0.9.0" +description = "Jupyter Event System library" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_events-0.9.0-py3-none-any.whl", hash = "sha256:d853b3c10273ff9bc8bb8b30076d65e2c9685579db736873de6c2232dde148bf"}, + {file = "jupyter_events-0.9.0.tar.gz", hash = "sha256:81ad2e4bc710881ec274d31c6c50669d71bbaa5dd9d01e600b56faa85700d399"}, +] + +[package.dependencies] +jsonschema = {version = ">=4.18.0", extras = ["format-nongpl"]} +python-json-logger = ">=2.0.4" +pyyaml = ">=5.3" +referencing = "*" +rfc3339-validator = "*" +rfc3986-validator = ">=0.1.1" +traitlets = ">=5.3" + +[package.extras] +cli = ["click", "rich"] +docs = ["jupyterlite-sphinx", "myst-parser", "pydata-sphinx-theme", "sphinxcontrib-spelling"] +test = ["click", "pre-commit", "pytest (>=7.0)", "pytest-asyncio (>=0.19.0)", "pytest-console-scripts", "rich"] + +[[package]] +name = "jupyter-lsp" +version = "2.2.2" +description = "Multi-Language Server WebSocket proxy for Jupyter Notebook/Lab server" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter-lsp-2.2.2.tar.gz", hash = "sha256:256d24620542ae4bba04a50fc1f6ffe208093a07d8e697fea0a8d1b8ca1b7e5b"}, + {file = "jupyter_lsp-2.2.2-py3-none-any.whl", hash = "sha256:3b95229e4168355a8c91928057c1621ac3510ba98b2a925e82ebd77f078b1aa5"}, +] + +[package.dependencies] +importlib-metadata = {version = ">=4.8.3", markers = "python_version < \"3.10\""} +jupyter-server = ">=1.1.2" + +[[package]] +name = "jupyter-server" +version = "2.12.5" +description = "The backend—i.e. core services, APIs, and REST endpoints—to Jupyter web applications." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_server-2.12.5-py3-none-any.whl", hash = "sha256:184a0f82809a8522777cfb6b760ab6f4b1bb398664c5860a27cec696cb884923"}, + {file = "jupyter_server-2.12.5.tar.gz", hash = "sha256:0edb626c94baa22809be1323f9770cf1c00a952b17097592e40d03e6a3951689"}, +] + +[package.dependencies] +anyio = ">=3.1.0" +argon2-cffi = "*" +jinja2 = "*" +jupyter-client = ">=7.4.4" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +jupyter-events = ">=0.9.0" +jupyter-server-terminals = "*" +nbconvert = ">=6.4.4" +nbformat = ">=5.3.0" +overrides = "*" +packaging = "*" +prometheus-client = "*" +pywinpty = {version = "*", markers = "os_name == \"nt\""} +pyzmq = ">=24" +send2trash = ">=1.8.2" +terminado = ">=0.8.3" +tornado = ">=6.2.0" +traitlets = ">=5.6.0" +websocket-client = "*" + +[package.extras] +docs = ["ipykernel", "jinja2", "jupyter-client", "jupyter-server", "myst-parser", "nbformat", "prometheus-client", "pydata-sphinx-theme", "send2trash", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-openapi (>=0.8.0)", "sphinxcontrib-spelling", "sphinxemoji", "tornado", "typing-extensions"] +test = ["flaky", "ipykernel", "pre-commit", "pytest (>=7.0)", "pytest-console-scripts", "pytest-jupyter[server] (>=0.4)", "pytest-timeout", "requests"] + +[[package]] +name = "jupyter-server-terminals" +version = "0.5.2" +description = "A Jupyter Server Extension Providing Terminals." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyter_server_terminals-0.5.2-py3-none-any.whl", hash = "sha256:1b80c12765da979513c42c90215481bbc39bd8ae7c0350b4f85bc3eb58d0fa80"}, + {file = "jupyter_server_terminals-0.5.2.tar.gz", hash = "sha256:396b5ccc0881e550bf0ee7012c6ef1b53edbde69e67cab1d56e89711b46052e8"}, +] + +[package.dependencies] +pywinpty = {version = ">=2.0.3", markers = "os_name == \"nt\""} +terminado = ">=0.8.3" + +[package.extras] +docs = ["jinja2", "jupyter-server", "mistune (<4.0)", "myst-parser", "nbformat", "packaging", "pydata-sphinx-theme", "sphinxcontrib-github-alt", "sphinxcontrib-openapi", "sphinxcontrib-spelling", "sphinxemoji", "tornado"] +test = ["jupyter-server (>=2.0.0)", "pytest (>=7.0)", "pytest-jupyter[server] (>=0.5.3)", "pytest-timeout"] + +[[package]] +name = "jupyterlab" +version = "4.1.1" +description = "JupyterLab computational environment" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab-4.1.1-py3-none-any.whl", hash = "sha256:fa3e8c18b804eac04e51ceebd9dd3dd396e08106816f0d09cc426799d7087632"}, + {file = "jupyterlab-4.1.1.tar.gz", hash = "sha256:8acc9f561729d8f32c14c294c397917cddfeeb13a5d46f811979b71b4911a9fd"}, +] + +[package.dependencies] +async-lru = ">=1.0.0" +httpx = ">=0.25.0" +importlib-metadata = {version = ">=4.8.3", markers = "python_version < \"3.10\""} +importlib-resources = {version = ">=1.4", markers = "python_version < \"3.9\""} +ipykernel = "*" +jinja2 = ">=3.0.3" +jupyter-core = "*" +jupyter-lsp = ">=2.0.0" +jupyter-server = ">=2.4.0,<3" +jupyterlab-server = ">=2.19.0,<3" +notebook-shim = ">=0.2" +packaging = "*" +tomli = {version = "*", markers = "python_version < \"3.11\""} +tornado = ">=6.2.0" +traitlets = "*" + +[package.extras] +dev = ["build", "bump2version", "coverage", "hatch", "pre-commit", "pytest-cov", "ruff (==0.2.0)"] +docs = ["jsx-lexer", "myst-parser", "pydata-sphinx-theme (>=0.13.0)", "pytest", "pytest-check-links", "pytest-jupyter", "sphinx (>=1.8,<7.3.0)", "sphinx-copybutton"] +docs-screenshots = ["altair (==5.2.0)", "ipython (==8.16.1)", "ipywidgets (==8.1.1)", "jupyterlab-geojson (==3.4.0)", "jupyterlab-language-pack-zh-cn (==4.0.post6)", "matplotlib (==3.8.2)", "nbconvert (>=7.0.0)", "pandas (==2.2.0)", "scipy (==1.12.0)", "vega-datasets (==0.9.0)"] +test = ["coverage", "pytest (>=7.0)", "pytest-check-links (>=0.7)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter (>=0.5.3)", "pytest-timeout", "pytest-tornasync", "requests", "requests-cache", "virtualenv"] + +[[package]] +name = "jupyterlab-pygments" +version = "0.3.0" +description = "Pygments theme using JupyterLab CSS variables" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab_pygments-0.3.0-py3-none-any.whl", hash = "sha256:841a89020971da1d8693f1a99997aefc5dc424bb1b251fd6322462a1b8842780"}, + {file = "jupyterlab_pygments-0.3.0.tar.gz", hash = "sha256:721aca4d9029252b11cfa9d185e5b5af4d54772bb8072f9b7036f4170054d35d"}, +] + +[[package]] +name = "jupyterlab-server" +version = "2.25.2" +description = "A set of server components for JupyterLab and JupyterLab like applications." +optional = false +python-versions = ">=3.8" +files = [ + {file = "jupyterlab_server-2.25.2-py3-none-any.whl", hash = "sha256:5b1798c9cc6a44f65c757de9f97fc06fc3d42535afbf47d2ace5e964ab447aaf"}, + {file = "jupyterlab_server-2.25.2.tar.gz", hash = "sha256:bd0ec7a99ebcedc8bcff939ef86e52c378e44c2707e053fcd81d046ce979ee63"}, +] + +[package.dependencies] +babel = ">=2.10" +importlib-metadata = {version = ">=4.8.3", markers = "python_version < \"3.10\""} +jinja2 = ">=3.0.3" +json5 = ">=0.9.0" +jsonschema = ">=4.18.0" +jupyter-server = ">=1.21,<3" +packaging = ">=21.3" +requests = ">=2.31" + +[package.extras] +docs = ["autodoc-traits", "jinja2 (<3.2.0)", "mistune (<4)", "myst-parser", "pydata-sphinx-theme", "sphinx", "sphinx-copybutton", "sphinxcontrib-openapi (>0.8)"] +openapi = ["openapi-core (>=0.18.0,<0.19.0)", "ruamel-yaml"] +test = ["hatch", "ipykernel", "openapi-core (>=0.18.0,<0.19.0)", "openapi-spec-validator (>=0.6.0,<0.8.0)", "pytest (>=7.0)", "pytest-console-scripts", "pytest-cov", "pytest-jupyter[server] (>=0.6.2)", "pytest-timeout", "requests-mock", "ruamel-yaml", "sphinxcontrib-spelling", "strict-rfc3339", "werkzeug"] + +[[package]] +name = "jupyterlab-widgets" +version = "3.0.10" +description = "Jupyter interactive widgets for JupyterLab" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyterlab_widgets-3.0.10-py3-none-any.whl", hash = "sha256:dd61f3ae7a5a7f80299e14585ce6cf3d6925a96c9103c978eda293197730cb64"}, + {file = "jupyterlab_widgets-3.0.10.tar.gz", hash = "sha256:04f2ac04976727e4f9d0fa91cdc2f1ab860f965e504c29dbd6a65c882c9d04c0"}, +] + +[[package]] +name = "lazy-loader" +version = "0.3" +description = "lazy_loader" +optional = false +python-versions = ">=3.7" +files = [ + {file = "lazy_loader-0.3-py3-none-any.whl", hash = "sha256:1e9e76ee8631e264c62ce10006718e80b2cfc74340d17d1031e0f84af7478554"}, + {file = "lazy_loader-0.3.tar.gz", hash = "sha256:3b68898e34f5b2a29daaaac172c6555512d0f32074f147e2254e4a6d9d838f37"}, +] + +[package.extras] +lint = ["pre-commit (>=3.3)"] +test = ["pytest (>=7.4)", "pytest-cov (>=4.1)"] + +[[package]] +name = "lazy-object-proxy" +version = "1.10.0" +description = "A fast and thorough lazy object proxy." +optional = false +python-versions = ">=3.8" +files = [ + {file = "lazy-object-proxy-1.10.0.tar.gz", hash = "sha256:78247b6d45f43a52ef35c25b5581459e85117225408a4128a3daf8bf9648ac69"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:855e068b0358ab916454464a884779c7ffa312b8925c6f7401e952dcf3b89977"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ab7004cf2e59f7c2e4345604a3e6ea0d92ac44e1c2375527d56492014e690c3"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc0d2fc424e54c70c4bc06787e4072c4f3b1aa2f897dfdc34ce1013cf3ceef05"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e2adb09778797da09d2b5ebdbceebf7dd32e2c96f79da9052b2e87b6ea495895"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b1f711e2c6dcd4edd372cf5dec5c5a30d23bba06ee012093267b3376c079ec83"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-win32.whl", hash = "sha256:76a095cfe6045c7d0ca77db9934e8f7b71b14645f0094ffcd842349ada5c5fb9"}, + {file = "lazy_object_proxy-1.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:b4f87d4ed9064b2628da63830986c3d2dca7501e6018347798313fcf028e2fd4"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fec03caabbc6b59ea4a638bee5fce7117be8e99a4103d9d5ad77f15d6f81020c"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:02c83f957782cbbe8136bee26416686a6ae998c7b6191711a04da776dc9e47d4"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:009e6bb1f1935a62889ddc8541514b6a9e1fcf302667dcb049a0be5c8f613e56"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:75fc59fc450050b1b3c203c35020bc41bd2695ed692a392924c6ce180c6f1dc9"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:782e2c9b2aab1708ffb07d4bf377d12901d7a1d99e5e410d648d892f8967ab1f"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-win32.whl", hash = "sha256:edb45bb8278574710e68a6b021599a10ce730d156e5b254941754a9cc0b17d03"}, + {file = "lazy_object_proxy-1.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:e271058822765ad5e3bca7f05f2ace0de58a3f4e62045a8c90a0dfd2f8ad8cc6"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:e98c8af98d5707dcdecc9ab0863c0ea6e88545d42ca7c3feffb6b4d1e370c7ba"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:952c81d415b9b80ea261d2372d2a4a2332a3890c2b83e0535f263ddfe43f0d43"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80b39d3a151309efc8cc48675918891b865bdf742a8616a337cb0090791a0de9"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:e221060b701e2aa2ea991542900dd13907a5c90fa80e199dbf5a03359019e7a3"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:92f09ff65ecff3108e56526f9e2481b8116c0b9e1425325e13245abfd79bdb1b"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-win32.whl", hash = "sha256:3ad54b9ddbe20ae9f7c1b29e52f123120772b06dbb18ec6be9101369d63a4074"}, + {file = "lazy_object_proxy-1.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:127a789c75151db6af398b8972178afe6bda7d6f68730c057fbbc2e96b08d282"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9e4ed0518a14dd26092614412936920ad081a424bdcb54cc13349a8e2c6d106a"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ad9e6ed739285919aa9661a5bbed0aaf410aa60231373c5579c6b4801bd883c"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2fc0a92c02fa1ca1e84fc60fa258458e5bf89d90a1ddaeb8ed9cc3147f417255"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0aefc7591920bbd360d57ea03c995cebc204b424524a5bd78406f6e1b8b2a5d8"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:5faf03a7d8942bb4476e3b62fd0f4cf94eaf4618e304a19865abf89a35c0bbee"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-win32.whl", hash = "sha256:e333e2324307a7b5d86adfa835bb500ee70bfcd1447384a822e96495796b0ca4"}, + {file = "lazy_object_proxy-1.10.0-cp38-cp38-win_amd64.whl", hash = "sha256:cb73507defd385b7705c599a94474b1d5222a508e502553ef94114a143ec6696"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:366c32fe5355ef5fc8a232c5436f4cc66e9d3e8967c01fb2e6302fd6627e3d94"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2297f08f08a2bb0d32a4265e98a006643cd7233fb7983032bd61ac7a02956b3b"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18dd842b49456aaa9a7cf535b04ca4571a302ff72ed8740d06b5adcd41fe0757"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:217138197c170a2a74ca0e05bddcd5f1796c735c37d0eee33e43259b192aa424"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9a3a87cf1e133e5b1994144c12ca4aa3d9698517fe1e2ca82977781b16955658"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-win32.whl", hash = "sha256:30b339b2a743c5288405aa79a69e706a06e02958eab31859f7f3c04980853b70"}, + {file = "lazy_object_proxy-1.10.0-cp39-cp39-win_amd64.whl", hash = "sha256:a899b10e17743683b293a729d3a11f2f399e8a90c73b089e29f5d0fe3509f0dd"}, + {file = "lazy_object_proxy-1.10.0-pp310.pp311.pp312.pp38.pp39-none-any.whl", hash = "sha256:80fa48bd89c8f2f456fc0765c11c23bf5af827febacd2f523ca5bc1893fcc09d"}, +] + +[[package]] +name = "llama-index-core" +version = "0.10.0" +description = "Interface between LLMs and your data" +optional = false +python-versions = ">=3.8.1,<4.0" +files = [ + {file = "llama_index_core-0.10.0-py3-none-any.whl", hash = "sha256:f532189aad6693abbf5ea82f98ce325ad6b41e597bbc9b9814f22ef13d5f89b9"}, + {file = "llama_index_core-0.10.0.tar.gz", hash = "sha256:f45e2decf5a1636a1b49799b0e3fc9834d5b3d028fe0a7e2eb3860fda11a9e59"}, +] + +[package.dependencies] +aiohttp = ">=3.8.6,<4.0.0" +dataclasses-json = "*" +deprecated = ">=1.2.9.3" +dirtyjson = ">=1.0.8,<2.0.0" +fsspec = ">=2023.5.0" +httpx = "*" +nest-asyncio = ">=1.5.8,<2.0.0" +networkx = ">=3.0" +nltk = ">=3.8.1,<4.0.0" +numpy = "*" +openai = ">=1.1.0" +pandas = "*" +pillow = ">=9.0.0" +PyYAML = ">=6.0.1" +requests = ">=2.31.0" +SQLAlchemy = {version = ">=1.4.49", extras = ["asyncio"]} +tenacity = ">=8.2.0,<9.0.0" +tiktoken = ">=0.3.3" +tqdm = ">=4.66.1,<5.0.0" +typing-extensions = ">=4.5.0" +typing-inspect = ">=0.8.0" + +[package.extras] +gradientai = ["gradientai (>=1.4.0)"] +html = ["beautifulsoup4 (>=4.12.2,<5.0.0)"] +langchain = ["langchain (>=0.0.303)"] +local-models = ["optimum[onnxruntime] (>=1.13.2,<2.0.0)", "sentencepiece (>=0.1.99,<0.2.0)", "transformers[torch] (>=4.33.1,<5.0.0)"] +postgres = ["asyncpg (>=0.28.0,<0.29.0)", "pgvector (>=0.1.0,<0.2.0)", "psycopg2-binary (>=2.9.9,<3.0.0)"] +query-tools = ["guidance (>=0.0.64,<0.0.65)", "jsonpath-ng (>=1.6.0,<2.0.0)", "lm-format-enforcer (>=0.4.3,<0.5.0)", "rank-bm25 (>=0.2.2,<0.3.0)", "scikit-learn", "spacy (>=3.7.1,<4.0.0)"] + +[[package]] +name = "loguru" +version = "0.7.2" +description = "Python logging made (stupidly) simple" +optional = false +python-versions = ">=3.5" +files = [ + {file = "loguru-0.7.2-py3-none-any.whl", hash = "sha256:003d71e3d3ed35f0f8984898359d65b79e5b21943f78af86aa5491210429b8eb"}, + {file = "loguru-0.7.2.tar.gz", hash = "sha256:e671a53522515f34fd406340ee968cb9ecafbc4b36c679da03c18fd8d0bd51ac"}, +] + +[package.dependencies] +colorama = {version = ">=0.3.4", markers = "sys_platform == \"win32\""} +win32-setctime = {version = ">=1.0.0", markers = "sys_platform == \"win32\""} + +[package.extras] +dev = ["Sphinx (==7.2.5)", "colorama (==0.4.5)", "colorama (==0.4.6)", "exceptiongroup (==1.1.3)", "freezegun (==1.1.0)", "freezegun (==1.2.2)", "mypy (==v0.910)", "mypy (==v0.971)", "mypy (==v1.4.1)", "mypy (==v1.5.1)", "pre-commit (==3.4.0)", "pytest (==6.1.2)", "pytest (==7.4.0)", "pytest-cov (==2.12.1)", "pytest-cov (==4.1.0)", "pytest-mypy-plugins (==1.9.3)", "pytest-mypy-plugins (==3.0.0)", "sphinx-autobuild (==2021.3.14)", "sphinx-rtd-theme (==1.3.0)", "tox (==3.27.1)", "tox (==4.11.0)"] + +[[package]] +name = "markupsafe" +version = "2.1.5" +description = "Safely add untrusted strings to HTML/XML markup." +optional = false +python-versions = ">=3.7" +files = [ + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a17a92de5231666cfbe003f0e4b9b3a7ae3afb1ec2845aadc2bacc93ff85febc"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:72b6be590cc35924b02c78ef34b467da4ba07e4e0f0454a2c5907f473fc50ce5"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61659ba32cf2cf1481e575d0462554625196a1f2fc06a1c777d3f48e8865d46"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2174c595a0d73a3080ca3257b40096db99799265e1c27cc5a610743acd86d62f"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ae2ad8ae6ebee9d2d94b17fb62763125f3f374c25618198f40cbb8b525411900"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:075202fa5b72c86ad32dc7d0b56024ebdbcf2048c0ba09f1cde31bfdd57bcfff"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:598e3276b64aff0e7b3451b72e94fa3c238d452e7ddcd893c3ab324717456bad"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fce659a462a1be54d2ffcacea5e3ba2d74daa74f30f5f143fe0c58636e355fdd"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-win32.whl", hash = "sha256:d9fad5155d72433c921b782e58892377c44bd6252b5af2f67f16b194987338a4"}, + {file = "MarkupSafe-2.1.5-cp310-cp310-win_amd64.whl", hash = "sha256:bf50cd79a75d181c9181df03572cdce0fbb75cc353bc350712073108cba98de5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:629ddd2ca402ae6dbedfceeba9c46d5f7b2a61d9749597d4307f943ef198fc1f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5b7b716f97b52c5a14bffdf688f971b2d5ef4029127f1ad7a513973cfd818df2"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ec585f69cec0aa07d945b20805be741395e28ac1627333b1c5b0105962ffced"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b91c037585eba9095565a3556f611e3cbfaa42ca1e865f7b8015fe5c7336d5a5"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7502934a33b54030eaf1194c21c692a534196063db72176b0c4028e140f8f32c"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0e397ac966fdf721b2c528cf028494e86172b4feba51d65f81ffd65c63798f3f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c061bb86a71b42465156a3ee7bd58c8c2ceacdbeb95d05a99893e08b8467359a"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3a57fdd7ce31c7ff06cdfbf31dafa96cc533c21e443d57f5b1ecc6cdc668ec7f"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win32.whl", hash = "sha256:397081c1a0bfb5124355710fe79478cdbeb39626492b15d399526ae53422b906"}, + {file = "MarkupSafe-2.1.5-cp311-cp311-win_amd64.whl", hash = "sha256:2b7c57a4dfc4f16f7142221afe5ba4e093e09e728ca65c51f5620c9aaeb9a617"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8dec4936e9c3100156f8a2dc89c4b88d5c435175ff03413b443469c7c8c5f4d1"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:3c6b973f22eb18a789b1460b4b91bf04ae3f0c4234a0a6aa6b0a92f6f7b951d4"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ac07bad82163452a6884fe8fa0963fb98c2346ba78d779ec06bd7a6262132aee"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f5dfb42c4604dddc8e4305050aa6deb084540643ed5804d7455b5df8fe16f5e5"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ea3d8a3d18833cf4304cd2fc9cbb1efe188ca9b5efef2bdac7adc20594a0e46b"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d050b3361367a06d752db6ead6e7edeb0009be66bc3bae0ee9d97fb326badc2a"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:bec0a414d016ac1a18862a519e54b2fd0fc8bbfd6890376898a6c0891dd82e9f"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:58c98fee265677f63a4385256a6d7683ab1832f3ddd1e66fe948d5880c21a169"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win32.whl", hash = "sha256:8590b4ae07a35970728874632fed7bd57b26b0102df2d2b233b6d9d82f6c62ad"}, + {file = "MarkupSafe-2.1.5-cp312-cp312-win_amd64.whl", hash = "sha256:823b65d8706e32ad2df51ed89496147a42a2a6e01c13cfb6ffb8b1e92bc910bb"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c8b29db45f8fe46ad280a7294f5c3ec36dbac9491f2d1c17345be8e69cc5928f"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec6a563cff360b50eed26f13adc43e61bc0c04d94b8be985e6fb24b81f6dcfdf"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a549b9c31bec33820e885335b451286e2969a2d9e24879f83fe904a5ce59d70a"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4f11aa001c540f62c6166c7726f71f7573b52c68c31f014c25cc7901deea0b52"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7b2e5a267c855eea6b4283940daa6e88a285f5f2a67f2220203786dfa59b37e9"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:2d2d793e36e230fd32babe143b04cec8a8b3eb8a3122d2aceb4a371e6b09b8df"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:ce409136744f6521e39fd8e2a24c53fa18ad67aa5bc7c2cf83645cce5b5c4e50"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-win32.whl", hash = "sha256:4096e9de5c6fdf43fb4f04c26fb114f61ef0bf2e5604b6ee3019d51b69e8c371"}, + {file = "MarkupSafe-2.1.5-cp37-cp37m-win_amd64.whl", hash = "sha256:4275d846e41ecefa46e2015117a9f491e57a71ddd59bbead77e904dc02b1bed2"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:656f7526c69fac7f600bd1f400991cc282b417d17539a1b228617081106feb4a"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:97cafb1f3cbcd3fd2b6fbfb99ae11cdb14deea0736fc2b0952ee177f2b813a46"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f3fbcb7ef1f16e48246f704ab79d79da8a46891e2da03f8783a5b6fa41a9532"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa9db3f79de01457b03d4f01b34cf91bc0048eb2c3846ff26f66687c2f6d16ab"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffee1f21e5ef0d712f9033568f8344d5da8cc2869dbd08d87c84656e6a2d2f68"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5dedb4db619ba5a2787a94d877bc8ffc0566f92a01c0ef214865e54ecc9ee5e0"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:30b600cf0a7ac9234b2638fbc0fb6158ba5bdcdf46aeb631ead21248b9affbc4"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8dd717634f5a044f860435c1d8c16a270ddf0ef8588d4887037c5028b859b0c3"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-win32.whl", hash = "sha256:daa4ee5a243f0f20d528d939d06670a298dd39b1ad5f8a72a4275124a7819eff"}, + {file = "MarkupSafe-2.1.5-cp38-cp38-win_amd64.whl", hash = "sha256:619bc166c4f2de5caa5a633b8b7326fbe98e0ccbfacabd87268a2b15ff73a029"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:7a68b554d356a91cce1236aa7682dc01df0edba8d043fd1ce607c49dd3c1edcf"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:db0b55e0f3cc0be60c1f19efdde9a637c32740486004f20d1cff53c3c0ece4d2"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e53af139f8579a6d5f7b76549125f0d94d7e630761a2111bc431fd820e163b8"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17b950fccb810b3293638215058e432159d2b71005c74371d784862b7e4683f3"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c31f53cdae6ecfa91a77820e8b151dba54ab528ba65dfd235c80b086d68a465"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:bff1b4290a66b490a2f4719358c0cdcd9bafb6b8f061e45c7a2460866bf50c2e"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:bc1667f8b83f48511b94671e0e441401371dfd0f0a795c7daa4a3cd1dde55bea"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5049256f536511ee3f7e1b3f87d1d1209d327e818e6ae1365e8653d7e3abb6a6"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win32.whl", hash = "sha256:00e046b6dd71aa03a41079792f8473dc494d564611a8f89bbbd7cb93295ebdcf"}, + {file = "MarkupSafe-2.1.5-cp39-cp39-win_amd64.whl", hash = "sha256:fa173ec60341d6bb97a89f5ea19c85c5643c1e7dedebc22f5181eb73573142c5"}, + {file = "MarkupSafe-2.1.5.tar.gz", hash = "sha256:d283d37a890ba4c1ae73ffadf8046435c76e7bc2247bbb63c00bd1a709c6544b"}, +] + +[[package]] +name = "marshmallow" +version = "3.20.2" +description = "A lightweight library for converting complex datatypes to and from native Python datatypes." +optional = false +python-versions = ">=3.8" +files = [ + {file = "marshmallow-3.20.2-py3-none-any.whl", hash = "sha256:c21d4b98fee747c130e6bc8f45c4b3199ea66bc00c12ee1f639f0aeca034d5e9"}, + {file = "marshmallow-3.20.2.tar.gz", hash = "sha256:4c1daff273513dc5eb24b219a8035559dc573c8f322558ef85f5438ddd1236dd"}, +] + +[package.dependencies] +packaging = ">=17.0" + +[package.extras] +dev = ["pre-commit (>=2.4,<4.0)", "pytest", "pytz", "simplejson", "tox"] +docs = ["alabaster (==0.7.15)", "autodocsumm (==0.2.12)", "sphinx (==7.2.6)", "sphinx-issues (==3.0.1)", "sphinx-version-warning (==1.1.2)"] +lint = ["pre-commit (>=2.4,<4.0)"] +tests = ["pytest", "pytz", "simplejson"] + +[[package]] +name = "matplotlib-inline" +version = "0.1.6" +description = "Inline Matplotlib backend for Jupyter" +optional = false +python-versions = ">=3.5" +files = [ + {file = "matplotlib-inline-0.1.6.tar.gz", hash = "sha256:f887e5f10ba98e8d2b150ddcf4702c1e5f8b3a20005eb0f74bfdbd360ee6f304"}, + {file = "matplotlib_inline-0.1.6-py3-none-any.whl", hash = "sha256:f1f41aab5328aa5aaea9b16d083b128102f8712542f819fe7e6a420ff581b311"}, +] + +[package.dependencies] +traitlets = "*" + +[[package]] +name = "mccabe" +version = "0.7.0" +description = "McCabe checker, plugin for flake8" +optional = false +python-versions = ">=3.6" +files = [ + {file = "mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e"}, + {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"}, +] + +[[package]] +name = "mistune" +version = "3.0.2" +description = "A sane and fast Markdown parser with useful plugins and renderers" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mistune-3.0.2-py3-none-any.whl", hash = "sha256:71481854c30fdbc938963d3605b72501f5c10a9320ecd412c121c163a1c7d205"}, + {file = "mistune-3.0.2.tar.gz", hash = "sha256:fc7f93ded930c92394ef2cb6f04a8aabab4117a91449e72dcc8dfa646a508be8"}, +] + +[[package]] +name = "multidict" +version = "6.0.5" +description = "multidict implementation" +optional = false +python-versions = ">=3.7" +files = [ + {file = "multidict-6.0.5-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:228b644ae063c10e7f324ab1ab6b548bdf6f8b47f3ec234fef1093bc2735e5f9"}, + {file = "multidict-6.0.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:896ebdcf62683551312c30e20614305f53125750803b614e9e6ce74a96232604"}, + {file = "multidict-6.0.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:411bf8515f3be9813d06004cac41ccf7d1cd46dfe233705933dd163b60e37600"}, + {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d147090048129ce3c453f0292e7697d333db95e52616b3793922945804a433c"}, + {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:215ed703caf15f578dca76ee6f6b21b7603791ae090fbf1ef9d865571039ade5"}, + {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c6390cf87ff6234643428991b7359b5f59cc15155695deb4eda5c777d2b880f"}, + {file = "multidict-6.0.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21fd81c4ebdb4f214161be351eb5bcf385426bf023041da2fd9e60681f3cebae"}, + {file = "multidict-6.0.5-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3cc2ad10255f903656017363cd59436f2111443a76f996584d1077e43ee51182"}, + {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:6939c95381e003f54cd4c5516740faba40cf5ad3eeff460c3ad1d3e0ea2549bf"}, + {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:220dd781e3f7af2c2c1053da9fa96d9cf3072ca58f057f4c5adaaa1cab8fc442"}, + {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:766c8f7511df26d9f11cd3a8be623e59cca73d44643abab3f8c8c07620524e4a"}, + {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:fe5d7785250541f7f5019ab9cba2c71169dc7d74d0f45253f8313f436458a4ef"}, + {file = "multidict-6.0.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c1c1496e73051918fcd4f58ff2e0f2f3066d1c76a0c6aeffd9b45d53243702cc"}, + {file = "multidict-6.0.5-cp310-cp310-win32.whl", hash = "sha256:7afcdd1fc07befad18ec4523a782cde4e93e0a2bf71239894b8d61ee578c1319"}, + {file = "multidict-6.0.5-cp310-cp310-win_amd64.whl", hash = "sha256:99f60d34c048c5c2fabc766108c103612344c46e35d4ed9ae0673d33c8fb26e8"}, + {file = "multidict-6.0.5-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f285e862d2f153a70586579c15c44656f888806ed0e5b56b64489afe4a2dbfba"}, + {file = "multidict-6.0.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:53689bb4e102200a4fafa9de9c7c3c212ab40a7ab2c8e474491914d2305f187e"}, + {file = "multidict-6.0.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:612d1156111ae11d14afaf3a0669ebf6c170dbb735e510a7438ffe2369a847fd"}, + {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7be7047bd08accdb7487737631d25735c9a04327911de89ff1b26b81745bd4e3"}, + {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de170c7b4fe6859beb8926e84f7d7d6c693dfe8e27372ce3b76f01c46e489fcf"}, + {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04bde7a7b3de05732a4eb39c94574db1ec99abb56162d6c520ad26f83267de29"}, + {file = "multidict-6.0.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85f67aed7bb647f93e7520633d8f51d3cbc6ab96957c71272b286b2f30dc70ed"}, + {file = "multidict-6.0.5-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:425bf820055005bfc8aa9a0b99ccb52cc2f4070153e34b701acc98d201693733"}, + {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d3eb1ceec286eba8220c26f3b0096cf189aea7057b6e7b7a2e60ed36b373b77f"}, + {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:7901c05ead4b3fb75113fb1dd33eb1253c6d3ee37ce93305acd9d38e0b5f21a4"}, + {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:e0e79d91e71b9867c73323a3444724d496c037e578a0e1755ae159ba14f4f3d1"}, + {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:29bfeb0dff5cb5fdab2023a7a9947b3b4af63e9c47cae2a10ad58394b517fddc"}, + {file = "multidict-6.0.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e030047e85cbcedbfc073f71836d62dd5dadfbe7531cae27789ff66bc551bd5e"}, + {file = "multidict-6.0.5-cp311-cp311-win32.whl", hash = "sha256:2f4848aa3baa109e6ab81fe2006c77ed4d3cd1e0ac2c1fbddb7b1277c168788c"}, + {file = "multidict-6.0.5-cp311-cp311-win_amd64.whl", hash = "sha256:2faa5ae9376faba05f630d7e5e6be05be22913782b927b19d12b8145968a85ea"}, + {file = "multidict-6.0.5-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:51d035609b86722963404f711db441cf7134f1889107fb171a970c9701f92e1e"}, + {file = "multidict-6.0.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cbebcd5bcaf1eaf302617c114aa67569dd3f090dd0ce8ba9e35e9985b41ac35b"}, + {file = "multidict-6.0.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2ffc42c922dbfddb4a4c3b438eb056828719f07608af27d163191cb3e3aa6cc5"}, + {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ceb3b7e6a0135e092de86110c5a74e46bda4bd4fbfeeb3a3bcec79c0f861e450"}, + {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:79660376075cfd4b2c80f295528aa6beb2058fd289f4c9252f986751a4cd0496"}, + {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e4428b29611e989719874670fd152b6625500ad6c686d464e99f5aaeeaca175a"}, + {file = "multidict-6.0.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d84a5c3a5f7ce6db1f999fb9438f686bc2e09d38143f2d93d8406ed2dd6b9226"}, + {file = "multidict-6.0.5-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:76c0de87358b192de7ea9649beb392f107dcad9ad27276324c24c91774ca5271"}, + {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:79a6d2ba910adb2cbafc95dad936f8b9386e77c84c35bc0add315b856d7c3abb"}, + {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:92d16a3e275e38293623ebf639c471d3e03bb20b8ebb845237e0d3664914caef"}, + {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:fb616be3538599e797a2017cccca78e354c767165e8858ab5116813146041a24"}, + {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:14c2976aa9038c2629efa2c148022ed5eb4cb939e15ec7aace7ca932f48f9ba6"}, + {file = "multidict-6.0.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:435a0984199d81ca178b9ae2c26ec3d49692d20ee29bc4c11a2a8d4514c67eda"}, + {file = "multidict-6.0.5-cp312-cp312-win32.whl", hash = "sha256:9fe7b0653ba3d9d65cbe7698cca585bf0f8c83dbbcc710db9c90f478e175f2d5"}, + {file = "multidict-6.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:01265f5e40f5a17f8241d52656ed27192be03bfa8764d88e8220141d1e4b3556"}, + {file = "multidict-6.0.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:19fe01cea168585ba0f678cad6f58133db2aa14eccaf22f88e4a6dccadfad8b3"}, + {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6bf7a982604375a8d49b6cc1b781c1747f243d91b81035a9b43a2126c04766f5"}, + {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:107c0cdefe028703fb5dafe640a409cb146d44a6ae201e55b35a4af8e95457dd"}, + {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:403c0911cd5d5791605808b942c88a8155c2592e05332d2bf78f18697a5fa15e"}, + {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aeaf541ddbad8311a87dd695ed9642401131ea39ad7bc8cf3ef3967fd093b626"}, + {file = "multidict-6.0.5-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e4972624066095e52b569e02b5ca97dbd7a7ddd4294bf4e7247d52635630dd83"}, + {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:d946b0a9eb8aaa590df1fe082cee553ceab173e6cb5b03239716338629c50c7a"}, + {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:b55358304d7a73d7bdf5de62494aaf70bd33015831ffd98bc498b433dfe5b10c"}, + {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:a3145cb08d8625b2d3fee1b2d596a8766352979c9bffe5d7833e0503d0f0b5e5"}, + {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:d65f25da8e248202bd47445cec78e0025c0fe7582b23ec69c3b27a640dd7a8e3"}, + {file = "multidict-6.0.5-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:c9bf56195c6bbd293340ea82eafd0071cb3d450c703d2c93afb89f93b8386ccc"}, + {file = "multidict-6.0.5-cp37-cp37m-win32.whl", hash = "sha256:69db76c09796b313331bb7048229e3bee7928eb62bab5e071e9f7fcc4879caee"}, + {file = "multidict-6.0.5-cp37-cp37m-win_amd64.whl", hash = "sha256:fce28b3c8a81b6b36dfac9feb1de115bab619b3c13905b419ec71d03a3fc1423"}, + {file = "multidict-6.0.5-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:76f067f5121dcecf0d63a67f29080b26c43c71a98b10c701b0677e4a065fbd54"}, + {file = "multidict-6.0.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b82cc8ace10ab5bd93235dfaab2021c70637005e1ac787031f4d1da63d493c1d"}, + {file = "multidict-6.0.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5cb241881eefd96b46f89b1a056187ea8e9ba14ab88ba632e68d7a2ecb7aadf7"}, + {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8e94e6912639a02ce173341ff62cc1201232ab86b8a8fcc05572741a5dc7d93"}, + {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:09a892e4a9fb47331da06948690ae38eaa2426de97b4ccbfafbdcbe5c8f37ff8"}, + {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:55205d03e8a598cfc688c71ca8ea5f66447164efff8869517f175ea632c7cb7b"}, + {file = "multidict-6.0.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:37b15024f864916b4951adb95d3a80c9431299080341ab9544ed148091b53f50"}, + {file = "multidict-6.0.5-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2a1dee728b52b33eebff5072817176c172050d44d67befd681609b4746e1c2e"}, + {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:edd08e6f2f1a390bf137080507e44ccc086353c8e98c657e666c017718561b89"}, + {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:60d698e8179a42ec85172d12f50b1668254628425a6bd611aba022257cac1386"}, + {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:3d25f19500588cbc47dc19081d78131c32637c25804df8414463ec908631e453"}, + {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:4cc0ef8b962ac7a5e62b9e826bd0cd5040e7d401bc45a6835910ed699037a461"}, + {file = "multidict-6.0.5-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:eca2e9d0cc5a889850e9bbd68e98314ada174ff6ccd1129500103df7a94a7a44"}, + {file = "multidict-6.0.5-cp38-cp38-win32.whl", hash = "sha256:4a6a4f196f08c58c59e0b8ef8ec441d12aee4125a7d4f4fef000ccb22f8d7241"}, + {file = "multidict-6.0.5-cp38-cp38-win_amd64.whl", hash = "sha256:0275e35209c27a3f7951e1ce7aaf93ce0d163b28948444bec61dd7badc6d3f8c"}, + {file = "multidict-6.0.5-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e7be68734bd8c9a513f2b0cfd508802d6609da068f40dc57d4e3494cefc92929"}, + {file = "multidict-6.0.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:1d9ea7a7e779d7a3561aade7d596649fbecfa5c08a7674b11b423783217933f9"}, + {file = "multidict-6.0.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ea1456df2a27c73ce51120fa2f519f1bea2f4a03a917f4a43c8707cf4cbbae1a"}, + {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf590b134eb70629e350691ecca88eac3e3b8b3c86992042fb82e3cb1830d5e1"}, + {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5c0631926c4f58e9a5ccce555ad7747d9a9f8b10619621f22f9635f069f6233e"}, + {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dce1c6912ab9ff5f179eaf6efe7365c1f425ed690b03341911bf4939ef2f3046"}, + {file = "multidict-6.0.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0868d64af83169e4d4152ec612637a543f7a336e4a307b119e98042e852ad9c"}, + {file = "multidict-6.0.5-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:141b43360bfd3bdd75f15ed811850763555a251e38b2405967f8e25fb43f7d40"}, + {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:7df704ca8cf4a073334e0427ae2345323613e4df18cc224f647f251e5e75a527"}, + {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:6214c5a5571802c33f80e6c84713b2c79e024995b9c5897f794b43e714daeec9"}, + {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:cd6c8fca38178e12c00418de737aef1261576bd1b6e8c6134d3e729a4e858b38"}, + {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:e02021f87a5b6932fa6ce916ca004c4d441509d33bbdbeca70d05dff5e9d2479"}, + {file = "multidict-6.0.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ebd8d160f91a764652d3e51ce0d2956b38efe37c9231cd82cfc0bed2e40b581c"}, + {file = "multidict-6.0.5-cp39-cp39-win32.whl", hash = "sha256:04da1bb8c8dbadf2a18a452639771951c662c5ad03aefe4884775454be322c9b"}, + {file = "multidict-6.0.5-cp39-cp39-win_amd64.whl", hash = "sha256:d6f6d4f185481c9669b9447bf9d9cf3b95a0e9df9d169bbc17e363b7d5487755"}, + {file = "multidict-6.0.5-py3-none-any.whl", hash = "sha256:0d63c74e3d7ab26de115c49bffc92cc77ed23395303d496eae515d4204a625e7"}, + {file = "multidict-6.0.5.tar.gz", hash = "sha256:f7e301075edaf50500f0b341543c41194d8df3ae5caf4702f2095f3ca73dd8da"}, +] + +[[package]] +name = "mypy" +version = "0.991" +description = "Optional static typing for Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mypy-0.991-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7d17e0a9707d0772f4a7b878f04b4fd11f6f5bcb9b3813975a9b13c9332153ab"}, + {file = "mypy-0.991-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0714258640194d75677e86c786e80ccf294972cc76885d3ebbb560f11db0003d"}, + {file = "mypy-0.991-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0c8f3be99e8a8bd403caa8c03be619544bc2c77a7093685dcf308c6b109426c6"}, + {file = "mypy-0.991-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc9ec663ed6c8f15f4ae9d3c04c989b744436c16d26580eaa760ae9dd5d662eb"}, + {file = "mypy-0.991-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4307270436fd7694b41f913eb09210faff27ea4979ecbcd849e57d2da2f65305"}, + {file = "mypy-0.991-cp310-cp310-win_amd64.whl", hash = "sha256:901c2c269c616e6cb0998b33d4adbb4a6af0ac4ce5cd078afd7bc95830e62c1c"}, + {file = "mypy-0.991-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d13674f3fb73805ba0c45eb6c0c3053d218aa1f7abead6e446d474529aafc372"}, + {file = "mypy-0.991-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1c8cd4fb70e8584ca1ed5805cbc7c017a3d1a29fb450621089ffed3e99d1857f"}, + {file = "mypy-0.991-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:209ee89fbb0deed518605edddd234af80506aec932ad28d73c08f1400ef80a33"}, + {file = "mypy-0.991-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:37bd02ebf9d10e05b00d71302d2c2e6ca333e6c2a8584a98c00e038db8121f05"}, + {file = "mypy-0.991-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:26efb2fcc6b67e4d5a55561f39176821d2adf88f2745ddc72751b7890f3194ad"}, + {file = "mypy-0.991-cp311-cp311-win_amd64.whl", hash = "sha256:3a700330b567114b673cf8ee7388e949f843b356a73b5ab22dd7cff4742a5297"}, + {file = "mypy-0.991-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:1f7d1a520373e2272b10796c3ff721ea1a0712288cafaa95931e66aa15798813"}, + {file = "mypy-0.991-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:641411733b127c3e0dab94c45af15fea99e4468f99ac88b39efb1ad677da5711"}, + {file = "mypy-0.991-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:3d80e36b7d7a9259b740be6d8d906221789b0d836201af4234093cae89ced0cd"}, + {file = "mypy-0.991-cp37-cp37m-win_amd64.whl", hash = "sha256:e62ebaad93be3ad1a828a11e90f0e76f15449371ffeecca4a0a0b9adc99abcef"}, + {file = "mypy-0.991-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:b86ce2c1866a748c0f6faca5232059f881cda6dda2a893b9a8373353cfe3715a"}, + {file = "mypy-0.991-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ac6e503823143464538efda0e8e356d871557ef60ccd38f8824a4257acc18d93"}, + {file = "mypy-0.991-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:0cca5adf694af539aeaa6ac633a7afe9bbd760df9d31be55ab780b77ab5ae8bf"}, + {file = "mypy-0.991-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a12c56bf73cdab116df96e4ff39610b92a348cc99a1307e1da3c3768bbb5b135"}, + {file = "mypy-0.991-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:652b651d42f155033a1967739788c436491b577b6a44e4c39fb340d0ee7f0d70"}, + {file = "mypy-0.991-cp38-cp38-win_amd64.whl", hash = "sha256:4175593dc25d9da12f7de8de873a33f9b2b8bdb4e827a7cae952e5b1a342e243"}, + {file = "mypy-0.991-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:98e781cd35c0acf33eb0295e8b9c55cdbef64fcb35f6d3aa2186f289bed6e80d"}, + {file = "mypy-0.991-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6d7464bac72a85cb3491c7e92b5b62f3dcccb8af26826257760a552a5e244aa5"}, + {file = "mypy-0.991-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c9166b3f81a10cdf9b49f2d594b21b31adadb3d5e9db9b834866c3258b695be3"}, + {file = "mypy-0.991-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8472f736a5bfb159a5e36740847808f6f5b659960115ff29c7cecec1741c648"}, + {file = "mypy-0.991-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5e80e758243b97b618cdf22004beb09e8a2de1af481382e4d84bc52152d1c476"}, + {file = "mypy-0.991-cp39-cp39-win_amd64.whl", hash = "sha256:74e259b5c19f70d35fcc1ad3d56499065c601dfe94ff67ae48b85596b9ec1461"}, + {file = "mypy-0.991-py3-none-any.whl", hash = "sha256:de32edc9b0a7e67c2775e574cb061a537660e51210fbf6006b0b36ea695ae9bb"}, + {file = "mypy-0.991.tar.gz", hash = "sha256:3c0165ba8f354a6d9881809ef29f1a9318a236a6d81c690094c5df32107bde06"}, +] + +[package.dependencies] +mypy-extensions = ">=0.4.3" +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +typing-extensions = ">=3.10" + +[package.extras] +dmypy = ["psutil (>=4.0)"] +install-types = ["pip"] +python2 = ["typed-ast (>=1.4.0,<2)"] +reports = ["lxml"] + +[[package]] +name = "mypy-extensions" +version = "1.0.0" +description = "Type system extensions for programs checked with the mypy type checker." +optional = false +python-versions = ">=3.5" +files = [ + {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, + {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, +] + +[[package]] +name = "nbclient" +version = "0.9.0" +description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." +optional = false +python-versions = ">=3.8.0" +files = [ + {file = "nbclient-0.9.0-py3-none-any.whl", hash = "sha256:a3a1ddfb34d4a9d17fc744d655962714a866639acd30130e9be84191cd97cd15"}, + {file = "nbclient-0.9.0.tar.gz", hash = "sha256:4b28c207877cf33ef3a9838cdc7a54c5ceff981194a82eac59d558f05487295e"}, +] + +[package.dependencies] +jupyter-client = ">=6.1.12" +jupyter-core = ">=4.12,<5.0.dev0 || >=5.1.dev0" +nbformat = ">=5.1" +traitlets = ">=5.4" + +[package.extras] +dev = ["pre-commit"] +docs = ["autodoc-traits", "mock", "moto", "myst-parser", "nbclient[test]", "sphinx (>=1.7)", "sphinx-book-theme", "sphinxcontrib-spelling"] +test = ["flaky", "ipykernel (>=6.19.3)", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "pytest (>=7.0)", "pytest-asyncio", "pytest-cov (>=4.0)", "testpath", "xmltodict"] + +[[package]] +name = "nbconvert" +version = "7.16.0" +description = "Converting Jupyter Notebooks" +optional = false +python-versions = ">=3.8" +files = [ + {file = "nbconvert-7.16.0-py3-none-any.whl", hash = "sha256:ad3dc865ea6e2768d31b7eb6c7ab3be014927216a5ece3ef276748dd809054c7"}, + {file = "nbconvert-7.16.0.tar.gz", hash = "sha256:813e6553796362489ae572e39ba1bff978536192fb518e10826b0e8cadf03ec8"}, +] + +[package.dependencies] +beautifulsoup4 = "*" +bleach = "!=5.0.0" +defusedxml = "*" +importlib-metadata = {version = ">=3.6", markers = "python_version < \"3.10\""} +jinja2 = ">=3.0" +jupyter-core = ">=4.7" +jupyterlab-pygments = "*" +markupsafe = ">=2.0" +mistune = ">=2.0.3,<4" +nbclient = ">=0.5.0" +nbformat = ">=5.7" +packaging = "*" +pandocfilters = ">=1.4.1" +pygments = ">=2.4.1" +tinycss2 = "*" +traitlets = ">=5.1" + +[package.extras] +all = ["nbconvert[docs,qtpdf,serve,test,webpdf]"] +docs = ["ipykernel", "ipython", "myst-parser", "nbsphinx (>=0.2.12)", "pydata-sphinx-theme", "sphinx (==5.0.2)", "sphinxcontrib-spelling"] +qtpdf = ["nbconvert[qtpng]"] +qtpng = ["pyqtwebengine (>=5.15)"] +serve = ["tornado (>=6.1)"] +test = ["flaky", "ipykernel", "ipywidgets (>=7.5)", "pytest"] +webpdf = ["playwright"] + +[[package]] +name = "nbformat" +version = "5.9.2" +description = "The Jupyter Notebook format" +optional = false +python-versions = ">=3.8" +files = [ + {file = "nbformat-5.9.2-py3-none-any.whl", hash = "sha256:1c5172d786a41b82bcfd0c23f9e6b6f072e8fb49c39250219e4acfff1efe89e9"}, + {file = "nbformat-5.9.2.tar.gz", hash = "sha256:5f98b5ba1997dff175e77e0c17d5c10a96eaed2cbd1de3533d1fc35d5e111192"}, +] + +[package.dependencies] +fastjsonschema = "*" +jsonschema = ">=2.6" +jupyter-core = "*" +traitlets = ">=5.1" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["pep440", "pre-commit", "pytest", "testpath"] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +description = "Patch asyncio to allow nested event loops" +optional = false +python-versions = ">=3.5" +files = [ + {file = "nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c"}, + {file = "nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe"}, +] + +[[package]] +name = "networkx" +version = "3.1" +description = "Python package for creating and manipulating graphs and networks" +optional = false +python-versions = ">=3.8" +files = [ + {file = "networkx-3.1-py3-none-any.whl", hash = "sha256:4f33f68cb2afcf86f28a45f43efc27a9386b535d567d2127f8f61d51dec58d36"}, + {file = "networkx-3.1.tar.gz", hash = "sha256:de346335408f84de0eada6ff9fafafff9bcda11f0a0dfaa931133debb146ab61"}, +] + +[package.extras] +default = ["matplotlib (>=3.4)", "numpy (>=1.20)", "pandas (>=1.3)", "scipy (>=1.8)"] +developer = ["mypy (>=1.1)", "pre-commit (>=3.2)"] +doc = ["nb2plots (>=0.6)", "numpydoc (>=1.5)", "pillow (>=9.4)", "pydata-sphinx-theme (>=0.13)", "sphinx (>=6.1)", "sphinx-gallery (>=0.12)", "texext (>=0.6.7)"] +extra = ["lxml (>=4.6)", "pydot (>=1.4.2)", "pygraphviz (>=1.10)", "sympy (>=1.10)"] +test = ["codecov (>=2.1)", "pytest (>=7.2)", "pytest-cov (>=4.0)"] + +[[package]] +name = "nltk" +version = "3.8.1" +description = "Natural Language Toolkit" +optional = false +python-versions = ">=3.7" +files = [ + {file = "nltk-3.8.1-py3-none-any.whl", hash = "sha256:fd5c9109f976fa86bcadba8f91e47f5e9293bd034474752e92a520f81c93dda5"}, + {file = "nltk-3.8.1.zip", hash = "sha256:1834da3d0682cba4f2cede2f9aad6b0fafb6461ba451db0efb6f9c39798d64d3"}, +] + +[package.dependencies] +click = "*" +joblib = "*" +regex = ">=2021.8.3" +tqdm = "*" + +[package.extras] +all = ["matplotlib", "numpy", "pyparsing", "python-crfsuite", "requests", "scikit-learn", "scipy", "twython"] +corenlp = ["requests"] +machine-learning = ["numpy", "python-crfsuite", "scikit-learn", "scipy"] +plot = ["matplotlib"] +tgrep = ["pyparsing"] +twitter = ["twython"] + +[[package]] +name = "nodeenv" +version = "1.8.0" +description = "Node.js virtual environment builder" +optional = false +python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*" +files = [ + {file = "nodeenv-1.8.0-py2.py3-none-any.whl", hash = "sha256:df865724bb3c3adc86b3876fa209771517b0cfe596beff01a92700e0e8be4cec"}, + {file = "nodeenv-1.8.0.tar.gz", hash = "sha256:d51e0c37e64fbf47d017feac3145cdbb58836d7eee8c6f6d3b6880c5456227d2"}, +] + +[package.dependencies] +setuptools = "*" + +[[package]] +name = "notebook" +version = "7.1.0" +description = "Jupyter Notebook - A web-based notebook environment for interactive computing" +optional = false +python-versions = ">=3.8" +files = [ + {file = "notebook-7.1.0-py3-none-any.whl", hash = "sha256:a8fa4ccb5e5fe220f29d9900337efd7752bc6f2efe004d6f320db01f7743adc9"}, + {file = "notebook-7.1.0.tar.gz", hash = "sha256:99caf01ff166b1cc86355c9b37c1ba9bf566c1d7fc4ab57bb6f8f24e36c4260e"}, +] + +[package.dependencies] +jupyter-server = ">=2.4.0,<3" +jupyterlab = ">=4.1.1,<4.2" +jupyterlab-server = ">=2.22.1,<3" +notebook-shim = ">=0.2,<0.3" +tornado = ">=6.2.0" + +[package.extras] +dev = ["hatch", "pre-commit"] +docs = ["myst-parser", "nbsphinx", "pydata-sphinx-theme", "sphinx (>=1.3.6)", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] +test = ["importlib-resources (>=5.0)", "ipykernel", "jupyter-server[test] (>=2.4.0,<3)", "jupyterlab-server[test] (>=2.22.1,<3)", "nbval", "pytest (>=7.0)", "pytest-console-scripts", "pytest-timeout", "pytest-tornasync", "requests"] + +[[package]] +name = "notebook-shim" +version = "0.2.3" +description = "A shim layer for notebook traits and config" +optional = false +python-versions = ">=3.7" +files = [ + {file = "notebook_shim-0.2.3-py3-none-any.whl", hash = "sha256:a83496a43341c1674b093bfcebf0fe8e74cbe7eda5fd2bbc56f8e39e1486c0c7"}, + {file = "notebook_shim-0.2.3.tar.gz", hash = "sha256:f69388ac283ae008cd506dda10d0288b09a017d822d5e8c7129a152cbd3ce7e9"}, +] + +[package.dependencies] +jupyter-server = ">=1.8,<3" + +[package.extras] +test = ["pytest", "pytest-console-scripts", "pytest-jupyter", "pytest-tornasync"] + +[[package]] +name = "numpy" +version = "1.24.4" +description = "Fundamental package for array computing in Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "numpy-1.24.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c0bfb52d2169d58c1cdb8cc1f16989101639b34c7d3ce60ed70b19c63eba0b64"}, + {file = "numpy-1.24.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ed094d4f0c177b1b8e7aa9cba7d6ceed51c0e569a5318ac0ca9a090680a6a1b1"}, + {file = "numpy-1.24.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79fc682a374c4a8ed08b331bef9c5f582585d1048fa6d80bc6c35bc384eee9b4"}, + {file = "numpy-1.24.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ffe43c74893dbf38c2b0a1f5428760a1a9c98285553c89e12d70a96a7f3a4d6"}, + {file = "numpy-1.24.4-cp310-cp310-win32.whl", hash = "sha256:4c21decb6ea94057331e111a5bed9a79d335658c27ce2adb580fb4d54f2ad9bc"}, + {file = "numpy-1.24.4-cp310-cp310-win_amd64.whl", hash = "sha256:b4bea75e47d9586d31e892a7401f76e909712a0fd510f58f5337bea9572c571e"}, + {file = "numpy-1.24.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f136bab9c2cfd8da131132c2cf6cc27331dd6fae65f95f69dcd4ae3c3639c810"}, + {file = "numpy-1.24.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e2926dac25b313635e4d6cf4dc4e51c8c0ebfed60b801c799ffc4c32bf3d1254"}, + {file = "numpy-1.24.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:222e40d0e2548690405b0b3c7b21d1169117391c2e82c378467ef9ab4c8f0da7"}, + {file = "numpy-1.24.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7215847ce88a85ce39baf9e89070cb860c98fdddacbaa6c0da3ffb31b3350bd5"}, + {file = "numpy-1.24.4-cp311-cp311-win32.whl", hash = "sha256:4979217d7de511a8d57f4b4b5b2b965f707768440c17cb70fbf254c4b225238d"}, + {file = "numpy-1.24.4-cp311-cp311-win_amd64.whl", hash = "sha256:b7b1fc9864d7d39e28f41d089bfd6353cb5f27ecd9905348c24187a768c79694"}, + {file = "numpy-1.24.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1452241c290f3e2a312c137a9999cdbf63f78864d63c79039bda65ee86943f61"}, + {file = "numpy-1.24.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:04640dab83f7c6c85abf9cd729c5b65f1ebd0ccf9de90b270cd61935eef0197f"}, + {file = "numpy-1.24.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5425b114831d1e77e4b5d812b69d11d962e104095a5b9c3b641a218abcc050e"}, + {file = "numpy-1.24.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd80e219fd4c71fc3699fc1dadac5dcf4fd882bfc6f7ec53d30fa197b8ee22dc"}, + {file = "numpy-1.24.4-cp38-cp38-win32.whl", hash = "sha256:4602244f345453db537be5314d3983dbf5834a9701b7723ec28923e2889e0bb2"}, + {file = "numpy-1.24.4-cp38-cp38-win_amd64.whl", hash = "sha256:692f2e0f55794943c5bfff12b3f56f99af76f902fc47487bdfe97856de51a706"}, + {file = "numpy-1.24.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2541312fbf09977f3b3ad449c4e5f4bb55d0dbf79226d7724211acc905049400"}, + {file = "numpy-1.24.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9667575fb6d13c95f1b36aca12c5ee3356bf001b714fc354eb5465ce1609e62f"}, + {file = "numpy-1.24.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f3a86ed21e4f87050382c7bc96571755193c4c1392490744ac73d660e8f564a9"}, + {file = "numpy-1.24.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d11efb4dbecbdf22508d55e48d9c8384db795e1b7b51ea735289ff96613ff74d"}, + {file = "numpy-1.24.4-cp39-cp39-win32.whl", hash = "sha256:6620c0acd41dbcb368610bb2f4d83145674040025e5536954782467100aa8835"}, + {file = "numpy-1.24.4-cp39-cp39-win_amd64.whl", hash = "sha256:befe2bf740fd8373cf56149a5c23a0f601e82869598d41f8e188a0e9869926f8"}, + {file = "numpy-1.24.4-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:31f13e25b4e304632a4619d0e0777662c2ffea99fcae2029556b17d8ff958aef"}, + {file = "numpy-1.24.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95f7ac6540e95bc440ad77f56e520da5bf877f87dca58bd095288dce8940532a"}, + {file = "numpy-1.24.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:e98f220aa76ca2a977fe435f5b04d7b3470c0a2e6312907b37ba6068f26787f2"}, + {file = "numpy-1.24.4.tar.gz", hash = "sha256:80f5e3a4e498641401868df4208b74581206afbee7cf7b8329daae82676d9463"}, +] + +[[package]] +name = "openai" +version = "1.12.0" +description = "The official Python library for the openai API" +optional = false +python-versions = ">=3.7.1" +files = [ + {file = "openai-1.12.0-py3-none-any.whl", hash = "sha256:a54002c814e05222e413664f651b5916714e4700d041d5cf5724d3ae1a3e3481"}, + {file = "openai-1.12.0.tar.gz", hash = "sha256:99c5d257d09ea6533d689d1cc77caa0ac679fa21efef8893d8b0832a86877f1b"}, +] + +[package.dependencies] +anyio = ">=3.5.0,<5" +distro = ">=1.7.0,<2" +httpx = ">=0.23.0,<1" +pydantic = ">=1.9.0,<3" +sniffio = "*" +tqdm = ">4" +typing-extensions = ">=4.7,<5" + +[package.extras] +datalib = ["numpy (>=1)", "pandas (>=1.2.3)", "pandas-stubs (>=1.1.0.11)"] + +[[package]] +name = "overrides" +version = "7.7.0" +description = "A decorator to automatically detect mismatch when overriding a method." +optional = false +python-versions = ">=3.6" +files = [ + {file = "overrides-7.7.0-py3-none-any.whl", hash = "sha256:c7ed9d062f78b8e4c1a7b70bd8796b35ead4d9f510227ef9c5dc7626c60d7e49"}, + {file = "overrides-7.7.0.tar.gz", hash = "sha256:55158fa3d93b98cc75299b1e67078ad9003ca27945c76162c1c0766d6f91820a"}, +] + +[[package]] +name = "packaging" +version = "23.2" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.7" +files = [ + {file = "packaging-23.2-py3-none-any.whl", hash = "sha256:8c491190033a9af7e1d931d0b5dacc2ef47509b34dd0de67ed209b5203fc88c7"}, + {file = "packaging-23.2.tar.gz", hash = "sha256:048fb0e9405036518eaaf48a55953c750c11e1a1b68e0dd1a9d62ed0c092cfc5"}, +] + +[[package]] +name = "pandas" +version = "2.0.3" +description = "Powerful data structures for data analysis, time series, and statistics" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pandas-2.0.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e4c7c9f27a4185304c7caf96dc7d91bc60bc162221152de697c98eb0b2648dd8"}, + {file = "pandas-2.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f167beed68918d62bffb6ec64f2e1d8a7d297a038f86d4aed056b9493fca407f"}, + {file = "pandas-2.0.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce0c6f76a0f1ba361551f3e6dceaff06bde7514a374aa43e33b588ec10420183"}, + {file = "pandas-2.0.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba619e410a21d8c387a1ea6e8a0e49bb42216474436245718d7f2e88a2f8d7c0"}, + {file = "pandas-2.0.3-cp310-cp310-win32.whl", hash = "sha256:3ef285093b4fe5058eefd756100a367f27029913760773c8bf1d2d8bebe5d210"}, + {file = "pandas-2.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:9ee1a69328d5c36c98d8e74db06f4ad518a1840e8ccb94a4ba86920986bb617e"}, + {file = "pandas-2.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b084b91d8d66ab19f5bb3256cbd5ea661848338301940e17f4492b2ce0801fe8"}, + {file = "pandas-2.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:37673e3bdf1551b95bf5d4ce372b37770f9529743d2498032439371fc7b7eb26"}, + {file = "pandas-2.0.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9cb1e14fdb546396b7e1b923ffaeeac24e4cedd14266c3497216dd4448e4f2d"}, + {file = "pandas-2.0.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d9cd88488cceb7635aebb84809d087468eb33551097d600c6dad13602029c2df"}, + {file = "pandas-2.0.3-cp311-cp311-win32.whl", hash = "sha256:694888a81198786f0e164ee3a581df7d505024fbb1f15202fc7db88a71d84ebd"}, + {file = "pandas-2.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:6a21ab5c89dcbd57f78d0ae16630b090eec626360085a4148693def5452d8a6b"}, + {file = "pandas-2.0.3-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9e4da0d45e7f34c069fe4d522359df7d23badf83abc1d1cef398895822d11061"}, + {file = "pandas-2.0.3-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:32fca2ee1b0d93dd71d979726b12b61faa06aeb93cf77468776287f41ff8fdc5"}, + {file = "pandas-2.0.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:258d3624b3ae734490e4d63c430256e716f488c4fcb7c8e9bde2d3aa46c29089"}, + {file = "pandas-2.0.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9eae3dc34fa1aa7772dd3fc60270d13ced7346fcbcfee017d3132ec625e23bb0"}, + {file = "pandas-2.0.3-cp38-cp38-win32.whl", hash = "sha256:f3421a7afb1a43f7e38e82e844e2bca9a6d793d66c1a7f9f0ff39a795bbc5e02"}, + {file = "pandas-2.0.3-cp38-cp38-win_amd64.whl", hash = "sha256:69d7f3884c95da3a31ef82b7618af5710dba95bb885ffab339aad925c3e8ce78"}, + {file = "pandas-2.0.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5247fb1ba347c1261cbbf0fcfba4a3121fbb4029d95d9ef4dc45406620b25c8b"}, + {file = "pandas-2.0.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:81af086f4543c9d8bb128328b5d32e9986e0c84d3ee673a2ac6fb57fd14f755e"}, + {file = "pandas-2.0.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1994c789bf12a7c5098277fb43836ce090f1073858c10f9220998ac74f37c69b"}, + {file = "pandas-2.0.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ec591c48e29226bcbb316e0c1e9423622bc7a4eaf1ef7c3c9fa1a3981f89641"}, + {file = "pandas-2.0.3-cp39-cp39-win32.whl", hash = "sha256:04dbdbaf2e4d46ca8da896e1805bc04eb85caa9a82e259e8eed00254d5e0c682"}, + {file = "pandas-2.0.3-cp39-cp39-win_amd64.whl", hash = "sha256:1168574b036cd8b93abc746171c9b4f1b83467438a5e45909fed645cf8692dbc"}, + {file = "pandas-2.0.3.tar.gz", hash = "sha256:c02f372a88e0d17f36d3093a644c73cfc1788e876a7c4bcb4020a77512e2043c"}, +] + +[package.dependencies] +numpy = [ + {version = ">=1.20.3", markers = "python_version < \"3.10\""}, + {version = ">=1.21.0", markers = "python_version >= \"3.10\" and python_version < \"3.11\""}, + {version = ">=1.23.2", markers = "python_version >= \"3.11\""}, +] +python-dateutil = ">=2.8.2" +pytz = ">=2020.1" +tzdata = ">=2022.1" + +[package.extras] +all = ["PyQt5 (>=5.15.1)", "SQLAlchemy (>=1.4.16)", "beautifulsoup4 (>=4.9.3)", "bottleneck (>=1.3.2)", "brotlipy (>=0.7.0)", "fastparquet (>=0.6.3)", "fsspec (>=2021.07.0)", "gcsfs (>=2021.07.0)", "html5lib (>=1.1)", "hypothesis (>=6.34.2)", "jinja2 (>=3.0.0)", "lxml (>=4.6.3)", "matplotlib (>=3.6.1)", "numba (>=0.53.1)", "numexpr (>=2.7.3)", "odfpy (>=1.4.1)", "openpyxl (>=3.0.7)", "pandas-gbq (>=0.15.0)", "psycopg2 (>=2.8.6)", "pyarrow (>=7.0.0)", "pymysql (>=1.0.2)", "pyreadstat (>=1.1.2)", "pytest (>=7.3.2)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)", "python-snappy (>=0.6.0)", "pyxlsb (>=1.0.8)", "qtpy (>=2.2.0)", "s3fs (>=2021.08.0)", "scipy (>=1.7.1)", "tables (>=3.6.1)", "tabulate (>=0.8.9)", "xarray (>=0.21.0)", "xlrd (>=2.0.1)", "xlsxwriter (>=1.4.3)", "zstandard (>=0.15.2)"] +aws = ["s3fs (>=2021.08.0)"] +clipboard = ["PyQt5 (>=5.15.1)", "qtpy (>=2.2.0)"] +compression = ["brotlipy (>=0.7.0)", "python-snappy (>=0.6.0)", "zstandard (>=0.15.2)"] +computation = ["scipy (>=1.7.1)", "xarray (>=0.21.0)"] +excel = ["odfpy (>=1.4.1)", "openpyxl (>=3.0.7)", "pyxlsb (>=1.0.8)", "xlrd (>=2.0.1)", "xlsxwriter (>=1.4.3)"] +feather = ["pyarrow (>=7.0.0)"] +fss = ["fsspec (>=2021.07.0)"] +gcp = ["gcsfs (>=2021.07.0)", "pandas-gbq (>=0.15.0)"] +hdf5 = ["tables (>=3.6.1)"] +html = ["beautifulsoup4 (>=4.9.3)", "html5lib (>=1.1)", "lxml (>=4.6.3)"] +mysql = ["SQLAlchemy (>=1.4.16)", "pymysql (>=1.0.2)"] +output-formatting = ["jinja2 (>=3.0.0)", "tabulate (>=0.8.9)"] +parquet = ["pyarrow (>=7.0.0)"] +performance = ["bottleneck (>=1.3.2)", "numba (>=0.53.1)", "numexpr (>=2.7.1)"] +plot = ["matplotlib (>=3.6.1)"] +postgresql = ["SQLAlchemy (>=1.4.16)", "psycopg2 (>=2.8.6)"] +spss = ["pyreadstat (>=1.1.2)"] +sql-other = ["SQLAlchemy (>=1.4.16)"] +test = ["hypothesis (>=6.34.2)", "pytest (>=7.3.2)", "pytest-asyncio (>=0.17.0)", "pytest-xdist (>=2.2.0)"] +xml = ["lxml (>=4.6.3)"] + +[[package]] +name = "pandocfilters" +version = "1.5.1" +description = "Utilities for writing pandoc filters in python" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "pandocfilters-1.5.1-py2.py3-none-any.whl", hash = "sha256:93be382804a9cdb0a7267585f157e5d1731bbe5545a85b268d6f5fe6232de2bc"}, + {file = "pandocfilters-1.5.1.tar.gz", hash = "sha256:002b4a555ee4ebc03f8b66307e287fa492e4a77b4ea14d3f934328297bb4939e"}, +] + +[[package]] +name = "parso" +version = "0.8.3" +description = "A Python Parser" +optional = false +python-versions = ">=3.6" +files = [ + {file = "parso-0.8.3-py2.py3-none-any.whl", hash = "sha256:c001d4636cd3aecdaf33cbb40aebb59b094be2a74c556778ef5576c175e19e75"}, + {file = "parso-0.8.3.tar.gz", hash = "sha256:8c07be290bb59f03588915921e29e8a50002acaf2cdc5fa0e0114f91709fafa0"}, +] + +[package.extras] +qa = ["flake8 (==3.8.3)", "mypy (==0.782)"] +testing = ["docopt", "pytest (<6.0.0)"] + +[[package]] +name = "pathspec" +version = "0.12.1" +description = "Utility library for gitignore style pattern matching of file paths." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08"}, + {file = "pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712"}, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +description = "Pexpect allows easy control of interactive console applications." +optional = false +python-versions = "*" +files = [ + {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, + {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, +] + +[package.dependencies] +ptyprocess = ">=0.5" + +[[package]] +name = "pickleshare" +version = "0.7.5" +description = "Tiny 'shelve'-like database with concurrency support" +optional = false +python-versions = "*" +files = [ + {file = "pickleshare-0.7.5-py2.py3-none-any.whl", hash = "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56"}, + {file = "pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca"}, +] + +[[package]] +name = "pillow" +version = "10.2.0" +description = "Python Imaging Library (Fork)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pillow-10.2.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:7823bdd049099efa16e4246bdf15e5a13dbb18a51b68fa06d6c1d4d8b99a796e"}, + {file = "pillow-10.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:83b2021f2ade7d1ed556bc50a399127d7fb245e725aa0113ebd05cfe88aaf588"}, + {file = "pillow-10.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6fad5ff2f13d69b7e74ce5b4ecd12cc0ec530fcee76356cac6742785ff71c452"}, + {file = "pillow-10.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da2b52b37dad6d9ec64e653637a096905b258d2fc2b984c41ae7d08b938a67e4"}, + {file = "pillow-10.2.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:47c0995fc4e7f79b5cfcab1fc437ff2890b770440f7696a3ba065ee0fd496563"}, + {file = "pillow-10.2.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:322bdf3c9b556e9ffb18f93462e5f749d3444ce081290352c6070d014c93feb2"}, + {file = "pillow-10.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:51f1a1bffc50e2e9492e87d8e09a17c5eea8409cda8d3f277eb6edc82813c17c"}, + {file = "pillow-10.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:69ffdd6120a4737710a9eee73e1d2e37db89b620f702754b8f6e62594471dee0"}, + {file = "pillow-10.2.0-cp310-cp310-win32.whl", hash = "sha256:c6dafac9e0f2b3c78df97e79af707cdc5ef8e88208d686a4847bab8266870023"}, + {file = "pillow-10.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:aebb6044806f2e16ecc07b2a2637ee1ef67a11840a66752751714a0d924adf72"}, + {file = "pillow-10.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:7049e301399273a0136ff39b84c3678e314f2158f50f517bc50285fb5ec847ad"}, + {file = "pillow-10.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:35bb52c37f256f662abdfa49d2dfa6ce5d93281d323a9af377a120e89a9eafb5"}, + {file = "pillow-10.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9c23f307202661071d94b5e384e1e1dc7dfb972a28a2310e4ee16103e66ddb67"}, + {file = "pillow-10.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:773efe0603db30c281521a7c0214cad7836c03b8ccff897beae9b47c0b657d61"}, + {file = "pillow-10.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:11fa2e5984b949b0dd6d7a94d967743d87c577ff0b83392f17cb3990d0d2fd6e"}, + {file = "pillow-10.2.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:716d30ed977be8b37d3ef185fecb9e5a1d62d110dfbdcd1e2a122ab46fddb03f"}, + {file = "pillow-10.2.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:a086c2af425c5f62a65e12fbf385f7c9fcb8f107d0849dba5839461a129cf311"}, + {file = "pillow-10.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:c8de2789052ed501dd829e9cae8d3dcce7acb4777ea4a479c14521c942d395b1"}, + {file = "pillow-10.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:609448742444d9290fd687940ac0b57fb35e6fd92bdb65386e08e99af60bf757"}, + {file = "pillow-10.2.0-cp311-cp311-win32.whl", hash = "sha256:823ef7a27cf86df6597fa0671066c1b596f69eba53efa3d1e1cb8b30f3533068"}, + {file = "pillow-10.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:1da3b2703afd040cf65ec97efea81cfba59cdbed9c11d8efc5ab09df9509fc56"}, + {file = "pillow-10.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:edca80cbfb2b68d7b56930b84a0e45ae1694aeba0541f798e908a49d66b837f1"}, + {file = "pillow-10.2.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:1b5e1b74d1bd1b78bc3477528919414874748dd363e6272efd5abf7654e68bef"}, + {file = "pillow-10.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0eae2073305f451d8ecacb5474997c08569fb4eb4ac231ffa4ad7d342fdc25ac"}, + {file = "pillow-10.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b7c2286c23cd350b80d2fc9d424fc797575fb16f854b831d16fd47ceec078f2c"}, + {file = "pillow-10.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1e23412b5c41e58cec602f1135c57dfcf15482013ce6e5f093a86db69646a5aa"}, + {file = "pillow-10.2.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:52a50aa3fb3acb9cf7213573ef55d31d6eca37f5709c69e6858fe3bc04a5c2a2"}, + {file = "pillow-10.2.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:127cee571038f252a552760076407f9cff79761c3d436a12af6000cd182a9d04"}, + {file = "pillow-10.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:8d12251f02d69d8310b046e82572ed486685c38f02176bd08baf216746eb947f"}, + {file = "pillow-10.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:54f1852cd531aa981bc0965b7d609f5f6cc8ce8c41b1139f6ed6b3c54ab82bfb"}, + {file = "pillow-10.2.0-cp312-cp312-win32.whl", hash = "sha256:257d8788df5ca62c980314053197f4d46eefedf4e6175bc9412f14412ec4ea2f"}, + {file = "pillow-10.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:154e939c5f0053a383de4fd3d3da48d9427a7e985f58af8e94d0b3c9fcfcf4f9"}, + {file = "pillow-10.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:f379abd2f1e3dddb2b61bc67977a6b5a0a3f7485538bcc6f39ec76163891ee48"}, + {file = "pillow-10.2.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:8373c6c251f7ef8bda6675dd6d2b3a0fcc31edf1201266b5cf608b62a37407f9"}, + {file = "pillow-10.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:870ea1ada0899fd0b79643990809323b389d4d1d46c192f97342eeb6ee0b8483"}, + {file = "pillow-10.2.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b4b6b1e20608493548b1f32bce8cca185bf0480983890403d3b8753e44077129"}, + {file = "pillow-10.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3031709084b6e7852d00479fd1d310b07d0ba82765f973b543c8af5061cf990e"}, + {file = "pillow-10.2.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:3ff074fc97dd4e80543a3e91f69d58889baf2002b6be64347ea8cf5533188213"}, + {file = "pillow-10.2.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:cb4c38abeef13c61d6916f264d4845fab99d7b711be96c326b84df9e3e0ff62d"}, + {file = "pillow-10.2.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b1b3020d90c2d8e1dae29cf3ce54f8094f7938460fb5ce8bc5c01450b01fbaf6"}, + {file = "pillow-10.2.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:170aeb00224ab3dc54230c797f8404507240dd868cf52066f66a41b33169bdbe"}, + {file = "pillow-10.2.0-cp38-cp38-win32.whl", hash = "sha256:c4225f5220f46b2fde568c74fca27ae9771536c2e29d7c04f4fb62c83275ac4e"}, + {file = "pillow-10.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:0689b5a8c5288bc0504d9fcee48f61a6a586b9b98514d7d29b840143d6734f39"}, + {file = "pillow-10.2.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:b792a349405fbc0163190fde0dc7b3fef3c9268292586cf5645598b48e63dc67"}, + {file = "pillow-10.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c570f24be1e468e3f0ce7ef56a89a60f0e05b30a3669a459e419c6eac2c35364"}, + {file = "pillow-10.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8ecd059fdaf60c1963c58ceb8997b32e9dc1b911f5da5307aab614f1ce5c2fb"}, + {file = "pillow-10.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c365fd1703040de1ec284b176d6af5abe21b427cb3a5ff68e0759e1e313a5e7e"}, + {file = "pillow-10.2.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:70c61d4c475835a19b3a5aa42492409878bbca7438554a1f89d20d58a7c75c01"}, + {file = "pillow-10.2.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:b6f491cdf80ae540738859d9766783e3b3c8e5bd37f5dfa0b76abdecc5081f13"}, + {file = "pillow-10.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9d189550615b4948f45252d7f005e53c2040cea1af5b60d6f79491a6e147eef7"}, + {file = "pillow-10.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:49d9ba1ed0ef3e061088cd1e7538a0759aab559e2e0a80a36f9fd9d8c0c21591"}, + {file = "pillow-10.2.0-cp39-cp39-win32.whl", hash = "sha256:babf5acfede515f176833ed6028754cbcd0d206f7f614ea3447d67c33be12516"}, + {file = "pillow-10.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:0304004f8067386b477d20a518b50f3fa658a28d44e4116970abfcd94fac34a8"}, + {file = "pillow-10.2.0-cp39-cp39-win_arm64.whl", hash = "sha256:0fb3e7fc88a14eacd303e90481ad983fd5b69c761e9e6ef94c983f91025da869"}, + {file = "pillow-10.2.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:322209c642aabdd6207517e9739c704dc9f9db943015535783239022002f054a"}, + {file = "pillow-10.2.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3eedd52442c0a5ff4f887fab0c1c0bb164d8635b32c894bc1faf4c618dd89df2"}, + {file = "pillow-10.2.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb28c753fd5eb3dd859b4ee95de66cc62af91bcff5db5f2571d32a520baf1f04"}, + {file = "pillow-10.2.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:33870dc4653c5017bf4c8873e5488d8f8d5f8935e2f1fb9a2208c47cdd66efd2"}, + {file = "pillow-10.2.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:3c31822339516fb3c82d03f30e22b1d038da87ef27b6a78c9549888f8ceda39a"}, + {file = "pillow-10.2.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a2b56ba36e05f973d450582fb015594aaa78834fefe8dfb8fcd79b93e64ba4c6"}, + {file = "pillow-10.2.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:d8e6aeb9201e655354b3ad049cb77d19813ad4ece0df1249d3c793de3774f8c7"}, + {file = "pillow-10.2.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:2247178effb34a77c11c0e8ac355c7a741ceca0a732b27bf11e747bbc950722f"}, + {file = "pillow-10.2.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:15587643b9e5eb26c48e49a7b33659790d28f190fc514a322d55da2fb5c2950e"}, + {file = "pillow-10.2.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753cd8f2086b2b80180d9b3010dd4ed147efc167c90d3bf593fe2af21265e5a5"}, + {file = "pillow-10.2.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:7c8f97e8e7a9009bcacbe3766a36175056c12f9a44e6e6f2d5caad06dcfbf03b"}, + {file = "pillow-10.2.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:d1b35bcd6c5543b9cb547dee3150c93008f8dd0f1fef78fc0cd2b141c5baf58a"}, + {file = "pillow-10.2.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:fe4c15f6c9285dc54ce6553a3ce908ed37c8f3825b5a51a15c91442bb955b868"}, + {file = "pillow-10.2.0.tar.gz", hash = "sha256:e87f0b2c78157e12d7686b27d63c070fd65d994e8ddae6f328e0dcf4a0cd007e"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"] +fpx = ["olefile"] +mic = ["olefile"] +tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] +typing = ["typing-extensions"] +xmp = ["defusedxml"] + +[[package]] +name = "pkgutil-resolve-name" +version = "1.3.10" +description = "Resolve a name to an object." +optional = false +python-versions = ">=3.6" +files = [ + {file = "pkgutil_resolve_name-1.3.10-py3-none-any.whl", hash = "sha256:ca27cc078d25c5ad71a9de0a7a330146c4e014c2462d9af19c6b828280649c5e"}, + {file = "pkgutil_resolve_name-1.3.10.tar.gz", hash = "sha256:357d6c9e6a755653cfd78893817c0853af365dd51ec97f3d358a819373bbd174"}, +] + +[[package]] +name = "platformdirs" +version = "4.2.0" +description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." +optional = false +python-versions = ">=3.8" +files = [ + {file = "platformdirs-4.2.0-py3-none-any.whl", hash = "sha256:0614df2a2f37e1a662acbd8e2b25b92ccf8632929bc6d43467e17fe89c75e068"}, + {file = "platformdirs-4.2.0.tar.gz", hash = "sha256:ef0cc731df711022c174543cb70a9b5bd22e5a9337c8624ef2c2ceb8ddad8768"}, +] + +[package.extras] +docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"] +test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"] + +[[package]] +name = "plotly" +version = "5.18.0" +description = "An open-source, interactive data visualization library for Python" +optional = false +python-versions = ">=3.6" +files = [ + {file = "plotly-5.18.0-py3-none-any.whl", hash = "sha256:23aa8ea2f4fb364a20d34ad38235524bd9d691bf5299e800bca608c31e8db8de"}, + {file = "plotly-5.18.0.tar.gz", hash = "sha256:360a31e6fbb49d12b007036eb6929521343d6bee2236f8459915821baefa2cbb"}, +] + +[package.dependencies] +packaging = "*" +tenacity = ">=6.2.0" + +[[package]] +name = "pluggy" +version = "1.4.0" +description = "plugin and hook calling mechanisms for python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pluggy-1.4.0-py3-none-any.whl", hash = "sha256:7db9f7b503d67d1c5b95f59773ebb58a8c1c288129a88665838012cfb07b8981"}, + {file = "pluggy-1.4.0.tar.gz", hash = "sha256:8c85c2876142a764e5b7548e7d9a0e0ddb46f5185161049a79b7e974454223be"}, +] + +[package.extras] +dev = ["pre-commit", "tox"] +testing = ["pytest", "pytest-benchmark"] + +[[package]] +name = "polars" +version = "0.20.8" +description = "Blazingly fast DataFrame library" +optional = false +python-versions = ">=3.8" +files = [ + {file = "polars-0.20.8-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:73f1d369aeddda5f11411b6497f697f2471bbe6ae55fd936677a10a40995c83c"}, + {file = "polars-0.20.8-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:dc3a446fe606095b3ad6df3cf3dddd8ad54be7745f255fedb29f8bdf71a60760"}, + {file = "polars-0.20.8-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d3d58ebc7a24d26930535d06b8772e125038a87a6abab4c5dfd87ea19bba61f3"}, + {file = "polars-0.20.8-cp38-abi3-manylinux_2_24_aarch64.whl", hash = "sha256:5b733816ac61156c12bd0edd6d7c1a5e63859830ce0e425b6450b335024f0cd5"}, + {file = "polars-0.20.8-cp38-abi3-win_amd64.whl", hash = "sha256:2300f48ff7120eefe2cac2113990d0b0b5beedad93266b9fedfc8df133e7b13b"}, + {file = "polars-0.20.8.tar.gz", hash = "sha256:a34f6ce1c5469872b291aaf90467e632e81f92dec6c2e18136bc40cd92877411"}, +] + +[package.extras] +adbc = ["adbc_driver_sqlite"] +all = ["polars[adbc,cloudpickle,connectorx,deltalake,fsspec,gevent,numpy,pandas,plot,pyarrow,pydantic,pyiceberg,sqlalchemy,timezone,xlsx2csv,xlsxwriter]"] +cloudpickle = ["cloudpickle"] +connectorx = ["connectorx (>=0.3.2)"] +deltalake = ["deltalake (>=0.14.0)"] +fsspec = ["fsspec"] +gevent = ["gevent"] +matplotlib = ["matplotlib"] +numpy = ["numpy (>=1.16.0)"] +openpyxl = ["openpyxl (>=3.0.0)"] +pandas = ["pandas", "pyarrow (>=7.0.0)"] +plot = ["hvplot (>=0.9.1)"] +pyarrow = ["pyarrow (>=7.0.0)"] +pydantic = ["pydantic"] +pyiceberg = ["pyiceberg (>=0.5.0)"] +pyxlsb = ["pyxlsb (>=1.0)"] +sqlalchemy = ["pandas", "sqlalchemy"] +timezone = ["backports.zoneinfo", "tzdata"] +xlsx2csv = ["xlsx2csv (>=0.8.0)"] +xlsxwriter = ["xlsxwriter"] + +[[package]] +name = "pre-commit" +version = "3.2.0" +description = "A framework for managing and maintaining multi-language pre-commit hooks." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pre_commit-3.2.0-py2.py3-none-any.whl", hash = "sha256:f712d3688102e13c8e66b7d7dbd8934a6dda157e58635d89f7d6fecdca39ce8a"}, + {file = "pre_commit-3.2.0.tar.gz", hash = "sha256:818f0d998059934d0f81bb3667e3ccdc32da6ed7ccaac33e43dc231561ddaaa9"}, +] + +[package.dependencies] +cfgv = ">=2.0.0" +identify = ">=1.0.0" +nodeenv = ">=0.11.1" +pyyaml = ">=5.1" +virtualenv = ">=20.10.0" + +[[package]] +name = "prometheus-client" +version = "0.19.0" +description = "Python client for the Prometheus monitoring system." +optional = false +python-versions = ">=3.8" +files = [ + {file = "prometheus_client-0.19.0-py3-none-any.whl", hash = "sha256:c88b1e6ecf6b41cd8fb5731c7ae919bf66df6ec6fafa555cd6c0e16ca169ae92"}, + {file = "prometheus_client-0.19.0.tar.gz", hash = "sha256:4585b0d1223148c27a225b10dbec5ae9bc4c81a99a3fa80774fa6209935324e1"}, +] + +[package.extras] +twisted = ["twisted"] + +[[package]] +name = "prompt-toolkit" +version = "3.0.43" +description = "Library for building powerful interactive command lines in Python" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "prompt_toolkit-3.0.43-py3-none-any.whl", hash = "sha256:a11a29cb3bf0a28a387fe5122cdb649816a957cd9261dcedf8c9f1fef33eacf6"}, + {file = "prompt_toolkit-3.0.43.tar.gz", hash = "sha256:3527b7af26106cbc65a040bcc84839a3566ec1b051bb0bfe953631e704b0ff7d"}, +] + +[package.dependencies] +wcwidth = "*" + +[[package]] +name = "psutil" +version = "5.9.8" +description = "Cross-platform lib for process and system monitoring in Python." +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*" +files = [ + {file = "psutil-5.9.8-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:26bd09967ae00920df88e0352a91cff1a78f8d69b3ecabbfe733610c0af486c8"}, + {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:05806de88103b25903dff19bb6692bd2e714ccf9e668d050d144012055cbca73"}, + {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:611052c4bc70432ec770d5d54f64206aa7203a101ec273a0cd82418c86503bb7"}, + {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:50187900d73c1381ba1454cf40308c2bf6f34268518b3f36a9b663ca87e65e36"}, + {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:02615ed8c5ea222323408ceba16c60e99c3f91639b07da6373fb7e6539abc56d"}, + {file = "psutil-5.9.8-cp27-none-win32.whl", hash = "sha256:36f435891adb138ed3c9e58c6af3e2e6ca9ac2f365efe1f9cfef2794e6c93b4e"}, + {file = "psutil-5.9.8-cp27-none-win_amd64.whl", hash = "sha256:bd1184ceb3f87651a67b2708d4c3338e9b10c5df903f2e3776b62303b26cb631"}, + {file = "psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:aee678c8720623dc456fa20659af736241f575d79429a0e5e9cf88ae0605cc81"}, + {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8cb6403ce6d8e047495a701dc7c5bd788add903f8986d523e3e20b98b733e421"}, + {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d06016f7f8625a1825ba3732081d77c94589dca78b7a3fc072194851e88461a4"}, + {file = "psutil-5.9.8-cp36-cp36m-win32.whl", hash = "sha256:7d79560ad97af658a0f6adfef8b834b53f64746d45b403f225b85c5c2c140eee"}, + {file = "psutil-5.9.8-cp36-cp36m-win_amd64.whl", hash = "sha256:27cc40c3493bb10de1be4b3f07cae4c010ce715290a5be22b98493509c6299e2"}, + {file = "psutil-5.9.8-cp37-abi3-win32.whl", hash = "sha256:bc56c2a1b0d15aa3eaa5a60c9f3f8e3e565303b465dbf57a1b730e7a2b9844e0"}, + {file = "psutil-5.9.8-cp37-abi3-win_amd64.whl", hash = "sha256:8db4c1b57507eef143a15a6884ca10f7c73876cdf5d51e713151c1236a0e68cf"}, + {file = "psutil-5.9.8-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:d16bbddf0693323b8c6123dd804100241da461e41d6e332fb0ba6058f630f8c8"}, + {file = "psutil-5.9.8.tar.gz", hash = "sha256:6be126e3225486dff286a8fb9a06246a5253f4c7c53b475ea5f5ac934e64194c"}, +] + +[package.extras] +test = ["enum34", "ipaddress", "mock", "pywin32", "wmi"] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +description = "Run a subprocess in a pseudo terminal" +optional = false +python-versions = "*" +files = [ + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.2" +description = "Safely evaluate AST nodes without side effects" +optional = false +python-versions = "*" +files = [ + {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, + {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, +] + +[package.extras] +tests = ["pytest"] + +[[package]] +name = "pycparser" +version = "2.21" +description = "C parser in Python" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +files = [ + {file = "pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9"}, + {file = "pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"}, +] + +[[package]] +name = "pydantic" +version = "1.10.9" +description = "Data validation and settings management using python type hints" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pydantic-1.10.9-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e692dec4a40bfb40ca530e07805b1208c1de071a18d26af4a2a0d79015b352ca"}, + {file = "pydantic-1.10.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3c52eb595db83e189419bf337b59154bdcca642ee4b2a09e5d7797e41ace783f"}, + {file = "pydantic-1.10.9-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:939328fd539b8d0edf244327398a667b6b140afd3bf7e347cf9813c736211896"}, + {file = "pydantic-1.10.9-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b48d3d634bca23b172f47f2335c617d3fcb4b3ba18481c96b7943a4c634f5c8d"}, + {file = "pydantic-1.10.9-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:f0b7628fb8efe60fe66fd4adadd7ad2304014770cdc1f4934db41fe46cc8825f"}, + {file = "pydantic-1.10.9-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e1aa5c2410769ca28aa9a7841b80d9d9a1c5f223928ca8bec7e7c9a34d26b1d4"}, + {file = "pydantic-1.10.9-cp310-cp310-win_amd64.whl", hash = "sha256:eec39224b2b2e861259d6f3c8b6290d4e0fbdce147adb797484a42278a1a486f"}, + {file = "pydantic-1.10.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d111a21bbbfd85c17248130deac02bbd9b5e20b303338e0dbe0faa78330e37e0"}, + {file = "pydantic-1.10.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2e9aec8627a1a6823fc62fb96480abe3eb10168fd0d859ee3d3b395105ae19a7"}, + {file = "pydantic-1.10.9-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07293ab08e7b4d3c9d7de4949a0ea571f11e4557d19ea24dd3ae0c524c0c334d"}, + {file = "pydantic-1.10.9-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7ee829b86ce984261d99ff2fd6e88f2230068d96c2a582f29583ed602ef3fc2c"}, + {file = "pydantic-1.10.9-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:4b466a23009ff5cdd7076eb56aca537c745ca491293cc38e72bf1e0e00de5b91"}, + {file = "pydantic-1.10.9-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7847ca62e581e6088d9000f3c497267868ca2fa89432714e21a4fb33a04d52e8"}, + {file = "pydantic-1.10.9-cp311-cp311-win_amd64.whl", hash = "sha256:7845b31959468bc5b78d7b95ec52fe5be32b55d0d09983a877cca6aedc51068f"}, + {file = "pydantic-1.10.9-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:517a681919bf880ce1dac7e5bc0c3af1e58ba118fd774da2ffcd93c5f96eaece"}, + {file = "pydantic-1.10.9-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:67195274fd27780f15c4c372f4ba9a5c02dad6d50647b917b6a92bf00b3d301a"}, + {file = "pydantic-1.10.9-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2196c06484da2b3fded1ab6dbe182bdabeb09f6318b7fdc412609ee2b564c49a"}, + {file = "pydantic-1.10.9-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:6257bb45ad78abacda13f15bde5886efd6bf549dd71085e64b8dcf9919c38b60"}, + {file = "pydantic-1.10.9-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:3283b574b01e8dbc982080d8287c968489d25329a463b29a90d4157de4f2baaf"}, + {file = "pydantic-1.10.9-cp37-cp37m-win_amd64.whl", hash = "sha256:5f8bbaf4013b9a50e8100333cc4e3fa2f81214033e05ac5aa44fa24a98670a29"}, + {file = "pydantic-1.10.9-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b9cd67fb763248cbe38f0593cd8611bfe4b8ad82acb3bdf2b0898c23415a1f82"}, + {file = "pydantic-1.10.9-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f50e1764ce9353be67267e7fd0da08349397c7db17a562ad036aa7c8f4adfdb6"}, + {file = "pydantic-1.10.9-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:73ef93e5e1d3c8e83f1ff2e7fdd026d9e063c7e089394869a6e2985696693766"}, + {file = "pydantic-1.10.9-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:128d9453d92e6e81e881dd7e2484e08d8b164da5507f62d06ceecf84bf2e21d3"}, + {file = "pydantic-1.10.9-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ad428e92ab68798d9326bb3e5515bc927444a3d71a93b4a2ca02a8a5d795c572"}, + {file = "pydantic-1.10.9-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:fab81a92f42d6d525dd47ced310b0c3e10c416bbfae5d59523e63ea22f82b31e"}, + {file = "pydantic-1.10.9-cp38-cp38-win_amd64.whl", hash = "sha256:963671eda0b6ba6926d8fc759e3e10335e1dc1b71ff2a43ed2efd6996634dafb"}, + {file = "pydantic-1.10.9-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:970b1bdc6243ef663ba5c7e36ac9ab1f2bfecb8ad297c9824b542d41a750b298"}, + {file = "pydantic-1.10.9-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7e1d5290044f620f80cf1c969c542a5468f3656de47b41aa78100c5baa2b8276"}, + {file = "pydantic-1.10.9-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:83fcff3c7df7adff880622a98022626f4f6dbce6639a88a15a3ce0f96466cb60"}, + {file = "pydantic-1.10.9-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0da48717dc9495d3a8f215e0d012599db6b8092db02acac5e0d58a65248ec5bc"}, + {file = "pydantic-1.10.9-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:0a2aabdc73c2a5960e87c3ffebca6ccde88665616d1fd6d3db3178ef427b267a"}, + {file = "pydantic-1.10.9-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9863b9420d99dfa9c064042304868e8ba08e89081428a1c471858aa2af6f57c4"}, + {file = "pydantic-1.10.9-cp39-cp39-win_amd64.whl", hash = "sha256:e7c9900b43ac14110efa977be3da28931ffc74c27e96ee89fbcaaf0b0fe338e1"}, + {file = "pydantic-1.10.9-py3-none-any.whl", hash = "sha256:6cafde02f6699ce4ff643417d1a9223716ec25e228ddc3b436fe7e2d25a1f305"}, + {file = "pydantic-1.10.9.tar.gz", hash = "sha256:95c70da2cd3b6ddf3b9645ecaa8d98f3d80c606624b6d245558d202cd23ea3be"}, +] + +[package.dependencies] +typing-extensions = ">=4.2.0" + +[package.extras] +dotenv = ["python-dotenv (>=0.10.4)"] +email = ["email-validator (>=1.0.3)"] + +[[package]] +name = "pygments" +version = "2.17.2" +description = "Pygments is a syntax highlighting package written in Python." +optional = false +python-versions = ">=3.7" +files = [ + {file = "pygments-2.17.2-py3-none-any.whl", hash = "sha256:b27c2826c47d0f3219f29554824c30c5e8945175d888647acd804ddd04af846c"}, + {file = "pygments-2.17.2.tar.gz", hash = "sha256:da46cec9fd2de5be3a8a784f434e4c4ab670b4ff54d605c4c2717e9d49c4c367"}, +] + +[package.extras] +plugins = ["importlib-metadata"] +windows-terminal = ["colorama (>=0.4.6)"] + +[[package]] +name = "pylint" +version = "2.15.10" +description = "python code static checker" +optional = false +python-versions = ">=3.7.2" +files = [ + {file = "pylint-2.15.10-py3-none-any.whl", hash = "sha256:9df0d07e8948a1c3ffa3b6e2d7e6e63d9fb457c5da5b961ed63106594780cc7e"}, + {file = "pylint-2.15.10.tar.gz", hash = "sha256:b3dc5ef7d33858f297ac0d06cc73862f01e4f2e74025ec3eff347ce0bc60baf5"}, +] + +[package.dependencies] +astroid = ">=2.12.13,<=2.14.0-dev0" +colorama = {version = ">=0.4.5", markers = "sys_platform == \"win32\""} +dill = [ + {version = ">=0.2", markers = "python_version < \"3.11\""}, + {version = ">=0.3.6", markers = "python_version >= \"3.11\""}, +] +isort = ">=4.2.5,<6" +mccabe = ">=0.6,<0.8" +platformdirs = ">=2.2.0" +tomli = {version = ">=1.1.0", markers = "python_version < \"3.11\""} +tomlkit = ">=0.10.1" +typing-extensions = {version = ">=3.10.0", markers = "python_version < \"3.10\""} + +[package.extras] +spelling = ["pyenchant (>=3.2,<4.0)"] +testutils = ["gitpython (>3)"] + +[[package]] +name = "pytest" +version = "7.2.1" +description = "pytest: simple powerful testing with Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pytest-7.2.1-py3-none-any.whl", hash = "sha256:c7c6ca206e93355074ae32f7403e8ea12163b1163c976fee7d4d84027c162be5"}, + {file = "pytest-7.2.1.tar.gz", hash = "sha256:d45e0952f3727241918b8fd0f376f5ff6b301cc0777c6f9a556935c92d8a7d42"}, +] + +[package.dependencies] +attrs = ">=19.2.0" +colorama = {version = "*", markers = "sys_platform == \"win32\""} +exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} +iniconfig = "*" +packaging = "*" +pluggy = ">=0.12,<2.0" +tomli = {version = ">=1.0.0", markers = "python_version < \"3.11\""} + +[package.extras] +testing = ["argcomplete", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "xmlschema"] + +[[package]] +name = "pytest-mock" +version = "3.11.1" +description = "Thin-wrapper around the mock package for easier use with pytest" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pytest-mock-3.11.1.tar.gz", hash = "sha256:7f6b125602ac6d743e523ae0bfa71e1a697a2f5534064528c6ff84c2f7c2fc7f"}, + {file = "pytest_mock-3.11.1-py3-none-any.whl", hash = "sha256:21c279fff83d70763b05f8874cc9cfb3fcacd6d354247a976f9529d19f9acf39"}, +] + +[package.dependencies] +pytest = ">=5.0" + +[package.extras] +dev = ["pre-commit", "pytest-asyncio", "tox"] + +[[package]] +name = "python-dateutil" +version = "2.8.2" +description = "Extensions to the standard Python datetime module" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" +files = [ + {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"}, + {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"}, +] + +[package.dependencies] +six = ">=1.5" + +[[package]] +name = "python-json-logger" +version = "2.0.7" +description = "A python library adding a json log formatter" +optional = false +python-versions = ">=3.6" +files = [ + {file = "python-json-logger-2.0.7.tar.gz", hash = "sha256:23e7ec02d34237c5aa1e29a070193a4ea87583bb4e7f8fd06d3de8264c4b2e1c"}, + {file = "python_json_logger-2.0.7-py3-none-any.whl", hash = "sha256:f380b826a991ebbe3de4d897aeec42760035ac760345e57b812938dc8b35e2bd"}, +] + +[[package]] +name = "pytz" +version = "2024.1" +description = "World timezone definitions, modern and historical" +optional = false +python-versions = "*" +files = [ + {file = "pytz-2024.1-py2.py3-none-any.whl", hash = "sha256:328171f4e3623139da4983451950b28e95ac706e13f3f2630a879749e7a8b319"}, + {file = "pytz-2024.1.tar.gz", hash = "sha256:2a29735ea9c18baf14b448846bde5a48030ed267578472d8955cd0e7443a9812"}, +] + +[[package]] +name = "pywin32" +version = "306" +description = "Python for Window Extensions" +optional = false +python-versions = "*" +files = [ + {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"}, + {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"}, + {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"}, + {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"}, + {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"}, + {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"}, + {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"}, + {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"}, + {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"}, + {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"}, + {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"}, + {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"}, + {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"}, + {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"}, +] + +[[package]] +name = "pywinpty" +version = "2.0.12" +description = "Pseudo terminal support for Windows from Python." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pywinpty-2.0.12-cp310-none-win_amd64.whl", hash = "sha256:21319cd1d7c8844fb2c970fb3a55a3db5543f112ff9cfcd623746b9c47501575"}, + {file = "pywinpty-2.0.12-cp311-none-win_amd64.whl", hash = "sha256:853985a8f48f4731a716653170cd735da36ffbdc79dcb4c7b7140bce11d8c722"}, + {file = "pywinpty-2.0.12-cp312-none-win_amd64.whl", hash = "sha256:1617b729999eb6713590e17665052b1a6ae0ad76ee31e60b444147c5b6a35dca"}, + {file = "pywinpty-2.0.12-cp38-none-win_amd64.whl", hash = "sha256:189380469ca143d06e19e19ff3fba0fcefe8b4a8cc942140a6b863aed7eebb2d"}, + {file = "pywinpty-2.0.12-cp39-none-win_amd64.whl", hash = "sha256:7520575b6546db23e693cbd865db2764097bd6d4ef5dc18c92555904cd62c3d4"}, + {file = "pywinpty-2.0.12.tar.gz", hash = "sha256:8197de460ae8ebb7f5d1701dfa1b5df45b157bb832e92acba316305e18ca00dd"}, +] + +[[package]] +name = "pyyaml" +version = "6.0.1" +description = "YAML parser and emitter for Python" +optional = false +python-versions = ">=3.6" +files = [ + {file = "PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a"}, + {file = "PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d"}, + {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515"}, + {file = "PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290"}, + {file = "PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924"}, + {file = "PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d"}, + {file = "PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007"}, + {file = "PyYAML-6.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f003ed9ad21d6a4713f0a9b5a7a0a79e08dd0f221aff4525a2be4c346ee60aab"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc"}, + {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673"}, + {file = "PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b"}, + {file = "PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741"}, + {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"}, + {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"}, + {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a08c6f0fe150303c1c6b71ebcd7213c2858041a7e01975da3a99aed1e7a378ef"}, + {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"}, + {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"}, + {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"}, + {file = "PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df"}, + {file = "PyYAML-6.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50550eb667afee136e9a77d6dc71ae76a44df8b3e51e41b77f6de2932bfe0f47"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe35611261b29bd1de0070f0b2f47cb6ff71fa6595c077e42bd0c419fa27b98"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704219a11b772aea0d8ecd7058d0082713c3562b4e271b849ad7dc4a5c90c13c"}, + {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:afd7e57eddb1a54f0f1a974bc4391af8bcce0b444685d936840f125cf046d5bd"}, + {file = "PyYAML-6.0.1-cp36-cp36m-win32.whl", hash = "sha256:fca0e3a251908a499833aa292323f32437106001d436eca0e6e7833256674585"}, + {file = "PyYAML-6.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f22ac1c3cac4dbc50079e965eba2c1058622631e526bd9afd45fedd49ba781fa"}, + {file = "PyYAML-6.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b1275ad35a5d18c62a7220633c913e1b42d44b46ee12554e5fd39c70a243d6a3"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18aeb1bf9a78867dc38b259769503436b7c72f7a1f1f4c93ff9a17de54319b27"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:596106435fa6ad000c2991a98fa58eeb8656ef2325d7e158344fb33864ed87e3"}, + {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa90d3f661d43131ca170712d903e6295d1f7a0f595074f151c0aed377c9b9c"}, + {file = "PyYAML-6.0.1-cp37-cp37m-win32.whl", hash = "sha256:9046c58c4395dff28dd494285c82ba00b546adfc7ef001486fbf0324bc174fba"}, + {file = "PyYAML-6.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4fb147e7a67ef577a588a0e2c17b6db51dda102c71de36f8549b6816a96e1867"}, + {file = "PyYAML-6.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1d4c7e777c441b20e32f52bd377e0c409713e8bb1386e1099c2415f26e479595"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696"}, + {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735"}, + {file = "PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6"}, + {file = "PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206"}, + {file = "PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62"}, + {file = "PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8"}, + {file = "PyYAML-6.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c8098ddcc2a85b61647b2590f825f3db38891662cfc2fc776415143f599bb859"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0"}, + {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c"}, + {file = "PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5"}, + {file = "PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c"}, + {file = "PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486"}, + {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"}, +] + +[[package]] +name = "pyzmq" +version = "25.1.2" +description = "Python bindings for 0MQ" +optional = false +python-versions = ">=3.6" +files = [ + {file = "pyzmq-25.1.2-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:e624c789359f1a16f83f35e2c705d07663ff2b4d4479bad35621178d8f0f6ea4"}, + {file = "pyzmq-25.1.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:49151b0efece79f6a79d41a461d78535356136ee70084a1c22532fc6383f4ad0"}, + {file = "pyzmq-25.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d9a5f194cf730f2b24d6af1f833c14c10f41023da46a7f736f48b6d35061e76e"}, + {file = "pyzmq-25.1.2-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:faf79a302f834d9e8304fafdc11d0d042266667ac45209afa57e5efc998e3872"}, + {file = "pyzmq-25.1.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f51a7b4ead28d3fca8dda53216314a553b0f7a91ee8fc46a72b402a78c3e43d"}, + {file = "pyzmq-25.1.2-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:0ddd6d71d4ef17ba5a87becf7ddf01b371eaba553c603477679ae817a8d84d75"}, + {file = "pyzmq-25.1.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:246747b88917e4867e2367b005fc8eefbb4a54b7db363d6c92f89d69abfff4b6"}, + {file = "pyzmq-25.1.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:00c48ae2fd81e2a50c3485de1b9d5c7c57cd85dc8ec55683eac16846e57ac979"}, + {file = "pyzmq-25.1.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:5a68d491fc20762b630e5db2191dd07ff89834086740f70e978bb2ef2668be08"}, + {file = "pyzmq-25.1.2-cp310-cp310-win32.whl", hash = "sha256:09dfe949e83087da88c4a76767df04b22304a682d6154de2c572625c62ad6886"}, + {file = "pyzmq-25.1.2-cp310-cp310-win_amd64.whl", hash = "sha256:fa99973d2ed20417744fca0073390ad65ce225b546febb0580358e36aa90dba6"}, + {file = "pyzmq-25.1.2-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:82544e0e2d0c1811482d37eef297020a040c32e0687c1f6fc23a75b75db8062c"}, + {file = "pyzmq-25.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:01171fc48542348cd1a360a4b6c3e7d8f46cdcf53a8d40f84db6707a6768acc1"}, + {file = "pyzmq-25.1.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bc69c96735ab501419c432110016329bf0dea8898ce16fab97c6d9106dc0b348"}, + {file = "pyzmq-25.1.2-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3e124e6b1dd3dfbeb695435dff0e383256655bb18082e094a8dd1f6293114642"}, + {file = "pyzmq-25.1.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7598d2ba821caa37a0f9d54c25164a4fa351ce019d64d0b44b45540950458840"}, + {file = "pyzmq-25.1.2-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:d1299d7e964c13607efd148ca1f07dcbf27c3ab9e125d1d0ae1d580a1682399d"}, + {file = "pyzmq-25.1.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:4e6f689880d5ad87918430957297c975203a082d9a036cc426648fcbedae769b"}, + {file = "pyzmq-25.1.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:cc69949484171cc961e6ecd4a8911b9ce7a0d1f738fcae717177c231bf77437b"}, + {file = "pyzmq-25.1.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9880078f683466b7f567b8624bfc16cad65077be046b6e8abb53bed4eeb82dd3"}, + {file = "pyzmq-25.1.2-cp311-cp311-win32.whl", hash = "sha256:4e5837af3e5aaa99a091302df5ee001149baff06ad22b722d34e30df5f0d9097"}, + {file = "pyzmq-25.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:25c2dbb97d38b5ac9fd15586e048ec5eb1e38f3d47fe7d92167b0c77bb3584e9"}, + {file = "pyzmq-25.1.2-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:11e70516688190e9c2db14fcf93c04192b02d457b582a1f6190b154691b4c93a"}, + {file = "pyzmq-25.1.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:313c3794d650d1fccaaab2df942af9f2c01d6217c846177cfcbc693c7410839e"}, + {file = "pyzmq-25.1.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b3cbba2f47062b85fe0ef9de5b987612140a9ba3a9c6d2543c6dec9f7c2ab27"}, + {file = "pyzmq-25.1.2-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fc31baa0c32a2ca660784d5af3b9487e13b61b3032cb01a115fce6588e1bed30"}, + {file = "pyzmq-25.1.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:02c9087b109070c5ab0b383079fa1b5f797f8d43e9a66c07a4b8b8bdecfd88ee"}, + {file = "pyzmq-25.1.2-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:f8429b17cbb746c3e043cb986328da023657e79d5ed258b711c06a70c2ea7537"}, + {file = "pyzmq-25.1.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:5074adeacede5f810b7ef39607ee59d94e948b4fd954495bdb072f8c54558181"}, + {file = "pyzmq-25.1.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:7ae8f354b895cbd85212da245f1a5ad8159e7840e37d78b476bb4f4c3f32a9fe"}, + {file = "pyzmq-25.1.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:b264bf2cc96b5bc43ce0e852be995e400376bd87ceb363822e2cb1964fcdc737"}, + {file = "pyzmq-25.1.2-cp312-cp312-win32.whl", hash = "sha256:02bbc1a87b76e04fd780b45e7f695471ae6de747769e540da909173d50ff8e2d"}, + {file = "pyzmq-25.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:ced111c2e81506abd1dc142e6cd7b68dd53747b3b7ae5edbea4578c5eeff96b7"}, + {file = "pyzmq-25.1.2-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:7b6d09a8962a91151f0976008eb7b29b433a560fde056ec7a3db9ec8f1075438"}, + {file = "pyzmq-25.1.2-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:967668420f36878a3c9ecb5ab33c9d0ff8d054f9c0233d995a6d25b0e95e1b6b"}, + {file = "pyzmq-25.1.2-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5edac3f57c7ddaacdb4d40f6ef2f9e299471fc38d112f4bc6d60ab9365445fb0"}, + {file = "pyzmq-25.1.2-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:0dabfb10ef897f3b7e101cacba1437bd3a5032ee667b7ead32bbcdd1a8422fe7"}, + {file = "pyzmq-25.1.2-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:2c6441e0398c2baacfe5ba30c937d274cfc2dc5b55e82e3749e333aabffde561"}, + {file = "pyzmq-25.1.2-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:16b726c1f6c2e7625706549f9dbe9b06004dfbec30dbed4bf50cbdfc73e5b32a"}, + {file = "pyzmq-25.1.2-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:a86c2dd76ef71a773e70551a07318b8e52379f58dafa7ae1e0a4be78efd1ff16"}, + {file = "pyzmq-25.1.2-cp36-cp36m-win32.whl", hash = "sha256:359f7f74b5d3c65dae137f33eb2bcfa7ad9ebefd1cab85c935f063f1dbb245cc"}, + {file = "pyzmq-25.1.2-cp36-cp36m-win_amd64.whl", hash = "sha256:55875492f820d0eb3417b51d96fea549cde77893ae3790fd25491c5754ea2f68"}, + {file = "pyzmq-25.1.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b8c8a419dfb02e91b453615c69568442e897aaf77561ee0064d789705ff37a92"}, + {file = "pyzmq-25.1.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8807c87fa893527ae8a524c15fc505d9950d5e856f03dae5921b5e9aa3b8783b"}, + {file = "pyzmq-25.1.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5e319ed7d6b8f5fad9b76daa0a68497bc6f129858ad956331a5835785761e003"}, + {file = "pyzmq-25.1.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:3c53687dde4d9d473c587ae80cc328e5b102b517447456184b485587ebd18b62"}, + {file = "pyzmq-25.1.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:9add2e5b33d2cd765ad96d5eb734a5e795a0755f7fc49aa04f76d7ddda73fd70"}, + {file = "pyzmq-25.1.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:e690145a8c0c273c28d3b89d6fb32c45e0d9605b2293c10e650265bf5c11cfec"}, + {file = "pyzmq-25.1.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:00a06faa7165634f0cac1abb27e54d7a0b3b44eb9994530b8ec73cf52e15353b"}, + {file = "pyzmq-25.1.2-cp37-cp37m-win32.whl", hash = "sha256:0f97bc2f1f13cb16905a5f3e1fbdf100e712d841482b2237484360f8bc4cb3d7"}, + {file = "pyzmq-25.1.2-cp37-cp37m-win_amd64.whl", hash = "sha256:6cc0020b74b2e410287e5942e1e10886ff81ac77789eb20bec13f7ae681f0fdd"}, + {file = "pyzmq-25.1.2-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:bef02cfcbded83473bdd86dd8d3729cd82b2e569b75844fb4ea08fee3c26ae41"}, + {file = "pyzmq-25.1.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e10a4b5a4b1192d74853cc71a5e9fd022594573926c2a3a4802020360aa719d8"}, + {file = "pyzmq-25.1.2-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8c5f80e578427d4695adac6fdf4370c14a2feafdc8cb35549c219b90652536ae"}, + {file = "pyzmq-25.1.2-cp38-cp38-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:5dde6751e857910c1339890f3524de74007958557593b9e7e8c5f01cd919f8a7"}, + {file = "pyzmq-25.1.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ea1608dd169da230a0ad602d5b1ebd39807ac96cae1845c3ceed39af08a5c6df"}, + {file = "pyzmq-25.1.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0f513130c4c361201da9bc69df25a086487250e16b5571ead521b31ff6b02220"}, + {file = "pyzmq-25.1.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:019744b99da30330798bb37df33549d59d380c78e516e3bab9c9b84f87a9592f"}, + {file = "pyzmq-25.1.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:2e2713ef44be5d52dd8b8e2023d706bf66cb22072e97fc71b168e01d25192755"}, + {file = "pyzmq-25.1.2-cp38-cp38-win32.whl", hash = "sha256:07cd61a20a535524906595e09344505a9bd46f1da7a07e504b315d41cd42eb07"}, + {file = "pyzmq-25.1.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb7e49a17fb8c77d3119d41a4523e432eb0c6932187c37deb6fbb00cc3028088"}, + {file = "pyzmq-25.1.2-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:94504ff66f278ab4b7e03e4cba7e7e400cb73bfa9d3d71f58d8972a8dc67e7a6"}, + {file = "pyzmq-25.1.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6dd0d50bbf9dca1d0bdea219ae6b40f713a3fb477c06ca3714f208fd69e16fd8"}, + {file = "pyzmq-25.1.2-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:004ff469d21e86f0ef0369717351073e0e577428e514c47c8480770d5e24a565"}, + {file = "pyzmq-25.1.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:c0b5ca88a8928147b7b1e2dfa09f3b6c256bc1135a1338536cbc9ea13d3b7add"}, + {file = "pyzmq-25.1.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c9a79f1d2495b167119d02be7448bfba57fad2a4207c4f68abc0bab4b92925b"}, + {file = "pyzmq-25.1.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:518efd91c3d8ac9f9b4f7dd0e2b7b8bf1a4fe82a308009016b07eaa48681af82"}, + {file = "pyzmq-25.1.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:1ec23bd7b3a893ae676d0e54ad47d18064e6c5ae1fadc2f195143fb27373f7f6"}, + {file = "pyzmq-25.1.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:db36c27baed588a5a8346b971477b718fdc66cf5b80cbfbd914b4d6d355e44e2"}, + {file = "pyzmq-25.1.2-cp39-cp39-win32.whl", hash = "sha256:39b1067f13aba39d794a24761e385e2eddc26295826530a8c7b6c6c341584289"}, + {file = "pyzmq-25.1.2-cp39-cp39-win_amd64.whl", hash = "sha256:8e9f3fabc445d0ce320ea2c59a75fe3ea591fdbdeebec5db6de530dd4b09412e"}, + {file = "pyzmq-25.1.2-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a8c1d566344aee826b74e472e16edae0a02e2a044f14f7c24e123002dcff1c05"}, + {file = "pyzmq-25.1.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:759cfd391a0996345ba94b6a5110fca9c557ad4166d86a6e81ea526c376a01e8"}, + {file = "pyzmq-25.1.2-pp310-pypy310_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7c61e346ac34b74028ede1c6b4bcecf649d69b707b3ff9dc0fab453821b04d1e"}, + {file = "pyzmq-25.1.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4cb8fc1f8d69b411b8ec0b5f1ffbcaf14c1db95b6bccea21d83610987435f1a4"}, + {file = "pyzmq-25.1.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:3c00c9b7d1ca8165c610437ca0c92e7b5607b2f9076f4eb4b095c85d6e680a1d"}, + {file = "pyzmq-25.1.2-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:df0c7a16ebb94452d2909b9a7b3337940e9a87a824c4fc1c7c36bb4404cb0cde"}, + {file = "pyzmq-25.1.2-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:45999e7f7ed5c390f2e87ece7f6c56bf979fb213550229e711e45ecc7d42ccb8"}, + {file = "pyzmq-25.1.2-pp37-pypy37_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ac170e9e048b40c605358667aca3d94e98f604a18c44bdb4c102e67070f3ac9b"}, + {file = "pyzmq-25.1.2-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1b604734bec94f05f81b360a272fc824334267426ae9905ff32dc2be433ab96"}, + {file = "pyzmq-25.1.2-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:a793ac733e3d895d96f865f1806f160696422554e46d30105807fdc9841b9f7d"}, + {file = "pyzmq-25.1.2-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0806175f2ae5ad4b835ecd87f5f85583316b69f17e97786f7443baaf54b9bb98"}, + {file = "pyzmq-25.1.2-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:ef12e259e7bc317c7597d4f6ef59b97b913e162d83b421dd0db3d6410f17a244"}, + {file = "pyzmq-25.1.2-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:ea253b368eb41116011add00f8d5726762320b1bda892f744c91997b65754d73"}, + {file = "pyzmq-25.1.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b9b1f2ad6498445a941d9a4fee096d387fee436e45cc660e72e768d3d8ee611"}, + {file = "pyzmq-25.1.2-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:8b14c75979ce932c53b79976a395cb2a8cd3aaf14aef75e8c2cb55a330b9b49d"}, + {file = "pyzmq-25.1.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:889370d5174a741a62566c003ee8ddba4b04c3f09a97b8000092b7ca83ec9c49"}, + {file = "pyzmq-25.1.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9a18fff090441a40ffda8a7f4f18f03dc56ae73f148f1832e109f9bffa85df15"}, + {file = "pyzmq-25.1.2-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:99a6b36f95c98839ad98f8c553d8507644c880cf1e0a57fe5e3a3f3969040882"}, + {file = "pyzmq-25.1.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4345c9a27f4310afbb9c01750e9461ff33d6fb74cd2456b107525bbeebcb5be3"}, + {file = "pyzmq-25.1.2-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:3516e0b6224cf6e43e341d56da15fd33bdc37fa0c06af4f029f7d7dfceceabbc"}, + {file = "pyzmq-25.1.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:146b9b1f29ead41255387fb07be56dc29639262c0f7344f570eecdcd8d683314"}, + {file = "pyzmq-25.1.2.tar.gz", hash = "sha256:93f1aa311e8bb912e34f004cf186407a4e90eec4f0ecc0efd26056bf7eda0226"}, +] + +[package.dependencies] +cffi = {version = "*", markers = "implementation_name == \"pypy\""} + +[[package]] +name = "qtconsole" +version = "5.5.1" +description = "Jupyter Qt console" +optional = false +python-versions = ">= 3.8" +files = [ + {file = "qtconsole-5.5.1-py3-none-any.whl", hash = "sha256:8c75fa3e9b4ed884880ff7cea90a1b67451219279ec33deaee1d59e3df1a5d2b"}, + {file = "qtconsole-5.5.1.tar.gz", hash = "sha256:a0e806c6951db9490628e4df80caec9669b65149c7ba40f9bf033c025a5b56bc"}, +] + +[package.dependencies] +ipykernel = ">=4.1" +jupyter-client = ">=4.1" +jupyter-core = "*" +packaging = "*" +pygments = "*" +pyzmq = ">=17.1" +qtpy = ">=2.4.0" +traitlets = "<5.2.1 || >5.2.1,<5.2.2 || >5.2.2" + +[package.extras] +doc = ["Sphinx (>=1.3)"] +test = ["flaky", "pytest", "pytest-qt"] + +[[package]] +name = "qtpy" +version = "2.4.1" +description = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." +optional = false +python-versions = ">=3.7" +files = [ + {file = "QtPy-2.4.1-py3-none-any.whl", hash = "sha256:1c1d8c4fa2c884ae742b069151b0abe15b3f70491f3972698c683b8e38de839b"}, + {file = "QtPy-2.4.1.tar.gz", hash = "sha256:a5a15ffd519550a1361bdc56ffc07fda56a6af7292f17c7b395d4083af632987"}, +] + +[package.dependencies] +packaging = "*" + +[package.extras] +test = ["pytest (>=6,!=7.0.0,!=7.0.1)", "pytest-cov (>=3.0.0)", "pytest-qt"] + +[[package]] +name = "referencing" +version = "0.33.0" +description = "JSON Referencing + Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "referencing-0.33.0-py3-none-any.whl", hash = "sha256:39240f2ecc770258f28b642dd47fd74bc8b02484de54e1882b74b35ebd779bd5"}, + {file = "referencing-0.33.0.tar.gz", hash = "sha256:c775fedf74bc0f9189c2a3be1c12fd03e8c23f4d371dce795df44e06c5b412f7"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +rpds-py = ">=0.7.0" + +[[package]] +name = "regex" +version = "2023.12.25" +description = "Alternative regular expression module, to replace re." +optional = false +python-versions = ">=3.7" +files = [ + {file = "regex-2023.12.25-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0694219a1d54336fd0445ea382d49d36882415c0134ee1e8332afd1529f0baa5"}, + {file = "regex-2023.12.25-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b014333bd0217ad3d54c143de9d4b9a3ca1c5a29a6d0d554952ea071cff0f1f8"}, + {file = "regex-2023.12.25-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d865984b3f71f6d0af64d0d88f5733521698f6c16f445bb09ce746c92c97c586"}, + {file = "regex-2023.12.25-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e0eabac536b4cc7f57a5f3d095bfa557860ab912f25965e08fe1545e2ed8b4c"}, + {file = "regex-2023.12.25-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c25a8ad70e716f96e13a637802813f65d8a6760ef48672aa3502f4c24ea8b400"}, + {file = "regex-2023.12.25-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a9b6d73353f777630626f403b0652055ebfe8ff142a44ec2cf18ae470395766e"}, + {file = "regex-2023.12.25-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9cc99d6946d750eb75827cb53c4371b8b0fe89c733a94b1573c9dd16ea6c9e4"}, + {file = "regex-2023.12.25-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:88d1f7bef20c721359d8675f7d9f8e414ec5003d8f642fdfd8087777ff7f94b5"}, + {file = "regex-2023.12.25-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:cb3fe77aec8f1995611f966d0c656fdce398317f850d0e6e7aebdfe61f40e1cd"}, + {file = "regex-2023.12.25-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:7aa47c2e9ea33a4a2a05f40fcd3ea36d73853a2aae7b4feab6fc85f8bf2c9704"}, + {file = "regex-2023.12.25-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:df26481f0c7a3f8739fecb3e81bc9da3fcfae34d6c094563b9d4670b047312e1"}, + {file = "regex-2023.12.25-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:c40281f7d70baf6e0db0c2f7472b31609f5bc2748fe7275ea65a0b4601d9b392"}, + {file = "regex-2023.12.25-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:d94a1db462d5690ebf6ae86d11c5e420042b9898af5dcf278bd97d6bda065423"}, + {file = "regex-2023.12.25-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:ba1b30765a55acf15dce3f364e4928b80858fa8f979ad41f862358939bdd1f2f"}, + {file = "regex-2023.12.25-cp310-cp310-win32.whl", hash = "sha256:150c39f5b964e4d7dba46a7962a088fbc91f06e606f023ce57bb347a3b2d4630"}, + {file = "regex-2023.12.25-cp310-cp310-win_amd64.whl", hash = "sha256:09da66917262d9481c719599116c7dc0c321ffcec4b1f510c4f8a066f8768105"}, + {file = "regex-2023.12.25-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1b9d811f72210fa9306aeb88385b8f8bcef0dfbf3873410413c00aa94c56c2b6"}, + {file = "regex-2023.12.25-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:d902a43085a308cef32c0d3aea962524b725403fd9373dea18110904003bac97"}, + {file = "regex-2023.12.25-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d166eafc19f4718df38887b2bbe1467a4f74a9830e8605089ea7a30dd4da8887"}, + {file = "regex-2023.12.25-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c7ad32824b7f02bb3c9f80306d405a1d9b7bb89362d68b3c5a9be53836caebdb"}, + {file = "regex-2023.12.25-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:636ba0a77de609d6510235b7f0e77ec494d2657108f777e8765efc060094c98c"}, + {file = "regex-2023.12.25-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fda75704357805eb953a3ee15a2b240694a9a514548cd49b3c5124b4e2ad01b"}, + {file = "regex-2023.12.25-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f72cbae7f6b01591f90814250e636065850c5926751af02bb48da94dfced7baa"}, + {file = "regex-2023.12.25-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:db2a0b1857f18b11e3b0e54ddfefc96af46b0896fb678c85f63fb8c37518b3e7"}, + {file = "regex-2023.12.25-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:7502534e55c7c36c0978c91ba6f61703faf7ce733715ca48f499d3dbbd7657e0"}, + {file = "regex-2023.12.25-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:e8c7e08bb566de4faaf11984af13f6bcf6a08f327b13631d41d62592681d24fe"}, + {file = "regex-2023.12.25-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:283fc8eed679758de38fe493b7d7d84a198b558942b03f017b1f94dda8efae80"}, + {file = "regex-2023.12.25-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:f44dd4d68697559d007462b0a3a1d9acd61d97072b71f6d1968daef26bc744bd"}, + {file = "regex-2023.12.25-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:67d3ccfc590e5e7197750fcb3a2915b416a53e2de847a728cfa60141054123d4"}, + {file = "regex-2023.12.25-cp311-cp311-win32.whl", hash = "sha256:68191f80a9bad283432385961d9efe09d783bcd36ed35a60fb1ff3f1ec2efe87"}, + {file = "regex-2023.12.25-cp311-cp311-win_amd64.whl", hash = "sha256:7d2af3f6b8419661a0c421584cfe8aaec1c0e435ce7e47ee2a97e344b98f794f"}, + {file = "regex-2023.12.25-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:8a0ccf52bb37d1a700375a6b395bff5dd15c50acb745f7db30415bae3c2b0715"}, + {file = "regex-2023.12.25-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c3c4a78615b7762740531c27cf46e2f388d8d727d0c0c739e72048beb26c8a9d"}, + {file = "regex-2023.12.25-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ad83e7545b4ab69216cef4cc47e344d19622e28aabec61574b20257c65466d6a"}, + {file = "regex-2023.12.25-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b7a635871143661feccce3979e1727c4e094f2bdfd3ec4b90dfd4f16f571a87a"}, + {file = "regex-2023.12.25-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d498eea3f581fbe1b34b59c697512a8baef88212f92e4c7830fcc1499f5b45a5"}, + {file = "regex-2023.12.25-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:43f7cd5754d02a56ae4ebb91b33461dc67be8e3e0153f593c509e21d219c5060"}, + {file = "regex-2023.12.25-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51f4b32f793812714fd5307222a7f77e739b9bc566dc94a18126aba3b92b98a3"}, + {file = "regex-2023.12.25-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ba99d8077424501b9616b43a2d208095746fb1284fc5ba490139651f971d39d9"}, + {file = "regex-2023.12.25-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:4bfc2b16e3ba8850e0e262467275dd4d62f0d045e0e9eda2bc65078c0110a11f"}, + {file = "regex-2023.12.25-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8c2c19dae8a3eb0ea45a8448356ed561be843b13cbc34b840922ddf565498c1c"}, + {file = "regex-2023.12.25-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:60080bb3d8617d96f0fb7e19796384cc2467447ef1c491694850ebd3670bc457"}, + {file = "regex-2023.12.25-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b77e27b79448e34c2c51c09836033056a0547aa360c45eeeb67803da7b0eedaf"}, + {file = "regex-2023.12.25-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:518440c991f514331f4850a63560321f833979d145d7d81186dbe2f19e27ae3d"}, + {file = "regex-2023.12.25-cp312-cp312-win32.whl", hash = "sha256:e2610e9406d3b0073636a3a2e80db05a02f0c3169b5632022b4e81c0364bcda5"}, + {file = "regex-2023.12.25-cp312-cp312-win_amd64.whl", hash = "sha256:cc37b9aeebab425f11f27e5e9e6cf580be7206c6582a64467a14dda211abc232"}, + {file = "regex-2023.12.25-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:da695d75ac97cb1cd725adac136d25ca687da4536154cdc2815f576e4da11c69"}, + {file = "regex-2023.12.25-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d126361607b33c4eb7b36debc173bf25d7805847346dd4d99b5499e1fef52bc7"}, + {file = "regex-2023.12.25-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4719bb05094d7d8563a450cf8738d2e1061420f79cfcc1fa7f0a44744c4d8f73"}, + {file = "regex-2023.12.25-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5dd58946bce44b53b06d94aa95560d0b243eb2fe64227cba50017a8d8b3cd3e2"}, + {file = "regex-2023.12.25-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22a86d9fff2009302c440b9d799ef2fe322416d2d58fc124b926aa89365ec482"}, + {file = "regex-2023.12.25-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2aae8101919e8aa05ecfe6322b278f41ce2994c4a430303c4cd163fef746e04f"}, + {file = "regex-2023.12.25-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:e692296c4cc2873967771345a876bcfc1c547e8dd695c6b89342488b0ea55cd8"}, + {file = "regex-2023.12.25-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:263ef5cc10979837f243950637fffb06e8daed7f1ac1e39d5910fd29929e489a"}, + {file = "regex-2023.12.25-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:d6f7e255e5fa94642a0724e35406e6cb7001c09d476ab5fce002f652b36d0c39"}, + {file = "regex-2023.12.25-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:88ad44e220e22b63b0f8f81f007e8abbb92874d8ced66f32571ef8beb0643b2b"}, + {file = "regex-2023.12.25-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:3a17d3ede18f9cedcbe23d2daa8a2cd6f59fe2bf082c567e43083bba3fb00347"}, + {file = "regex-2023.12.25-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:d15b274f9e15b1a0b7a45d2ac86d1f634d983ca40d6b886721626c47a400bf39"}, + {file = "regex-2023.12.25-cp37-cp37m-win32.whl", hash = "sha256:ed19b3a05ae0c97dd8f75a5d8f21f7723a8c33bbc555da6bbe1f96c470139d3c"}, + {file = "regex-2023.12.25-cp37-cp37m-win_amd64.whl", hash = "sha256:a6d1047952c0b8104a1d371f88f4ab62e6275567d4458c1e26e9627ad489b445"}, + {file = "regex-2023.12.25-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:b43523d7bc2abd757119dbfb38af91b5735eea45537ec6ec3a5ec3f9562a1c53"}, + {file = "regex-2023.12.25-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:efb2d82f33b2212898f1659fb1c2e9ac30493ac41e4d53123da374c3b5541e64"}, + {file = "regex-2023.12.25-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b7fca9205b59c1a3d5031f7e64ed627a1074730a51c2a80e97653e3e9fa0d415"}, + {file = "regex-2023.12.25-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:086dd15e9435b393ae06f96ab69ab2d333f5d65cbe65ca5a3ef0ec9564dfe770"}, + {file = "regex-2023.12.25-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e81469f7d01efed9b53740aedd26085f20d49da65f9c1f41e822a33992cb1590"}, + {file = "regex-2023.12.25-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:34e4af5b27232f68042aa40a91c3b9bb4da0eeb31b7632e0091afc4310afe6cb"}, + {file = "regex-2023.12.25-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9852b76ab558e45b20bf1893b59af64a28bd3820b0c2efc80e0a70a4a3ea51c1"}, + {file = "regex-2023.12.25-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ff100b203092af77d1a5a7abe085b3506b7eaaf9abf65b73b7d6905b6cb76988"}, + {file = "regex-2023.12.25-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:cc038b2d8b1470364b1888a98fd22d616fba2b6309c5b5f181ad4483e0017861"}, + {file = "regex-2023.12.25-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:094ba386bb5c01e54e14434d4caabf6583334090865b23ef58e0424a6286d3dc"}, + {file = "regex-2023.12.25-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:5cd05d0f57846d8ba4b71d9c00f6f37d6b97d5e5ef8b3c3840426a475c8f70f4"}, + {file = "regex-2023.12.25-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:9aa1a67bbf0f957bbe096375887b2505f5d8ae16bf04488e8b0f334c36e31360"}, + {file = "regex-2023.12.25-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:98a2636994f943b871786c9e82bfe7883ecdaba2ef5df54e1450fa9869d1f756"}, + {file = "regex-2023.12.25-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:37f8e93a81fc5e5bd8db7e10e62dc64261bcd88f8d7e6640aaebe9bc180d9ce2"}, + {file = "regex-2023.12.25-cp38-cp38-win32.whl", hash = "sha256:d78bd484930c1da2b9679290a41cdb25cc127d783768a0369d6b449e72f88beb"}, + {file = "regex-2023.12.25-cp38-cp38-win_amd64.whl", hash = "sha256:b521dcecebc5b978b447f0f69b5b7f3840eac454862270406a39837ffae4e697"}, + {file = "regex-2023.12.25-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:f7bc09bc9c29ebead055bcba136a67378f03d66bf359e87d0f7c759d6d4ffa31"}, + {file = "regex-2023.12.25-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e14b73607d6231f3cc4622809c196b540a6a44e903bcfad940779c80dffa7be7"}, + {file = "regex-2023.12.25-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:9eda5f7a50141291beda3edd00abc2d4a5b16c29c92daf8d5bd76934150f3edc"}, + {file = "regex-2023.12.25-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc6bb9aa69aacf0f6032c307da718f61a40cf970849e471254e0e91c56ffca95"}, + {file = "regex-2023.12.25-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:298dc6354d414bc921581be85695d18912bea163a8b23cac9a2562bbcd5088b1"}, + {file = "regex-2023.12.25-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2f4e475a80ecbd15896a976aa0b386c5525d0ed34d5c600b6d3ebac0a67c7ddf"}, + {file = "regex-2023.12.25-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:531ac6cf22b53e0696f8e1d56ce2396311254eb806111ddd3922c9d937151dae"}, + {file = "regex-2023.12.25-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:22f3470f7524b6da61e2020672df2f3063676aff444db1daa283c2ea4ed259d6"}, + {file = "regex-2023.12.25-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:89723d2112697feaa320c9d351e5f5e7b841e83f8b143dba8e2d2b5f04e10923"}, + {file = "regex-2023.12.25-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0ecf44ddf9171cd7566ef1768047f6e66975788258b1c6c6ca78098b95cf9a3d"}, + {file = "regex-2023.12.25-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:905466ad1702ed4acfd67a902af50b8db1feeb9781436372261808df7a2a7bca"}, + {file = "regex-2023.12.25-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:4558410b7a5607a645e9804a3e9dd509af12fb72b9825b13791a37cd417d73a5"}, + {file = "regex-2023.12.25-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:7e316026cc1095f2a3e8cc012822c99f413b702eaa2ca5408a513609488cb62f"}, + {file = "regex-2023.12.25-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3b1de218d5375cd6ac4b5493e0b9f3df2be331e86520f23382f216c137913d20"}, + {file = "regex-2023.12.25-cp39-cp39-win32.whl", hash = "sha256:11a963f8e25ab5c61348d090bf1b07f1953929c13bd2309a0662e9ff680763c9"}, + {file = "regex-2023.12.25-cp39-cp39-win_amd64.whl", hash = "sha256:e693e233ac92ba83a87024e1d32b5f9ab15ca55ddd916d878146f4e3406b5c91"}, + {file = "regex-2023.12.25.tar.gz", hash = "sha256:29171aa128da69afdf4bde412d5bedc335f2ca8fcfe4489038577d05f16181e5"}, +] + +[[package]] +name = "requests" +version = "2.31.0" +description = "Python HTTP for Humans." +optional = false +python-versions = ">=3.7" +files = [ + {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"}, + {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"}, +] + +[package.dependencies] +certifi = ">=2017.4.17" +charset-normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<3" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] + +[[package]] +name = "rfc3339-validator" +version = "0.1.4" +description = "A pure python RFC3339 validator" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "rfc3339_validator-0.1.4-py2.py3-none-any.whl", hash = "sha256:24f6ec1eda14ef823da9e36ec7113124b39c04d50a4d3d3a3c2859577e7791fa"}, + {file = "rfc3339_validator-0.1.4.tar.gz", hash = "sha256:138a2abdf93304ad60530167e51d2dfb9549521a836871b88d7f4695d0022f6b"}, +] + +[package.dependencies] +six = "*" + +[[package]] +name = "rfc3986-validator" +version = "0.1.1" +description = "Pure python rfc3986 validator" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "rfc3986_validator-0.1.1-py2.py3-none-any.whl", hash = "sha256:2f235c432ef459970b4306369336b9d5dbdda31b510ca1e327636e01f528bfa9"}, + {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, +] + +[[package]] +name = "rpds-py" +version = "0.18.0" +description = "Python bindings to Rust's persistent data structures (rpds)" +optional = false +python-versions = ">=3.8" +files = [ + {file = "rpds_py-0.18.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:5b4e7d8d6c9b2e8ee2d55c90b59c707ca59bc30058269b3db7b1f8df5763557e"}, + {file = "rpds_py-0.18.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c463ed05f9dfb9baebef68048aed8dcdc94411e4bf3d33a39ba97e271624f8f7"}, + {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:01e36a39af54a30f28b73096dd39b6802eddd04c90dbe161c1b8dbe22353189f"}, + {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d62dec4976954a23d7f91f2f4530852b0c7608116c257833922a896101336c51"}, + {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dd18772815d5f008fa03d2b9a681ae38d5ae9f0e599f7dda233c439fcaa00d40"}, + {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:923d39efa3cfb7279a0327e337a7958bff00cc447fd07a25cddb0a1cc9a6d2da"}, + {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:39514da80f971362f9267c600b6d459bfbbc549cffc2cef8e47474fddc9b45b1"}, + {file = "rpds_py-0.18.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a34d557a42aa28bd5c48a023c570219ba2593bcbbb8dc1b98d8cf5d529ab1434"}, + {file = "rpds_py-0.18.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:93df1de2f7f7239dc9cc5a4a12408ee1598725036bd2dedadc14d94525192fc3"}, + {file = "rpds_py-0.18.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:34b18ba135c687f4dac449aa5157d36e2cbb7c03cbea4ddbd88604e076aa836e"}, + {file = "rpds_py-0.18.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c0b5dcf9193625afd8ecc92312d6ed78781c46ecbf39af9ad4681fc9f464af88"}, + {file = "rpds_py-0.18.0-cp310-none-win32.whl", hash = "sha256:c4325ff0442a12113a6379af66978c3fe562f846763287ef66bdc1d57925d337"}, + {file = "rpds_py-0.18.0-cp310-none-win_amd64.whl", hash = "sha256:7223a2a5fe0d217e60a60cdae28d6949140dde9c3bcc714063c5b463065e3d66"}, + {file = "rpds_py-0.18.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:3a96e0c6a41dcdba3a0a581bbf6c44bb863f27c541547fb4b9711fd8cf0ffad4"}, + {file = "rpds_py-0.18.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30f43887bbae0d49113cbaab729a112251a940e9b274536613097ab8b4899cf6"}, + {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fcb25daa9219b4cf3a0ab24b0eb9a5cc8949ed4dc72acb8fa16b7e1681aa3c58"}, + {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d68c93e381010662ab873fea609bf6c0f428b6d0bb00f2c6939782e0818d37bf"}, + {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b34b7aa8b261c1dbf7720b5d6f01f38243e9b9daf7e6b8bc1fd4657000062f2c"}, + {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2e6d75ab12b0bbab7215e5d40f1e5b738aa539598db27ef83b2ec46747df90e1"}, + {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b8612cd233543a3781bc659c731b9d607de65890085098986dfd573fc2befe5"}, + {file = "rpds_py-0.18.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:aec493917dd45e3c69d00a8874e7cbed844efd935595ef78a0f25f14312e33c6"}, + {file = "rpds_py-0.18.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:661d25cbffaf8cc42e971dd570d87cb29a665f49f4abe1f9e76be9a5182c4688"}, + {file = "rpds_py-0.18.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1df3659d26f539ac74fb3b0c481cdf9d725386e3552c6fa2974f4d33d78e544b"}, + {file = "rpds_py-0.18.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a1ce3ba137ed54f83e56fb983a5859a27d43a40188ba798993812fed73c70836"}, + {file = "rpds_py-0.18.0-cp311-none-win32.whl", hash = "sha256:69e64831e22a6b377772e7fb337533c365085b31619005802a79242fee620bc1"}, + {file = "rpds_py-0.18.0-cp311-none-win_amd64.whl", hash = "sha256:998e33ad22dc7ec7e030b3df701c43630b5bc0d8fbc2267653577e3fec279afa"}, + {file = "rpds_py-0.18.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:7f2facbd386dd60cbbf1a794181e6aa0bd429bd78bfdf775436020172e2a23f0"}, + {file = "rpds_py-0.18.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1d9a5be316c15ffb2b3c405c4ff14448c36b4435be062a7f578ccd8b01f0c4d8"}, + {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cd5bf1af8efe569654bbef5a3e0a56eca45f87cfcffab31dd8dde70da5982475"}, + {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5417558f6887e9b6b65b4527232553c139b57ec42c64570569b155262ac0754f"}, + {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:56a737287efecafc16f6d067c2ea0117abadcd078d58721f967952db329a3e5c"}, + {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8f03bccbd8586e9dd37219bce4d4e0d3ab492e6b3b533e973fa08a112cb2ffc9"}, + {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4457a94da0d5c53dc4b3e4de1158bdab077db23c53232f37a3cb7afdb053a4e3"}, + {file = "rpds_py-0.18.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0ab39c1ba9023914297dd88ec3b3b3c3f33671baeb6acf82ad7ce883f6e8e157"}, + {file = "rpds_py-0.18.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9d54553c1136b50fd12cc17e5b11ad07374c316df307e4cfd6441bea5fb68496"}, + {file = "rpds_py-0.18.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0af039631b6de0397ab2ba16eaf2872e9f8fca391b44d3d8cac317860a700a3f"}, + {file = "rpds_py-0.18.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:84ffab12db93b5f6bad84c712c92060a2d321b35c3c9960b43d08d0f639d60d7"}, + {file = "rpds_py-0.18.0-cp312-none-win32.whl", hash = "sha256:685537e07897f173abcf67258bee3c05c374fa6fff89d4c7e42fb391b0605e98"}, + {file = "rpds_py-0.18.0-cp312-none-win_amd64.whl", hash = "sha256:e003b002ec72c8d5a3e3da2989c7d6065b47d9eaa70cd8808b5384fbb970f4ec"}, + {file = "rpds_py-0.18.0-cp38-cp38-macosx_10_12_x86_64.whl", hash = "sha256:08f9ad53c3f31dfb4baa00da22f1e862900f45908383c062c27628754af2e88e"}, + {file = "rpds_py-0.18.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:c0013fe6b46aa496a6749c77e00a3eb07952832ad6166bd481c74bda0dcb6d58"}, + {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e32a92116d4f2a80b629778280103d2a510a5b3f6314ceccd6e38006b5e92dcb"}, + {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e541ec6f2ec456934fd279a3120f856cd0aedd209fc3852eca563f81738f6861"}, + {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bed88b9a458e354014d662d47e7a5baafd7ff81c780fd91584a10d6ec842cb73"}, + {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2644e47de560eb7bd55c20fc59f6daa04682655c58d08185a9b95c1970fa1e07"}, + {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e8916ae4c720529e18afa0b879473049e95949bf97042e938530e072fde061d"}, + {file = "rpds_py-0.18.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:465a3eb5659338cf2a9243e50ad9b2296fa15061736d6e26240e713522b6235c"}, + {file = "rpds_py-0.18.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:ea7d4a99f3b38c37eac212dbd6ec42b7a5ec51e2c74b5d3223e43c811609e65f"}, + {file = "rpds_py-0.18.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:67071a6171e92b6da534b8ae326505f7c18022c6f19072a81dcf40db2638767c"}, + {file = "rpds_py-0.18.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:41ef53e7c58aa4ef281da975f62c258950f54b76ec8e45941e93a3d1d8580594"}, + {file = "rpds_py-0.18.0-cp38-none-win32.whl", hash = "sha256:fdea4952db2793c4ad0bdccd27c1d8fdd1423a92f04598bc39425bcc2b8ee46e"}, + {file = "rpds_py-0.18.0-cp38-none-win_amd64.whl", hash = "sha256:7cd863afe7336c62ec78d7d1349a2f34c007a3cc6c2369d667c65aeec412a5b1"}, + {file = "rpds_py-0.18.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:5307def11a35f5ae4581a0b658b0af8178c65c530e94893345bebf41cc139d33"}, + {file = "rpds_py-0.18.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:77f195baa60a54ef9d2de16fbbfd3ff8b04edc0c0140a761b56c267ac11aa467"}, + {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39f5441553f1c2aed4de4377178ad8ff8f9d733723d6c66d983d75341de265ab"}, + {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9a00312dea9310d4cb7dbd7787e722d2e86a95c2db92fbd7d0155f97127bcb40"}, + {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f2fc11e8fe034ee3c34d316d0ad8808f45bc3b9ce5857ff29d513f3ff2923a1"}, + {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:586f8204935b9ec884500498ccc91aa869fc652c40c093bd9e1471fbcc25c022"}, + {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ddc2f4dfd396c7bfa18e6ce371cba60e4cf9d2e5cdb71376aa2da264605b60b9"}, + {file = "rpds_py-0.18.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5ddcba87675b6d509139d1b521e0c8250e967e63b5909a7e8f8944d0f90ff36f"}, + {file = "rpds_py-0.18.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:7bd339195d84439cbe5771546fe8a4e8a7a045417d8f9de9a368c434e42a721e"}, + {file = "rpds_py-0.18.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:d7c36232a90d4755b720fbd76739d8891732b18cf240a9c645d75f00639a9024"}, + {file = "rpds_py-0.18.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:6b0817e34942b2ca527b0e9298373e7cc75f429e8da2055607f4931fded23e20"}, + {file = "rpds_py-0.18.0-cp39-none-win32.whl", hash = "sha256:99f70b740dc04d09e6b2699b675874367885217a2e9f782bdf5395632ac663b7"}, + {file = "rpds_py-0.18.0-cp39-none-win_amd64.whl", hash = "sha256:6ef687afab047554a2d366e112dd187b62d261d49eb79b77e386f94644363294"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ad36cfb355e24f1bd37cac88c112cd7730873f20fb0bdaf8ba59eedf8216079f"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:36b3ee798c58ace201289024b52788161e1ea133e4ac93fba7d49da5fec0ef9e"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f8a2f084546cc59ea99fda8e070be2fd140c3092dc11524a71aa8f0f3d5a55ca"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e4461d0f003a0aa9be2bdd1b798a041f177189c1a0f7619fe8c95ad08d9a45d7"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8db715ebe3bb7d86d77ac1826f7d67ec11a70dbd2376b7cc214199360517b641"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:793968759cd0d96cac1e367afd70c235867831983f876a53389ad869b043c948"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:66e6a3af5a75363d2c9a48b07cb27c4ea542938b1a2e93b15a503cdfa8490795"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6ef0befbb5d79cf32d0266f5cff01545602344eda89480e1dd88aca964260b18"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:1d4acf42190d449d5e89654d5c1ed3a4f17925eec71f05e2a41414689cda02d1"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-musllinux_1_2_i686.whl", hash = "sha256:a5f446dd5055667aabaee78487f2b5ab72e244f9bc0b2ffebfeec79051679984"}, + {file = "rpds_py-0.18.0-pp310-pypy310_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:9dbbeb27f4e70bfd9eec1be5477517365afe05a9b2c441a0b21929ee61048124"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-macosx_10_12_x86_64.whl", hash = "sha256:22806714311a69fd0af9b35b7be97c18a0fc2826e6827dbb3a8c94eac6cf7eeb"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:b34ae4636dfc4e76a438ab826a0d1eed2589ca7d9a1b2d5bb546978ac6485461"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c8370641f1a7f0e0669ddccca22f1da893cef7628396431eb445d46d893e5cd"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c8362467a0fdeccd47935f22c256bec5e6abe543bf0d66e3d3d57a8fb5731863"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:11a8c85ef4a07a7638180bf04fe189d12757c696eb41f310d2426895356dcf05"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b316144e85316da2723f9d8dc75bada12fa58489a527091fa1d5a612643d1a0e"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf1ea2e34868f6fbf070e1af291c8180480310173de0b0c43fc38a02929fc0e3"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e546e768d08ad55b20b11dbb78a745151acbd938f8f00d0cfbabe8b0199b9880"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:4901165d170a5fde6f589acb90a6b33629ad1ec976d4529e769c6f3d885e3e80"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-musllinux_1_2_i686.whl", hash = "sha256:618a3d6cae6ef8ec88bb76dd80b83cfe415ad4f1d942ca2a903bf6b6ff97a2da"}, + {file = "rpds_py-0.18.0-pp38-pypy38_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ed4eb745efbff0a8e9587d22a84be94a5eb7d2d99c02dacf7bd0911713ed14dd"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:6c81e5f372cd0dc5dc4809553d34f832f60a46034a5f187756d9b90586c2c307"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:43fbac5f22e25bee1d482c97474f930a353542855f05c1161fd804c9dc74a09d"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d7faa6f14017c0b1e69f5e2c357b998731ea75a442ab3841c0dbbbfe902d2c4"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:08231ac30a842bd04daabc4d71fddd7e6d26189406d5a69535638e4dcb88fe76"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:044a3e61a7c2dafacae99d1e722cc2d4c05280790ec5a05031b3876809d89a5c"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3f26b5bd1079acdb0c7a5645e350fe54d16b17bfc5e71f371c449383d3342e17"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:482103aed1dfe2f3b71a58eff35ba105289b8d862551ea576bd15479aba01f66"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1374f4129f9bcca53a1bba0bb86bf78325a0374577cf7e9e4cd046b1e6f20e24"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:635dc434ff724b178cb192c70016cc0ad25a275228f749ee0daf0eddbc8183b1"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-musllinux_1_2_i686.whl", hash = "sha256:bc362ee4e314870a70f4ae88772d72d877246537d9f8cb8f7eacf10884862432"}, + {file = "rpds_py-0.18.0-pp39-pypy39_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:4832d7d380477521a8c1644bbab6588dfedea5e30a7d967b5fb75977c45fd77f"}, + {file = "rpds_py-0.18.0.tar.gz", hash = "sha256:42821446ee7a76f5d9f71f9e33a4fb2ffd724bb3e7f93386150b61a43115788d"}, +] + +[[package]] +name = "ruff" +version = "0.0.292" +description = "An extremely fast Python linter, written in Rust." +optional = false +python-versions = ">=3.7" +files = [ + {file = "ruff-0.0.292-py3-none-macosx_10_7_x86_64.whl", hash = "sha256:02f29db018c9d474270c704e6c6b13b18ed0ecac82761e4fcf0faa3728430c96"}, + {file = "ruff-0.0.292-py3-none-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:69654e564342f507edfa09ee6897883ca76e331d4bbc3676d8a8403838e9fade"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c3c91859a9b845c33778f11902e7b26440d64b9d5110edd4e4fa1726c41e0a4"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f4476f1243af2d8c29da5f235c13dca52177117935e1f9393f9d90f9833f69e4"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:be8eb50eaf8648070b8e58ece8e69c9322d34afe367eec4210fdee9a555e4ca7"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:9889bac18a0c07018aac75ef6c1e6511d8411724d67cb879103b01758e110a81"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6bdfabd4334684a4418b99b3118793f2c13bb67bf1540a769d7816410402a205"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:aa7c77c53bfcd75dbcd4d1f42d6cabf2485d2e1ee0678da850f08e1ab13081a8"}, + {file = "ruff-0.0.292-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e087b24d0d849c5c81516ec740bf4fd48bf363cfb104545464e0fca749b6af9"}, + {file = "ruff-0.0.292-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:f160b5ec26be32362d0774964e218f3fcf0a7da299f7e220ef45ae9e3e67101a"}, + {file = "ruff-0.0.292-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:ac153eee6dd4444501c4bb92bff866491d4bfb01ce26dd2fff7ca472c8df9ad0"}, + {file = "ruff-0.0.292-py3-none-musllinux_1_2_i686.whl", hash = "sha256:87616771e72820800b8faea82edd858324b29bb99a920d6aa3d3949dd3f88fb0"}, + {file = "ruff-0.0.292-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:b76deb3bdbea2ef97db286cf953488745dd6424c122d275f05836c53f62d4016"}, + {file = "ruff-0.0.292-py3-none-win32.whl", hash = "sha256:e854b05408f7a8033a027e4b1c7f9889563dd2aca545d13d06711e5c39c3d003"}, + {file = "ruff-0.0.292-py3-none-win_amd64.whl", hash = "sha256:f27282bedfd04d4c3492e5c3398360c9d86a295be00eccc63914438b4ac8a83c"}, + {file = "ruff-0.0.292-py3-none-win_arm64.whl", hash = "sha256:7f67a69c8f12fbc8daf6ae6d36705037bde315abf8b82b6e1f4c9e74eb750f68"}, + {file = "ruff-0.0.292.tar.gz", hash = "sha256:1093449e37dd1e9b813798f6ad70932b57cf614e5c2b5c51005bf67d55db33ac"}, +] + +[[package]] +name = "send2trash" +version = "1.8.2" +description = "Send file to trash natively under Mac OS X, Windows and Linux" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7" +files = [ + {file = "Send2Trash-1.8.2-py3-none-any.whl", hash = "sha256:a384719d99c07ce1eefd6905d2decb6f8b7ed054025bb0e618919f945de4f679"}, + {file = "Send2Trash-1.8.2.tar.gz", hash = "sha256:c132d59fa44b9ca2b1699af5c86f57ce9f4c5eb56629d5d55fbb7a35f84e2312"}, +] + +[package.extras] +nativelib = ["pyobjc-framework-Cocoa", "pywin32"] +objc = ["pyobjc-framework-Cocoa"] +win32 = ["pywin32"] + +[[package]] +name = "setuptools" +version = "69.1.0" +description = "Easily download, build, install, upgrade, and uninstall Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "setuptools-69.1.0-py3-none-any.whl", hash = "sha256:c054629b81b946d63a9c6e732bc8b2513a7c3ea645f11d0139a2191d735c60c6"}, + {file = "setuptools-69.1.0.tar.gz", hash = "sha256:850894c4195f09c4ed30dba56213bf7c3f21d86ed6bdaafb5df5972593bfc401"}, +] + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"] +testing = ["build[virtualenv]", "filelock (>=3.4.0)", "flake8-2020", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "pip (>=19.1)", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy (>=0.9.1)", "pytest-perf", "pytest-ruff (>=0.2.1)", "pytest-timeout", "pytest-xdist", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"] +testing-integration = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.1)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"] + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "sniffio" +version = "1.3.0" +description = "Sniff out which async library your code is running under" +optional = false +python-versions = ">=3.7" +files = [ + {file = "sniffio-1.3.0-py3-none-any.whl", hash = "sha256:eecefdce1e5bbfb7ad2eeaabf7c1eeb404d7757c379bd1f7e5cce9d8bf425384"}, + {file = "sniffio-1.3.0.tar.gz", hash = "sha256:e60305c5e5d314f5389259b7f22aaa33d8f7dee49763119234af3755c55b9101"}, +] + +[[package]] +name = "soupsieve" +version = "2.5" +description = "A modern CSS selector implementation for Beautiful Soup." +optional = false +python-versions = ">=3.8" +files = [ + {file = "soupsieve-2.5-py3-none-any.whl", hash = "sha256:eaa337ff55a1579b6549dc679565eac1e3d000563bcb1c8ab0d0fefbc0c2cdc7"}, + {file = "soupsieve-2.5.tar.gz", hash = "sha256:5663d5a7b3bfaeee0bc4372e7fc48f9cff4940b3eec54a6451cc5299f1097690"}, +] + +[[package]] +name = "sqlalchemy" +version = "2.0.27" +description = "Database Abstraction Library" +optional = false +python-versions = ">=3.7" +files = [ + {file = "SQLAlchemy-2.0.27-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d04e579e911562f1055d26dab1868d3e0bb905db3bccf664ee8ad109f035618a"}, + {file = "SQLAlchemy-2.0.27-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fa67d821c1fd268a5a87922ef4940442513b4e6c377553506b9db3b83beebbd8"}, + {file = "SQLAlchemy-2.0.27-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c7a596d0be71b7baa037f4ac10d5e057d276f65a9a611c46970f012752ebf2d"}, + {file = "SQLAlchemy-2.0.27-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:954d9735ee9c3fa74874c830d089a815b7b48df6f6b6e357a74130e478dbd951"}, + {file = "SQLAlchemy-2.0.27-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:5cd20f58c29bbf2680039ff9f569fa6d21453fbd2fa84dbdb4092f006424c2e6"}, + {file = "SQLAlchemy-2.0.27-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:03f448ffb731b48323bda68bcc93152f751436ad6037f18a42b7e16af9e91c07"}, + {file = "SQLAlchemy-2.0.27-cp310-cp310-win32.whl", hash = "sha256:d997c5938a08b5e172c30583ba6b8aad657ed9901fc24caf3a7152eeccb2f1b4"}, + {file = "SQLAlchemy-2.0.27-cp310-cp310-win_amd64.whl", hash = "sha256:eb15ef40b833f5b2f19eeae65d65e191f039e71790dd565c2af2a3783f72262f"}, + {file = "SQLAlchemy-2.0.27-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6c5bad7c60a392850d2f0fee8f355953abaec878c483dd7c3836e0089f046bf6"}, + {file = "SQLAlchemy-2.0.27-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a3012ab65ea42de1be81fff5fb28d6db893ef978950afc8130ba707179b4284a"}, + {file = "SQLAlchemy-2.0.27-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dbcd77c4d94b23e0753c5ed8deba8c69f331d4fd83f68bfc9db58bc8983f49cd"}, + {file = "SQLAlchemy-2.0.27-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d177b7e82f6dd5e1aebd24d9c3297c70ce09cd1d5d37b43e53f39514379c029c"}, + {file = "SQLAlchemy-2.0.27-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:680b9a36029b30cf063698755d277885d4a0eab70a2c7c6e71aab601323cba45"}, + {file = "SQLAlchemy-2.0.27-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1306102f6d9e625cebaca3d4c9c8f10588735ef877f0360b5cdb4fdfd3fd7131"}, + {file = "SQLAlchemy-2.0.27-cp311-cp311-win32.whl", hash = "sha256:5b78aa9f4f68212248aaf8943d84c0ff0f74efc65a661c2fc68b82d498311fd5"}, + {file = "SQLAlchemy-2.0.27-cp311-cp311-win_amd64.whl", hash = "sha256:15e19a84b84528f52a68143439d0c7a3a69befcd4f50b8ef9b7b69d2628ae7c4"}, + {file = "SQLAlchemy-2.0.27-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:0de1263aac858f288a80b2071990f02082c51d88335a1db0d589237a3435fe71"}, + {file = "SQLAlchemy-2.0.27-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce850db091bf7d2a1f2fdb615220b968aeff3849007b1204bf6e3e50a57b3d32"}, + {file = "SQLAlchemy-2.0.27-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8dfc936870507da96aebb43e664ae3a71a7b96278382bcfe84d277b88e379b18"}, + {file = "SQLAlchemy-2.0.27-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c4fbe6a766301f2e8a4519f4500fe74ef0a8509a59e07a4085458f26228cd7cc"}, + {file = "SQLAlchemy-2.0.27-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:4535c49d961fe9a77392e3a630a626af5baa967172d42732b7a43496c8b28876"}, + {file = "SQLAlchemy-2.0.27-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:0fb3bffc0ced37e5aa4ac2416f56d6d858f46d4da70c09bb731a246e70bff4d5"}, + {file = "SQLAlchemy-2.0.27-cp312-cp312-win32.whl", hash = "sha256:7f470327d06400a0aa7926b375b8e8c3c31d335e0884f509fe272b3c700a7254"}, + {file = "SQLAlchemy-2.0.27-cp312-cp312-win_amd64.whl", hash = "sha256:f9374e270e2553653d710ece397df67db9d19c60d2647bcd35bfc616f1622dcd"}, + {file = "SQLAlchemy-2.0.27-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:e97cf143d74a7a5a0f143aa34039b4fecf11343eed66538610debc438685db4a"}, + {file = "SQLAlchemy-2.0.27-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7b5a3e2120982b8b6bd1d5d99e3025339f7fb8b8267551c679afb39e9c7c7f1"}, + {file = "SQLAlchemy-2.0.27-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e36aa62b765cf9f43a003233a8c2d7ffdeb55bc62eaa0a0380475b228663a38f"}, + {file = "SQLAlchemy-2.0.27-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:5ada0438f5b74c3952d916c199367c29ee4d6858edff18eab783b3978d0db16d"}, + {file = "SQLAlchemy-2.0.27-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:b1d9d1bfd96eef3c3faedb73f486c89e44e64e40e5bfec304ee163de01cf996f"}, + {file = "SQLAlchemy-2.0.27-cp37-cp37m-win32.whl", hash = "sha256:ca891af9f3289d24a490a5fde664ea04fe2f4984cd97e26de7442a4251bd4b7c"}, + {file = "SQLAlchemy-2.0.27-cp37-cp37m-win_amd64.whl", hash = "sha256:fd8aafda7cdff03b905d4426b714601c0978725a19efc39f5f207b86d188ba01"}, + {file = "SQLAlchemy-2.0.27-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:ec1f5a328464daf7a1e4e385e4f5652dd9b1d12405075ccba1df842f7774b4fc"}, + {file = "SQLAlchemy-2.0.27-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:ad862295ad3f644e3c2c0d8b10a988e1600d3123ecb48702d2c0f26771f1c396"}, + {file = "SQLAlchemy-2.0.27-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:48217be1de7d29a5600b5c513f3f7664b21d32e596d69582be0a94e36b8309cb"}, + {file = "SQLAlchemy-2.0.27-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e56afce6431450442f3ab5973156289bd5ec33dd618941283847c9fd5ff06bf"}, + {file = "SQLAlchemy-2.0.27-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:611068511b5531304137bcd7fe8117c985d1b828eb86043bd944cebb7fae3910"}, + {file = "SQLAlchemy-2.0.27-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:b86abba762ecfeea359112b2bb4490802b340850bbee1948f785141a5e020de8"}, + {file = "SQLAlchemy-2.0.27-cp38-cp38-win32.whl", hash = "sha256:30d81cc1192dc693d49d5671cd40cdec596b885b0ce3b72f323888ab1c3863d5"}, + {file = "SQLAlchemy-2.0.27-cp38-cp38-win_amd64.whl", hash = "sha256:120af1e49d614d2525ac247f6123841589b029c318b9afbfc9e2b70e22e1827d"}, + {file = "SQLAlchemy-2.0.27-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d07ee7793f2aeb9b80ec8ceb96bc8cc08a2aec8a1b152da1955d64e4825fcbac"}, + {file = "SQLAlchemy-2.0.27-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:cb0845e934647232b6ff5150df37ceffd0b67b754b9fdbb095233deebcddbd4a"}, + {file = "SQLAlchemy-2.0.27-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fc19ae2e07a067663dd24fca55f8ed06a288384f0e6e3910420bf4b1270cc51"}, + {file = "SQLAlchemy-2.0.27-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b90053be91973a6fb6020a6e44382c97739736a5a9d74e08cc29b196639eb979"}, + {file = "SQLAlchemy-2.0.27-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:2f5c9dfb0b9ab5e3a8a00249534bdd838d943ec4cfb9abe176a6c33408430230"}, + {file = "SQLAlchemy-2.0.27-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:33e8bde8fff203de50399b9039c4e14e42d4d227759155c21f8da4a47fc8053c"}, + {file = "SQLAlchemy-2.0.27-cp39-cp39-win32.whl", hash = "sha256:d873c21b356bfaf1589b89090a4011e6532582b3a8ea568a00e0c3aab09399dd"}, + {file = "SQLAlchemy-2.0.27-cp39-cp39-win_amd64.whl", hash = "sha256:ff2f1b7c963961d41403b650842dc2039175b906ab2093635d8319bef0b7d620"}, + {file = "SQLAlchemy-2.0.27-py3-none-any.whl", hash = "sha256:1ab4e0448018d01b142c916cc7119ca573803a4745cfe341b8f95657812700ac"}, + {file = "SQLAlchemy-2.0.27.tar.gz", hash = "sha256:86a6ed69a71fe6b88bf9331594fa390a2adda4a49b5c06f98e47bf0d392534f8"}, +] + +[package.dependencies] +greenlet = {version = "!=0.4.17", optional = true, markers = "platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\" or extra == \"asyncio\""} +typing-extensions = ">=4.6.0" + +[package.extras] +aiomysql = ["aiomysql (>=0.2.0)", "greenlet (!=0.4.17)"] +aioodbc = ["aioodbc", "greenlet (!=0.4.17)"] +aiosqlite = ["aiosqlite", "greenlet (!=0.4.17)", "typing_extensions (!=3.10.0.1)"] +asyncio = ["greenlet (!=0.4.17)"] +asyncmy = ["asyncmy (>=0.2.3,!=0.2.4,!=0.2.6)", "greenlet (!=0.4.17)"] +mariadb-connector = ["mariadb (>=1.0.1,!=1.1.2,!=1.1.5)"] +mssql = ["pyodbc"] +mssql-pymssql = ["pymssql"] +mssql-pyodbc = ["pyodbc"] +mypy = ["mypy (>=0.910)"] +mysql = ["mysqlclient (>=1.4.0)"] +mysql-connector = ["mysql-connector-python"] +oracle = ["cx_oracle (>=8)"] +oracle-oracledb = ["oracledb (>=1.0.1)"] +postgresql = ["psycopg2 (>=2.7)"] +postgresql-asyncpg = ["asyncpg", "greenlet (!=0.4.17)"] +postgresql-pg8000 = ["pg8000 (>=1.29.1)"] +postgresql-psycopg = ["psycopg (>=3.0.7)"] +postgresql-psycopg2binary = ["psycopg2-binary"] +postgresql-psycopg2cffi = ["psycopg2cffi"] +postgresql-psycopgbinary = ["psycopg[binary] (>=3.0.7)"] +pymysql = ["pymysql"] +sqlcipher = ["sqlcipher3_binary"] + +[[package]] +name = "stack-data" +version = "0.6.3" +description = "Extract data from python stack frames and tracebacks for informative displays" +optional = false +python-versions = "*" +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[package.dependencies] +asttokens = ">=2.1.0" +executing = ">=1.2.0" +pure-eval = "*" + +[package.extras] +tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] + +[[package]] +name = "tenacity" +version = "8.2.3" +description = "Retry code until it succeeds" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tenacity-8.2.3-py3-none-any.whl", hash = "sha256:ce510e327a630c9e1beaf17d42e6ffacc88185044ad85cf74c0a8887c6a0f88c"}, + {file = "tenacity-8.2.3.tar.gz", hash = "sha256:5398ef0d78e63f40007c1fb4c0bff96e1911394d2fa8d194f77619c05ff6cc8a"}, +] + +[package.extras] +doc = ["reno", "sphinx", "tornado (>=4.5)"] + +[[package]] +name = "terminado" +version = "0.18.0" +description = "Tornado websocket backend for the Xterm.js Javascript terminal emulator library." +optional = false +python-versions = ">=3.8" +files = [ + {file = "terminado-0.18.0-py3-none-any.whl", hash = "sha256:87b0d96642d0fe5f5abd7783857b9cab167f221a39ff98e3b9619a788a3c0f2e"}, + {file = "terminado-0.18.0.tar.gz", hash = "sha256:1ea08a89b835dd1b8c0c900d92848147cef2537243361b2e3f4dc15df9b6fded"}, +] + +[package.dependencies] +ptyprocess = {version = "*", markers = "os_name != \"nt\""} +pywinpty = {version = ">=1.1.0", markers = "os_name == \"nt\""} +tornado = ">=6.1.0" + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["pre-commit", "pytest (>=7.0)", "pytest-timeout"] +typing = ["mypy (>=1.6,<2.0)", "traitlets (>=5.11.1)"] + +[[package]] +name = "tiktoken" +version = "0.6.0" +description = "tiktoken is a fast BPE tokeniser for use with OpenAI's models" +optional = false +python-versions = ">=3.8" +files = [ + {file = "tiktoken-0.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:277de84ccd8fa12730a6b4067456e5cf72fef6300bea61d506c09e45658d41ac"}, + {file = "tiktoken-0.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9c44433f658064463650d61387623735641dcc4b6c999ca30bc0f8ba3fccaf5c"}, + {file = "tiktoken-0.6.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afb9a2a866ae6eef1995ab656744287a5ac95acc7e0491c33fad54d053288ad3"}, + {file = "tiktoken-0.6.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c62c05b3109fefca26fedb2820452a050074ad8e5ad9803f4652977778177d9f"}, + {file = "tiktoken-0.6.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0ef917fad0bccda07bfbad835525bbed5f3ab97a8a3e66526e48cdc3e7beacf7"}, + {file = "tiktoken-0.6.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e095131ab6092d0769a2fda85aa260c7c383072daec599ba9d8b149d2a3f4d8b"}, + {file = "tiktoken-0.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:05b344c61779f815038292a19a0c6eb7098b63c8f865ff205abb9ea1b656030e"}, + {file = "tiktoken-0.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cefb9870fb55dca9e450e54dbf61f904aab9180ff6fe568b61f4db9564e78871"}, + {file = "tiktoken-0.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:702950d33d8cabc039845674107d2e6dcabbbb0990ef350f640661368df481bb"}, + {file = "tiktoken-0.6.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8d49d076058f23254f2aff9af603863c5c5f9ab095bc896bceed04f8f0b013a"}, + {file = "tiktoken-0.6.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:430bc4e650a2d23a789dc2cdca3b9e5e7eb3cd3935168d97d43518cbb1f9a911"}, + {file = "tiktoken-0.6.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:293cb8669757301a3019a12d6770bd55bec38a4d3ee9978ddbe599d68976aca7"}, + {file = "tiktoken-0.6.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7bd1a288b7903aadc054b0e16ea78e3171f70b670e7372432298c686ebf9dd47"}, + {file = "tiktoken-0.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac76e000183e3b749634968a45c7169b351e99936ef46f0d2353cd0d46c3118d"}, + {file = "tiktoken-0.6.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:17cc8a4a3245ab7d935c83a2db6bb71619099d7284b884f4b2aea4c74f2f83e3"}, + {file = "tiktoken-0.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:284aebcccffe1bba0d6571651317df6a5b376ff6cfed5aeb800c55df44c78177"}, + {file = "tiktoken-0.6.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0c1a3a5d33846f8cd9dd3b7897c1d45722f48625a587f8e6f3d3e85080559be8"}, + {file = "tiktoken-0.6.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6318b2bb2337f38ee954fd5efa82632c6e5ced1d52a671370fa4b2eff1355e91"}, + {file = "tiktoken-0.6.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1f5f0f2ed67ba16373f9a6013b68da298096b27cd4e1cf276d2d3868b5c7efd1"}, + {file = "tiktoken-0.6.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:75af4c0b16609c2ad02581f3cdcd1fb698c7565091370bf6c0cf8624ffaba6dc"}, + {file = "tiktoken-0.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:45577faf9a9d383b8fd683e313cf6df88b6076c034f0a16da243bb1c139340c3"}, + {file = "tiktoken-0.6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7c1492ab90c21ca4d11cef3a236ee31a3e279bb21b3fc5b0e2210588c4209e68"}, + {file = "tiktoken-0.6.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:e2b380c5b7751272015400b26144a2bab4066ebb8daae9c3cd2a92c3b508fe5a"}, + {file = "tiktoken-0.6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9f497598b9f58c99cbc0eb764b4a92272c14d5203fc713dd650b896a03a50ad"}, + {file = "tiktoken-0.6.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e65e8bd6f3f279d80f1e1fbd5f588f036b9a5fa27690b7f0cc07021f1dfa0839"}, + {file = "tiktoken-0.6.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5f1495450a54e564d236769d25bfefbf77727e232d7a8a378f97acddee08c1ae"}, + {file = "tiktoken-0.6.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6c4e4857d99f6fb4670e928250835b21b68c59250520a1941618b5b4194e20c3"}, + {file = "tiktoken-0.6.0-cp38-cp38-win_amd64.whl", hash = "sha256:168d718f07a39b013032741867e789971346df8e89983fe3c0ef3fbd5a0b1cb9"}, + {file = "tiktoken-0.6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:47fdcfe11bd55376785a6aea8ad1db967db7f66ea81aed5c43fad497521819a4"}, + {file = "tiktoken-0.6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:fb7d2ccbf1a7784810aff6b80b4012fb42c6fc37eaa68cb3b553801a5cc2d1fc"}, + {file = "tiktoken-0.6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1ccb7a111ee76af5d876a729a347f8747d5ad548e1487eeea90eaf58894b3138"}, + {file = "tiktoken-0.6.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2048e1086b48e3c8c6e2ceeac866561374cd57a84622fa49a6b245ffecb7744"}, + {file = "tiktoken-0.6.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:07f229a5eb250b6403a61200199cecf0aac4aa23c3ecc1c11c1ca002cbb8f159"}, + {file = "tiktoken-0.6.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:432aa3be8436177b0db5a2b3e7cc28fd6c693f783b2f8722539ba16a867d0c6a"}, + {file = "tiktoken-0.6.0-cp39-cp39-win_amd64.whl", hash = "sha256:8bfe8a19c8b5c40d121ee7938cd9c6a278e5b97dc035fd61714b4f0399d2f7a1"}, + {file = "tiktoken-0.6.0.tar.gz", hash = "sha256:ace62a4ede83c75b0374a2ddfa4b76903cf483e9cb06247f566be3bf14e6beed"}, +] + +[package.dependencies] +regex = ">=2022.1.18" +requests = ">=2.26.0" + +[package.extras] +blobfile = ["blobfile (>=2)"] + +[[package]] +name = "tinycss2" +version = "1.2.1" +description = "A tiny CSS parser" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tinycss2-1.2.1-py3-none-any.whl", hash = "sha256:2b80a96d41e7c3914b8cda8bc7f705a4d9c49275616e886103dd839dfc847847"}, + {file = "tinycss2-1.2.1.tar.gz", hash = "sha256:8cff3a8f066c2ec677c06dbc7b45619804a6938478d9d73c284b29d14ecb0627"}, +] + +[package.dependencies] +webencodings = ">=0.4" + +[package.extras] +doc = ["sphinx", "sphinx_rtd_theme"] +test = ["flake8", "isort", "pytest"] + +[[package]] +name = "tokenize-rt" +version = "5.2.0" +description = "A wrapper around the stdlib `tokenize` which roundtrips." +optional = false +python-versions = ">=3.8" +files = [ + {file = "tokenize_rt-5.2.0-py2.py3-none-any.whl", hash = "sha256:b79d41a65cfec71285433511b50271b05da3584a1da144a0752e9c621a285289"}, + {file = "tokenize_rt-5.2.0.tar.gz", hash = "sha256:9fe80f8a5c1edad2d3ede0f37481cc0cc1538a2f442c9c2f9e4feacd2792d054"}, +] + +[[package]] +name = "tomli" +version = "2.0.1" +description = "A lil' TOML parser" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"}, + {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, +] + +[[package]] +name = "tomlkit" +version = "0.12.3" +description = "Style preserving TOML library" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tomlkit-0.12.3-py3-none-any.whl", hash = "sha256:b0a645a9156dc7cb5d3a1f0d4bab66db287fcb8e0430bdd4664a095ea16414ba"}, + {file = "tomlkit-0.12.3.tar.gz", hash = "sha256:75baf5012d06501f07bee5bf8e801b9f343e7aac5a92581f20f80ce632e6b5a4"}, +] + +[[package]] +name = "tornado" +version = "6.4" +description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." +optional = false +python-versions = ">= 3.8" +files = [ + {file = "tornado-6.4-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:02ccefc7d8211e5a7f9e8bc3f9e5b0ad6262ba2fbb683a6443ecc804e5224ce0"}, + {file = "tornado-6.4-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:27787de946a9cffd63ce5814c33f734c627a87072ec7eed71f7fc4417bb16263"}, + {file = "tornado-6.4-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7894c581ecdcf91666a0912f18ce5e757213999e183ebfc2c3fdbf4d5bd764e"}, + {file = "tornado-6.4-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e43bc2e5370a6a8e413e1e1cd0c91bedc5bd62a74a532371042a18ef19e10579"}, + {file = "tornado-6.4-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0251554cdd50b4b44362f73ad5ba7126fc5b2c2895cc62b14a1c2d7ea32f212"}, + {file = "tornado-6.4-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:fd03192e287fbd0899dd8f81c6fb9cbbc69194d2074b38f384cb6fa72b80e9c2"}, + {file = "tornado-6.4-cp38-abi3-musllinux_1_1_i686.whl", hash = "sha256:88b84956273fbd73420e6d4b8d5ccbe913c65d31351b4c004ae362eba06e1f78"}, + {file = "tornado-6.4-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:71ddfc23a0e03ef2df1c1397d859868d158c8276a0603b96cf86892bff58149f"}, + {file = "tornado-6.4-cp38-abi3-win32.whl", hash = "sha256:6f8a6c77900f5ae93d8b4ae1196472d0ccc2775cc1dfdc9e7727889145c45052"}, + {file = "tornado-6.4-cp38-abi3-win_amd64.whl", hash = "sha256:10aeaa8006333433da48dec9fe417877f8bcc21f48dda8d661ae79da357b2a63"}, + {file = "tornado-6.4.tar.gz", hash = "sha256:72291fa6e6bc84e626589f1c29d90a5a6d593ef5ae68052ee2ef000dfd273dee"}, +] + +[[package]] +name = "tqdm" +version = "4.66.2" +description = "Fast, Extensible Progress Meter" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tqdm-4.66.2-py3-none-any.whl", hash = "sha256:1ee4f8a893eb9bef51c6e35730cebf234d5d0b6bd112b0271e10ed7c24a02bd9"}, + {file = "tqdm-4.66.2.tar.gz", hash = "sha256:6cd52cdf0fef0e0f543299cfc96fec90d7b8a7e88745f411ec33eb44d5ed3531"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + +[package.extras] +dev = ["pytest (>=6)", "pytest-cov", "pytest-timeout", "pytest-xdist"] +notebook = ["ipywidgets (>=6)"] +slack = ["slack-sdk"] +telegram = ["requests"] + +[[package]] +name = "traitlets" +version = "5.14.1" +description = "Traitlets Python configuration system" +optional = false +python-versions = ">=3.8" +files = [ + {file = "traitlets-5.14.1-py3-none-any.whl", hash = "sha256:2e5a030e6eff91737c643231bfcf04a65b0132078dad75e4936700b213652e74"}, + {file = "traitlets-5.14.1.tar.gz", hash = "sha256:8585105b371a04b8316a43d5ce29c098575c2e477850b62b848b964f1444527e"}, +] + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<7.5)", "pytest-mock", "pytest-mypy-testing"] + +[[package]] +name = "tree-sitter" +version = "0.20.4" +description = "Python bindings for the Tree-Sitter parsing library" +optional = false +python-versions = ">=3.3" +files = [ + {file = "tree_sitter-0.20.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:c259b9bcb596e54f54713eb3951226fc834d65289940f4bfdcdf519f08e8e876"}, + {file = "tree_sitter-0.20.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:88da7e2e4c69881cd63916cc24ae0b809f96aae331da45b418ae6b2d1ed2ca19"}, + {file = "tree_sitter-0.20.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:66a68b156ba131e9d8dff4a1f72037f4b368cc50c58f18905a91743ae1d1c795"}, + {file = "tree_sitter-0.20.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ae28e25d551f406807011487bdfb9728041e656b30b554fa7f3391ab64ed69f9"}, + {file = "tree_sitter-0.20.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:36b10c9c69e825ba65cf9b0f77668bf33e70d2a5764b64ad6f133f8cc9220f09"}, + {file = "tree_sitter-0.20.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:7c18c64ddd44b75b7e1660b9793753eda427e4b145b6216d4b2d2e9b200c74f2"}, + {file = "tree_sitter-0.20.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:e9e9e594bbefb76ad9ea256f5c87eba7591b4758854d3df83ce4df415933a006"}, + {file = "tree_sitter-0.20.4-cp310-cp310-win32.whl", hash = "sha256:b4755229dc18644fe48bcab974bde09b171fcb6ef625d3cb5ece5c6198f4223e"}, + {file = "tree_sitter-0.20.4-cp310-cp310-win_amd64.whl", hash = "sha256:f792684cee8a46d9194d9f4223810e54ccc704470c5777538d59fbde0a4c91bf"}, + {file = "tree_sitter-0.20.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9d22ee75f45836554ee6a11e50dd8f9827941e67c49fce9a0790245b899811a9"}, + {file = "tree_sitter-0.20.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2a0ffd76dd991ba745bb5d0ba1d583bec85726d3ddef8c9685dc8636a619adde"}, + {file = "tree_sitter-0.20.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:060d4e5b803be0975f1ac46e54a292eab0701296ccd912f6cdac3f7331e29143"}, + {file = "tree_sitter-0.20.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:822e02366dbf223697b2b56b8f91aa5b60571f9fe7c998988a381db1c69604e9"}, + {file = "tree_sitter-0.20.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:527ca72c6a8f60fa719af37fa86f58b7ad0e07b8f74d1c1c7e926c5c888a7e6b"}, + {file = "tree_sitter-0.20.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a418ca71309ea7052e076f08d623f33f58eae01a8e8cdc1e6d3a01b5b8ddebfe"}, + {file = "tree_sitter-0.20.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:08c3ba2561b61a83c28ca06a0bce2a5ffcfb6b39f9d27a45e5ebd9cad2bedb7f"}, + {file = "tree_sitter-0.20.4-cp311-cp311-win32.whl", hash = "sha256:8d04c75a389b2de94952d602264852acff8cd3ed1ccf8a2492a080973d5ddd58"}, + {file = "tree_sitter-0.20.4-cp311-cp311-win_amd64.whl", hash = "sha256:ba9215c0e7529d9eb370528e5d99b7389d14a7eae94f07d14fa9dab18f267c62"}, + {file = "tree_sitter-0.20.4-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:c4c1af5ed4306071d30970c83ec882520a7bf5d8053996dbc4aa5c59238d4990"}, + {file = "tree_sitter-0.20.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:9d70bfa550cf22c9cea9b3c0d18b889fc4f2a7e9dcf1d6cc93f49fa9d4a94954"}, + {file = "tree_sitter-0.20.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6de537bca0641775d8d175d37303d54998980fc0d997dd9aa89e16b415bf0cc3"}, + {file = "tree_sitter-0.20.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b1c0f8c0e3e50267566f5116cdceedf4e23e8c08b55ef3becbe954a11b16e84"}, + {file = "tree_sitter-0.20.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ef2ee6d9bb8e21713949e5ff769ed670fe1217f95b7eeb6c675788438c1e6e"}, + {file = "tree_sitter-0.20.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b6fd1c881ab0de5faa67168db2d001eee32be5482cb4e0b21b217689a05b6fe4"}, + {file = "tree_sitter-0.20.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:bf47047420021d50aec529cb66387c90562350b499ddf56ecef1fc8255439e30"}, + {file = "tree_sitter-0.20.4-cp312-cp312-win32.whl", hash = "sha256:c16b48378041fc9702b6aa3480f2ffa49ca8ea58141a862acd569e5a0679655f"}, + {file = "tree_sitter-0.20.4-cp312-cp312-win_amd64.whl", hash = "sha256:973e871167079a1b1d7304d361449253efbe2a6974728ad563cf407bd02ddccb"}, + {file = "tree_sitter-0.20.4-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:9d33a55598dd18a4d8b869a3417de82a4812c3a7dc7e61cb025ece3e9c3e4e96"}, + {file = "tree_sitter-0.20.4-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7cee6955c2c97fc5927a41c7a8b06647c4b4d9b99b8a1581bf1183435c8cec3e"}, + {file = "tree_sitter-0.20.4-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5022bea67e479ad212be7c05b983a72e297a013efb4e8ea5b5b4d7da79a9fdef"}, + {file = "tree_sitter-0.20.4-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:640f60a5b966f0990338f1bf559455c3dcb822bc4329d82b3d42f32a48374dfe"}, + {file = "tree_sitter-0.20.4-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:0e83f641fe6f27d91bd4d259fff5d35de1567d3f581b9efe9bbd5be50fe4ddc7"}, + {file = "tree_sitter-0.20.4-cp36-cp36m-win32.whl", hash = "sha256:ce6a85027c66fa3f09d482cc6d41927ea40955f7f33b86aedd26dd932709a2c9"}, + {file = "tree_sitter-0.20.4-cp36-cp36m-win_amd64.whl", hash = "sha256:fe10779347a6c067af29cb37fd4b75fa96c5cb68f587cc9530b70fe3f2a51a55"}, + {file = "tree_sitter-0.20.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:28d5f84e34e276887e3a240b60906ca7e2b51e975f3145c3149ceed977a69508"}, + {file = "tree_sitter-0.20.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6c913b65cbe10996116988ac436748f24883b5097e58274223e89bb2c5d1bb1a"}, + {file = "tree_sitter-0.20.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecaed46241e071752195a628bb97d2b740f2fde9e34f8a74456a4ea8bb26df88"}, + {file = "tree_sitter-0.20.4-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:b641e88a97eab002a1736d93ef5a4beac90ea4fd6e25affd1831319b99f456c9"}, + {file = "tree_sitter-0.20.4-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:327c40f439c6155e4eee54c4657e4701a04f5f4816d9defdcb836bf65bf83d21"}, + {file = "tree_sitter-0.20.4-cp37-cp37m-win32.whl", hash = "sha256:1b7c1d95f006b3de42fbf4045bd00c273d113e372fcb6a5378e74ed120c12032"}, + {file = "tree_sitter-0.20.4-cp37-cp37m-win_amd64.whl", hash = "sha256:6140d037239a41046f5d34fba5e0374ee697adb4b48b90579c618b5402781c11"}, + {file = "tree_sitter-0.20.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:f42fd1104efaad8151370f1936e2a488b7337a5d24544a9ab59ba4c4010b1272"}, + {file = "tree_sitter-0.20.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7859717c5d62ee386b3d036cab8ed0f88f8c027b6b4ae476a55a8c5fb8aab713"}, + {file = "tree_sitter-0.20.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:fdd361fe1cc68db68b4d85165641275e34b86cc26b2bab932790204fa14824dc"}, + {file = "tree_sitter-0.20.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b8d7539075606027b67764543463ff2bc4e52f4158ef6dc419c9f5625aa5383"}, + {file = "tree_sitter-0.20.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78e76307f05aca6cde72f3307b4d53701f34ae45f2248ceb83d1626051e201fd"}, + {file = "tree_sitter-0.20.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:dd8c352f4577f61098d06cf3feb7fd214259f41b5036b81003860ed54d16b448"}, + {file = "tree_sitter-0.20.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:281f3e5382d1bd7fccc88d1afe68c915565bc24f8b8dd4844079d46c7815b8a7"}, + {file = "tree_sitter-0.20.4-cp38-cp38-win32.whl", hash = "sha256:6a77ac3cdcddd80cdd1fd394318bff99f94f37e08d235aaefccb87e1224946e5"}, + {file = "tree_sitter-0.20.4-cp38-cp38-win_amd64.whl", hash = "sha256:8eee8adf54033dc48eab84b040f4d7b32355a964c4ae0aae5dfbdc4dbc3364ca"}, + {file = "tree_sitter-0.20.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:e89f6508e30fce05e2c724725d022db30d877817b9d64f933506ffb3a3f4a2c2"}, + {file = "tree_sitter-0.20.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7fb6286bb1fae663c45ff0700ec88fb9b50a81eed2bae8a291f95fcf8cc19547"}, + {file = "tree_sitter-0.20.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:11e93f8b4bbae04070416a82257a7ab2eb0afb76e093ae3ea73bd63b792f6846"}, + {file = "tree_sitter-0.20.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8250725c5f78929aeb2c71db5dca76f1ef448389ca16f9439161f90978bb8478"}, + {file = "tree_sitter-0.20.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d404a8ca9de9b0843844f0cd4d423f46bc46375ab8afb63b1d8ec01201457ac8"}, + {file = "tree_sitter-0.20.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0f2422c9ee70ba972dfc3943746e6cf7fc03725a866908950245bda9ccfc7301"}, + {file = "tree_sitter-0.20.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:21a937942e4729abbe778a609d2c218574436cb351c36fba89ef3c8c6066ec78"}, + {file = "tree_sitter-0.20.4-cp39-cp39-win32.whl", hash = "sha256:427a9a39360cc1816e28f8182550e478e4ba983595a2565ab9dfe32ea1b03fd7"}, + {file = "tree_sitter-0.20.4-cp39-cp39-win_amd64.whl", hash = "sha256:7095bb9aff297fa9c6026bf8914fd295997d714d1a6ee9a1edf7282c772f9f64"}, + {file = "tree_sitter-0.20.4-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:859260b90f0e3867ae840e39f54e830f607b3bc531bc21deeeeaa8a30cbb89ad"}, + {file = "tree_sitter-0.20.4-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0dfc14be73cf46126660a3aecdd0396e69562ad1a902245225ca7bd29649594e"}, + {file = "tree_sitter-0.20.4-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ec46355bf3ff23f54d5e365871ffd3e05cfbc65d1b36a8be7c0bcbda30a1d43"}, + {file = "tree_sitter-0.20.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d933a942fde39876b99c36f12aa3764e4a555ae9366c10ce6cca8c16341c1bbf"}, + {file = "tree_sitter-0.20.4-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a7eec3b55135fe851a38fa248c9fd75fc3d58ceb6e1865b795e416e4d598c2a1"}, + {file = "tree_sitter-0.20.4-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dfc76225529ee14a53e84413480ce81ec3c44eaa0455c140e961c90ac3118ead"}, + {file = "tree_sitter-0.20.4-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ccf0396e47efffc0b528959a8f2e2346a98297579f867e9e1834c2aad4be829c"}, + {file = "tree_sitter-0.20.4-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:a15fbabd3bc8e29c48289c156d743e69f5ec72bb125cf44f7adbdaa1937c3da6"}, + {file = "tree_sitter-0.20.4-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:36f8adf2126f496cf376b6e4b707cba061c25beb17841727eef6f0e083e53e1f"}, + {file = "tree_sitter-0.20.4-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:841efb40c116ab0a066924925409a8a4dcffeb39a151c0b2a1c2abe56ad4fb42"}, + {file = "tree_sitter-0.20.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2051e8a70fd8426f27a43dad71d11929a62ce30a9b1eb65bba0ed79e82481592"}, + {file = "tree_sitter-0.20.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:99a3c2824d4cfcffd9f961176891426bde2cb36ece5280c61480be93319c23c4"}, + {file = "tree_sitter-0.20.4-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:72830dc85a10430eca3d56739b7efcd7a05459c8d425f08c1aee6179ab7f13a9"}, + {file = "tree_sitter-0.20.4-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4992dd226055b6cd0a4f5661c66b799a73d3eff716302e0f7ab06594ee12d49f"}, + {file = "tree_sitter-0.20.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a66d95bbf92175cdc295d6d77f330942811f02e3aaf3fc64431cb749683b2f7d"}, + {file = "tree_sitter-0.20.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a25b1087e4f7825b2458dacf5f4b0be2938f78e850e822edca1ff4994b56081a"}, + {file = "tree_sitter-0.20.4.tar.gz", hash = "sha256:6adb123e2f3e56399bbf2359924633c882cc40ee8344885200bca0922f713be5"}, +] + +[[package]] +name = "tree-sitter-languages" +version = "1.9.1" +description = "Binary Python wheels for all tree sitter languages." +optional = false +python-versions = "*" +files = [ + {file = "tree_sitter_languages-1.9.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5dee458cf1bd1e725470949124e24db842dc789039ea7ff5ba46b338e5f0dc60"}, + {file = "tree_sitter_languages-1.9.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:81921135fa15469586b1528088f78553e60a900d3045f4f37021ad3836219216"}, + {file = "tree_sitter_languages-1.9.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:edd60780d14c727179acb7bb48fbe4f79da9b830abdeb0d12c06a9f2c37928c7"}, + {file = "tree_sitter_languages-1.9.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a28da3f60a6bc23195d6850836e477c149d4aaf58cdb0eb662741dca4f6401e2"}, + {file = "tree_sitter_languages-1.9.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9778c00a58ee77006abc5af905b591551b158ce106c8cc6c3b4148d624ccabf"}, + {file = "tree_sitter_languages-1.9.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:6f68cfec0d74d6344db9c83414f401dcfc753916e71fac7d37f3a5e35b79e5ec"}, + {file = "tree_sitter_languages-1.9.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:02142d81b2cd759b5fe246d403e4fba80b70268d108bd2b108301e64a84437a6"}, + {file = "tree_sitter_languages-1.9.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:ca4e0041c2ead2a8b354b9c229faee152bfd4617480c85cf2b352acf459db3cc"}, + {file = "tree_sitter_languages-1.9.1-cp310-cp310-win32.whl", hash = "sha256:506ff5c3646e7b3a533f9e925221d4fe63b88dad0b7ffc1fb96db4c271994606"}, + {file = "tree_sitter_languages-1.9.1-cp310-cp310-win_amd64.whl", hash = "sha256:3ac3899e05f2bf0a7c8da70ef5a077ab3dbd442f99eb7452aabbe67bc7b29ddf"}, + {file = "tree_sitter_languages-1.9.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:823426c3768eea88b6a4fd70dc668b72de90cc9f44d041a579c76d024d7d0697"}, + {file = "tree_sitter_languages-1.9.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:51f64b11f30cef3c5c9741e06221a46948f7c82d53ea2468139028eaf4858cca"}, + {file = "tree_sitter_languages-1.9.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7e1c384bcd2695ebf873bc63eccfa0b9e1c3c944cd6a6ebdd1139a2528d2d6f"}, + {file = "tree_sitter_languages-1.9.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fecf8553645fc1ad84921e97b03615d84aca22c35d020f629bb44cb6a28a302e"}, + {file = "tree_sitter_languages-1.9.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f1a499004189bf9f338f3412d4c1c05a643e86d4619a60ba4b3ae56bc4bf5db9"}, + {file = "tree_sitter_languages-1.9.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:634ef22744b4af2ed9a43fea8309ec1171b062e37c609c3463364c790a08dae3"}, + {file = "tree_sitter_languages-1.9.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:9394eb34208abcfa9c26ece39778037a8d97da3ef59501185303fef0ab850290"}, + {file = "tree_sitter_languages-1.9.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:221c367be0129da540fbb84170e18c5b8c56c09fd2f6143e116eebbef72c780e"}, + {file = "tree_sitter_languages-1.9.1-cp311-cp311-win32.whl", hash = "sha256:15d03f54f913f47ac36277d8a521cd425415a25b020e0845d7b8843f5f5e1209"}, + {file = "tree_sitter_languages-1.9.1-cp311-cp311-win_amd64.whl", hash = "sha256:7c565c18cebc72417ebc8f0f4cd5cb91dda51874164045cc274f47c913b194aa"}, + {file = "tree_sitter_languages-1.9.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:cde380cdc37594e7fcbade6a4b396dbeab52a1cecfe884cd814e1a1541ca6b93"}, + {file = "tree_sitter_languages-1.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9c4f2409e5460bdec5921ee445f748ea7c319469e347a13373e3c7086dbf0315"}, + {file = "tree_sitter_languages-1.9.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a17bbe91a78a29a9c14ab8bb07ed3761bb2708b58815bafc02d0965b15cb99e5"}, + {file = "tree_sitter_languages-1.9.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:369402e2b395de2655d769e515401fe7c7df247a83aa28a6362e808b8a017fae"}, + {file = "tree_sitter_languages-1.9.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f4a382d1e463e6ae60bbbd0c1f3db48e83b3c1a3af98d652af11de4c0e6171fc"}, + {file = "tree_sitter_languages-1.9.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:bc60fb35f377143b30f4319fbaac0503b12cfb49de34082a479c7f0cc28927f1"}, + {file = "tree_sitter_languages-1.9.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:9e953fb43767e327bf5c1d0585ee39236eaff47683cbda2811cbe0227fd41ad7"}, + {file = "tree_sitter_languages-1.9.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:c5a6df25eae23a5e2d448218b130207476cb8a613ac40570d49008243b0915bb"}, + {file = "tree_sitter_languages-1.9.1-cp312-cp312-win32.whl", hash = "sha256:2720f9a639f5d5c17692135f3f2d60506c240699d0c1becdb895546e553f2339"}, + {file = "tree_sitter_languages-1.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:f19157c33ddc1e75ae7843b813e65575ed2040e1638643251bd603bb0f52046b"}, + {file = "tree_sitter_languages-1.9.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:40880b5e774c3d5759b726273c36f83042d39c600c3aeefaf39248c3adec92d0"}, + {file = "tree_sitter_languages-1.9.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad71366ee2458bda6df5a7476fc0e465a1e1579f53335ce901935efc5c67fdeb"}, + {file = "tree_sitter_languages-1.9.1-cp36-cp36m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a8000c6bf889e35e8b75407ea2d56153534b3f80c3b768378f4ca5a6fe286c0f"}, + {file = "tree_sitter_languages-1.9.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7e20ead363d70b3f0f0b04cf6da30257d22a166700fa39e06c9f263b527688"}, + {file = "tree_sitter_languages-1.9.1-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:444d2662912bc439c54c1b0ffe38354ae648f1f1ac8d1254b14fa768aa1a8587"}, + {file = "tree_sitter_languages-1.9.1-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:cceac9018359310fee46204b452860bfdcb3da00f4518d430790f909cbbf6b4c"}, + {file = "tree_sitter_languages-1.9.1-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:332c182afbd9f7601e268426470e8c453740769a6227e7d1a9636d905cd7d707"}, + {file = "tree_sitter_languages-1.9.1-cp36-cp36m-win32.whl", hash = "sha256:25e993a41ad11fc433cb18ce0cc1d51eb7a285560c5cdddf781139312dac1881"}, + {file = "tree_sitter_languages-1.9.1-cp36-cp36m-win_amd64.whl", hash = "sha256:57419c215092ba9ba1964e07620dd386fc88ebb075b981fbb80f68f58004d4b4"}, + {file = "tree_sitter_languages-1.9.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:06747cac4789c436affa7c6b3483f68cc234e6a75b508a0f8369c77eb1faa04b"}, + {file = "tree_sitter_languages-1.9.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b40bc82005543309c9cd4059f362c9d0d51277c942c71a5fdbed118389e5543a"}, + {file = "tree_sitter_languages-1.9.1-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44920c9654ae03e94baa45c6e8c4b36a5f7bdd0c93877c72931bd77e862adaf1"}, + {file = "tree_sitter_languages-1.9.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82e44f63a5449a41c5de3e9350967dc1c9183d9375881af5efb970c58c3fcfd8"}, + {file = "tree_sitter_languages-1.9.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:df177fa87b655f6234e4dae540ba3917cf8e87c3646423b809415711e926765e"}, + {file = "tree_sitter_languages-1.9.1-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:abdc8793328aa13fbd1cef3a0dff1c2e057a430fe2a64251628bbc97c4774eba"}, + {file = "tree_sitter_languages-1.9.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8b3f319f95f4464c35381755422f6dc0a518ad7d295d3cfe57bbaa564d225f3f"}, + {file = "tree_sitter_languages-1.9.1-cp37-cp37m-win32.whl", hash = "sha256:9f3a59bb4e8ec0a598566e02b7900eb8142236bda6c8b1069c4f3cdaf641950d"}, + {file = "tree_sitter_languages-1.9.1-cp37-cp37m-win_amd64.whl", hash = "sha256:517bdfe34bf24a05a496d441bee836fa77a6864f256508b82457ac28a9ac36bc"}, + {file = "tree_sitter_languages-1.9.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9383331026f736bcbdf6b67f9b45417fe8fbb47225fe2517a1e4f974c319d9a8"}, + {file = "tree_sitter_languages-1.9.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:bba45ff3715e20e6e9a9b402f1ec2f2fc5ce11ce7b223584d0b5be5a4f8c60bb"}, + {file = "tree_sitter_languages-1.9.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:03558927c6e731d81706e3a8b26276eaa4fadba17e2fd83a5e0bc2a32b261975"}, + {file = "tree_sitter_languages-1.9.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6f0231140e2d29fcf987216277483c93bc7ce4c2f88b8af77756d796e17a2957"}, + {file = "tree_sitter_languages-1.9.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ead59b416f03da262df26e282cd40eb487f15384c90290f5105451e9a8ecfea"}, + {file = "tree_sitter_languages-1.9.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:fd27b7bdb95a2b35b730069d7dea60d0f6cc37e5ab2e900d2940a82d1db608bd"}, + {file = "tree_sitter_languages-1.9.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:d8b65a5fafd774a6c6dcacd9ac8b4c258c9f1efe2bfdca0a63818c83e591b949"}, + {file = "tree_sitter_languages-1.9.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:f32f7a7b8fd9952f82e2b881c1c8701a467b27db209590e0effb2fb4d71fe3d3"}, + {file = "tree_sitter_languages-1.9.1-cp38-cp38-win32.whl", hash = "sha256:b52321e2a3a7cd1660cd7dadea16d7c7b9c981e177e0f77f9735e04cd89de015"}, + {file = "tree_sitter_languages-1.9.1-cp38-cp38-win_amd64.whl", hash = "sha256:e8752bec9372937094a2557d9bfff357f30f5aa398e41e76e656baf53b4939d3"}, + {file = "tree_sitter_languages-1.9.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:119f32cfc7c561e252e8958259ef997f2adfd4587ae43e82819b56f2810b8b42"}, + {file = "tree_sitter_languages-1.9.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:582b04e11c67706b0a5ea64fd53ce4910fe11ad29d74ec7680c4014a02d09d4a"}, + {file = "tree_sitter_languages-1.9.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a816f76c52f6c9fb3316c5d44195f8de48e09f2214b7fdb5f9232395033c789c"}, + {file = "tree_sitter_languages-1.9.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3a099b2f69cf22ab77de811b148de7d2d8ba8c51176a64bc56304cf42a627dd4"}, + {file = "tree_sitter_languages-1.9.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:447b6c62c59255c89341ec0968e467e8c59c60fc5c2c3dc1f7dfe159a820dd3c"}, + {file = "tree_sitter_languages-1.9.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:41f4fee9b7de9646ef9711b6dbcdd5a4e7079e3d175089c8ef3f2c68b5adb5f4"}, + {file = "tree_sitter_languages-1.9.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:ee3b70594b79ff1155d5d9fea64e3af240d9327a52526d446e6bd792ac5b43cf"}, + {file = "tree_sitter_languages-1.9.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:087b82cc3943fc5ffac30dc1b4192936a27c3c06fbd8718935a269e30dedc83b"}, + {file = "tree_sitter_languages-1.9.1-cp39-cp39-win32.whl", hash = "sha256:155483058dc11de302f47922d31feec5e1bb9888e661aed7be0dad6f70bfe691"}, + {file = "tree_sitter_languages-1.9.1-cp39-cp39-win_amd64.whl", hash = "sha256:5335405a937f788a2608d1b25c654461dddddbc6a1341672c833d2c8943397a8"}, +] + +[package.dependencies] +tree-sitter = "*" + +[[package]] +name = "types-deprecated" +version = "1.2.9.20240106" +description = "Typing stubs for Deprecated" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-Deprecated-1.2.9.20240106.tar.gz", hash = "sha256:afeb819e9a03d0a5795f18c88fe6207c48ed13c639e93281bd9d9b7bb6d34310"}, + {file = "types_Deprecated-1.2.9.20240106-py3-none-any.whl", hash = "sha256:9dcb258493b5be407574ee21e50ddac9e429072d39b576126bf1ac00764fb9a8"}, +] + +[[package]] +name = "types-docutils" +version = "0.20.0.20240201" +description = "Typing stubs for docutils" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-docutils-0.20.0.20240201.tar.gz", hash = "sha256:ba4bfd4ff6dd19640ba7ab5d93900393a65897880f3650997964a943f4e79a6b"}, + {file = "types_docutils-0.20.0.20240201-py3-none-any.whl", hash = "sha256:79d3bcef235f7c81a63f4f3dcf1d0b138985079bb32d02f5a7d266e1f9f361ba"}, +] + +[[package]] +name = "types-protobuf" +version = "4.24.0.20240129" +description = "Typing stubs for protobuf" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-protobuf-4.24.0.20240129.tar.gz", hash = "sha256:8a83dd3b9b76a33e08d8636c5daa212ace1396418ed91837635fcd564a624891"}, + {file = "types_protobuf-4.24.0.20240129-py3-none-any.whl", hash = "sha256:23be68cc29f3f5213b5c5878ac0151706182874040e220cfb11336f9ee642ead"}, +] + +[[package]] +name = "types-pyopenssl" +version = "24.0.0.20240130" +description = "Typing stubs for pyOpenSSL" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-pyOpenSSL-24.0.0.20240130.tar.gz", hash = "sha256:c812e5c1c35249f75ef5935708b2a997d62abf9745be222e5f94b9595472ab25"}, + {file = "types_pyOpenSSL-24.0.0.20240130-py3-none-any.whl", hash = "sha256:24a255458b5b8a7fca8139cf56f2a8ad5a4f1a5f711b73a5bb9cb50dc688fab5"}, +] + +[package.dependencies] +cryptography = ">=35.0.0" + +[[package]] +name = "types-python-dateutil" +version = "2.8.19.20240106" +description = "Typing stubs for python-dateutil" +optional = false +python-versions = ">=3.8" +files = [ + {file = "types-python-dateutil-2.8.19.20240106.tar.gz", hash = "sha256:1f8db221c3b98e6ca02ea83a58371b22c374f42ae5bbdf186db9c9a76581459f"}, + {file = "types_python_dateutil-2.8.19.20240106-py3-none-any.whl", hash = "sha256:efbbdc54590d0f16152fa103c9879c7d4a00e82078f6e2cf01769042165acaa2"}, +] + +[[package]] +name = "types-pyyaml" +version = "6.0.12.12" +description = "Typing stubs for PyYAML" +optional = false +python-versions = "*" +files = [ + {file = "types-PyYAML-6.0.12.12.tar.gz", hash = "sha256:334373d392fde0fdf95af5c3f1661885fa10c52167b14593eb856289e1855062"}, + {file = "types_PyYAML-6.0.12.12-py3-none-any.whl", hash = "sha256:c05bc6c158facb0676674b7f11fe3960db4f389718e19e62bd2b84d6205cfd24"}, +] + +[[package]] +name = "types-redis" +version = "4.5.5.0" +description = "Typing stubs for redis" +optional = false +python-versions = "*" +files = [ + {file = "types-redis-4.5.5.0.tar.gz", hash = "sha256:26547d91f011a4024375d9216cd4d917b4678c984201d46f72c604526c138523"}, + {file = "types_redis-4.5.5.0-py3-none-any.whl", hash = "sha256:c7132e0cedeb52a83d20138c0440721bfae89cd2027c1ef57a294b56dfde4ee8"}, +] + +[package.dependencies] +cryptography = ">=35.0.0" +types-pyOpenSSL = "*" + +[[package]] +name = "types-requests" +version = "2.28.11.8" +description = "Typing stubs for requests" +optional = false +python-versions = "*" +files = [ + {file = "types-requests-2.28.11.8.tar.gz", hash = "sha256:e67424525f84adfbeab7268a159d3c633862dafae15c5b19547ce1b55954f0a3"}, + {file = "types_requests-2.28.11.8-py3-none-any.whl", hash = "sha256:61960554baca0008ae7e2db2bd3b322ca9a144d3e80ce270f5fb640817e40994"}, +] + +[package.dependencies] +types-urllib3 = "<1.27" + +[[package]] +name = "types-setuptools" +version = "67.1.0.0" +description = "Typing stubs for setuptools" +optional = false +python-versions = "*" +files = [ + {file = "types-setuptools-67.1.0.0.tar.gz", hash = "sha256:162a39d22e3a5eb802197c84f16b19e798101bbd33d9437837fbb45627da5627"}, + {file = "types_setuptools-67.1.0.0-py3-none-any.whl", hash = "sha256:5bd7a10d93e468bfcb10d24cb8ea5e12ac4f4ac91267293959001f1448cf0619"}, +] + +[package.dependencies] +types-docutils = "*" + +[[package]] +name = "types-urllib3" +version = "1.26.25.14" +description = "Typing stubs for urllib3" +optional = false +python-versions = "*" +files = [ + {file = "types-urllib3-1.26.25.14.tar.gz", hash = "sha256:229b7f577c951b8c1b92c1bc2b2fdb0b49847bd2af6d1cc2a2e3dd340f3bda8f"}, + {file = "types_urllib3-1.26.25.14-py3-none-any.whl", hash = "sha256:9683bbb7fb72e32bfe9d2be6e04875fbe1b3eeec3cbb4ea231435aa7fd6b4f0e"}, +] + +[[package]] +name = "typing-extensions" +version = "4.9.0" +description = "Backported and Experimental Type Hints for Python 3.8+" +optional = false +python-versions = ">=3.8" +files = [ + {file = "typing_extensions-4.9.0-py3-none-any.whl", hash = "sha256:af72aea155e91adfc61c3ae9e0e342dbc0cba726d6cba4b6c72c1f34e47291cd"}, + {file = "typing_extensions-4.9.0.tar.gz", hash = "sha256:23478f88c37f27d76ac8aee6c905017a143b0b1b886c3c9f66bc2fd94f9f5783"}, +] + +[[package]] +name = "typing-inspect" +version = "0.9.0" +description = "Runtime inspection utilities for typing module." +optional = false +python-versions = "*" +files = [ + {file = "typing_inspect-0.9.0-py3-none-any.whl", hash = "sha256:9ee6fc59062311ef8547596ab6b955e1b8aa46242d854bfc78f4f6b0eff35f9f"}, + {file = "typing_inspect-0.9.0.tar.gz", hash = "sha256:b23fc42ff6f6ef6954e4852c1fb512cdd18dbea03134f91f856a95ccc9461f78"}, +] + +[package.dependencies] +mypy-extensions = ">=0.3.0" +typing-extensions = ">=3.7.4" + +[[package]] +name = "tzdata" +version = "2024.1" +description = "Provider of IANA time zone data" +optional = false +python-versions = ">=2" +files = [ + {file = "tzdata-2024.1-py2.py3-none-any.whl", hash = "sha256:9068bc196136463f5245e51efda838afa15aaeca9903f49050dfa2679db4d252"}, + {file = "tzdata-2024.1.tar.gz", hash = "sha256:2674120f8d891909751c38abcdfd386ac0a5a1127954fbc332af6b5ceae07efd"}, +] + +[[package]] +name = "uptrain" +version = "0.5.0" +description = "UpTrain - tool to evaluate LLM applications on aspects like factual accuracy, response quality, retrieval quality, tonality, etc." +optional = false +python-versions = "*" +files = [ + {file = "uptrain-0.5.0-py3-none-any.whl", hash = "sha256:7a168c82136f5d3869204e4176b959676075c085dd109582a1fec67e030f58ad"}, + {file = "uptrain-0.5.0.tar.gz", hash = "sha256:81cd37b938d3805cc3dc6031bce4be94c79e57684247b21f341508aad9bc96e6"}, +] + +[package.dependencies] +httpx = ">=0.24.1" +lazy-loader = "*" +loguru = "*" +networkx = "*" +numpy = ">=1.23.0" +pandas = "*" +plotly = ">=5.0.0" +polars = ">=0.18" +pydantic = "<1.10.10" + +[package.extras] +test = ["pytest (>=7.0)"] + +[[package]] +name = "uri-template" +version = "1.3.0" +description = "RFC 6570 URI Template Processor" +optional = false +python-versions = ">=3.7" +files = [ + {file = "uri-template-1.3.0.tar.gz", hash = "sha256:0e00f8eb65e18c7de20d595a14336e9f337ead580c70934141624b6d1ffdacc7"}, + {file = "uri_template-1.3.0-py3-none-any.whl", hash = "sha256:a44a133ea12d44a0c0f06d7d42a52d71282e77e2f937d8abd5655b8d56fc1363"}, +] + +[package.extras] +dev = ["flake8", "flake8-annotations", "flake8-bandit", "flake8-bugbear", "flake8-commas", "flake8-comprehensions", "flake8-continuation", "flake8-datetimez", "flake8-docstrings", "flake8-import-order", "flake8-literal", "flake8-modern-annotations", "flake8-noqa", "flake8-pyproject", "flake8-requirements", "flake8-typechecking-import", "flake8-use-fstring", "mypy", "pep8-naming", "types-PyYAML"] + +[[package]] +name = "urllib3" +version = "2.2.0" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = ">=3.8" +files = [ + {file = "urllib3-2.2.0-py3-none-any.whl", hash = "sha256:ce3711610ddce217e6d113a2732fafad960a03fd0318c91faa79481e35c11224"}, + {file = "urllib3-2.2.0.tar.gz", hash = "sha256:051d961ad0c62a94e50ecf1af379c3aba230c66c710493493560c0c223c49f20"}, +] + +[package.extras] +brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +h2 = ["h2 (>=4,<5)"] +socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] +zstd = ["zstandard (>=0.18.0)"] + +[[package]] +name = "virtualenv" +version = "20.25.0" +description = "Virtual Python Environment builder" +optional = false +python-versions = ">=3.7" +files = [ + {file = "virtualenv-20.25.0-py3-none-any.whl", hash = "sha256:4238949c5ffe6876362d9c0180fc6c3a824a7b12b80604eeb8085f2ed7460de3"}, + {file = "virtualenv-20.25.0.tar.gz", hash = "sha256:bf51c0d9c7dd63ea8e44086fa1e4fb1093a31e963b86959257378aef020e1f1b"}, +] + +[package.dependencies] +distlib = ">=0.3.7,<1" +filelock = ">=3.12.2,<4" +platformdirs = ">=3.9.1,<5" + +[package.extras] +docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"] +test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"] + +[[package]] +name = "wcwidth" +version = "0.2.13" +description = "Measures the displayed width of unicode strings in a terminal" +optional = false +python-versions = "*" +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[[package]] +name = "webcolors" +version = "1.13" +description = "A library for working with the color formats defined by HTML and CSS." +optional = false +python-versions = ">=3.7" +files = [ + {file = "webcolors-1.13-py3-none-any.whl", hash = "sha256:29bc7e8752c0a1bd4a1f03c14d6e6a72e93d82193738fa860cbff59d0fcc11bf"}, + {file = "webcolors-1.13.tar.gz", hash = "sha256:c225b674c83fa923be93d235330ce0300373d02885cef23238813b0d5668304a"}, +] + +[package.extras] +docs = ["furo", "sphinx", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-notfound-page", "sphinxext-opengraph"] +tests = ["pytest", "pytest-cov"] + +[[package]] +name = "webencodings" +version = "0.5.1" +description = "Character encoding aliases for legacy web content" +optional = false +python-versions = "*" +files = [ + {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, + {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, +] + +[[package]] +name = "websocket-client" +version = "1.7.0" +description = "WebSocket client for Python with low level API options" +optional = false +python-versions = ">=3.8" +files = [ + {file = "websocket-client-1.7.0.tar.gz", hash = "sha256:10e511ea3a8c744631d3bd77e61eb17ed09304c413ad42cf6ddfa4c7787e8fe6"}, + {file = "websocket_client-1.7.0-py3-none-any.whl", hash = "sha256:f4c3d22fec12a2461427a29957ff07d35098ee2d976d3ba244e688b8b4057588"}, +] + +[package.extras] +docs = ["Sphinx (>=6.0)", "sphinx-rtd-theme (>=1.1.0)"] +optional = ["python-socks", "wsaccel"] +test = ["websockets"] + +[[package]] +name = "widgetsnbextension" +version = "4.0.10" +description = "Jupyter interactive widgets for Jupyter Notebook" +optional = false +python-versions = ">=3.7" +files = [ + {file = "widgetsnbextension-4.0.10-py3-none-any.whl", hash = "sha256:d37c3724ec32d8c48400a435ecfa7d3e259995201fbefa37163124a9fcb393cc"}, + {file = "widgetsnbextension-4.0.10.tar.gz", hash = "sha256:64196c5ff3b9a9183a8e699a4227fb0b7002f252c814098e66c4d1cd0644688f"}, +] + +[[package]] +name = "win32-setctime" +version = "1.1.0" +description = "A small Python utility to set file creation time on Windows" +optional = false +python-versions = ">=3.5" +files = [ + {file = "win32_setctime-1.1.0-py3-none-any.whl", hash = "sha256:231db239e959c2fe7eb1d7dc129f11172354f98361c4fa2d6d2d7e278baa8aad"}, + {file = "win32_setctime-1.1.0.tar.gz", hash = "sha256:15cf5750465118d6929ae4de4eb46e8edae9a5634350c01ba582df868e932cb2"}, +] + +[package.extras] +dev = ["black (>=19.3b0)", "pytest (>=4.6.2)"] + +[[package]] +name = "wrapt" +version = "1.16.0" +description = "Module for decorators, wrappers and monkey patching." +optional = false +python-versions = ">=3.6" +files = [ + {file = "wrapt-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ffa565331890b90056c01db69c0fe634a776f8019c143a5ae265f9c6bc4bd6d4"}, + {file = "wrapt-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e4fdb9275308292e880dcbeb12546df7f3e0f96c6b41197e0cf37d2826359020"}, + {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb2dee3874a500de01c93d5c71415fcaef1d858370d405824783e7a8ef5db440"}, + {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2a88e6010048489cda82b1326889ec075a8c856c2e6a256072b28eaee3ccf487"}, + {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac83a914ebaf589b69f7d0a1277602ff494e21f4c2f743313414378f8f50a4cf"}, + {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:73aa7d98215d39b8455f103de64391cb79dfcad601701a3aa0dddacf74911d72"}, + {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:807cc8543a477ab7422f1120a217054f958a66ef7314f76dd9e77d3f02cdccd0"}, + {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bf5703fdeb350e36885f2875d853ce13172ae281c56e509f4e6eca049bdfb136"}, + {file = "wrapt-1.16.0-cp310-cp310-win32.whl", hash = "sha256:f6b2d0c6703c988d334f297aa5df18c45e97b0af3679bb75059e0e0bd8b1069d"}, + {file = "wrapt-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:decbfa2f618fa8ed81c95ee18a387ff973143c656ef800c9f24fb7e9c16054e2"}, + {file = "wrapt-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1a5db485fe2de4403f13fafdc231b0dbae5eca4359232d2efc79025527375b09"}, + {file = "wrapt-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:75ea7d0ee2a15733684badb16de6794894ed9c55aa5e9903260922f0482e687d"}, + {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a452f9ca3e3267cd4d0fcf2edd0d035b1934ac2bd7e0e57ac91ad6b95c0c6389"}, + {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:43aa59eadec7890d9958748db829df269f0368521ba6dc68cc172d5d03ed8060"}, + {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:72554a23c78a8e7aa02abbd699d129eead8b147a23c56e08d08dfc29cfdddca1"}, + {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d2efee35b4b0a347e0d99d28e884dfd82797852d62fcd7ebdeee26f3ceb72cf3"}, + {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:6dcfcffe73710be01d90cae08c3e548d90932d37b39ef83969ae135d36ef3956"}, + {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:eb6e651000a19c96f452c85132811d25e9264d836951022d6e81df2fff38337d"}, + {file = "wrapt-1.16.0-cp311-cp311-win32.whl", hash = "sha256:66027d667efe95cc4fa945af59f92c5a02c6f5bb6012bff9e60542c74c75c362"}, + {file = "wrapt-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:aefbc4cb0a54f91af643660a0a150ce2c090d3652cf4052a5397fb2de549cd89"}, + {file = "wrapt-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5eb404d89131ec9b4f748fa5cfb5346802e5ee8836f57d516576e61f304f3b7b"}, + {file = "wrapt-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9090c9e676d5236a6948330e83cb89969f433b1943a558968f659ead07cb3b36"}, + {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94265b00870aa407bd0cbcfd536f17ecde43b94fb8d228560a1e9d3041462d73"}, + {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2058f813d4f2b5e3a9eb2eb3faf8f1d99b81c3e51aeda4b168406443e8ba809"}, + {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98b5e1f498a8ca1858a1cdbffb023bfd954da4e3fa2c0cb5853d40014557248b"}, + {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:14d7dc606219cdd7405133c713f2c218d4252f2a469003f8c46bb92d5d095d81"}, + {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:49aac49dc4782cb04f58986e81ea0b4768e4ff197b57324dcbd7699c5dfb40b9"}, + {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:418abb18146475c310d7a6dc71143d6f7adec5b004ac9ce08dc7a34e2babdc5c"}, + {file = "wrapt-1.16.0-cp312-cp312-win32.whl", hash = "sha256:685f568fa5e627e93f3b52fda002c7ed2fa1800b50ce51f6ed1d572d8ab3e7fc"}, + {file = "wrapt-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:dcdba5c86e368442528f7060039eda390cc4091bfd1dca41e8046af7c910dda8"}, + {file = "wrapt-1.16.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:d462f28826f4657968ae51d2181a074dfe03c200d6131690b7d65d55b0f360f8"}, + {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a33a747400b94b6d6b8a165e4480264a64a78c8a4c734b62136062e9a248dd39"}, + {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3646eefa23daeba62643a58aac816945cadc0afaf21800a1421eeba5f6cfb9c"}, + {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ebf019be5c09d400cf7b024aa52b1f3aeebeff51550d007e92c3c1c4afc2a40"}, + {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:0d2691979e93d06a95a26257adb7bfd0c93818e89b1406f5a28f36e0d8c1e1fc"}, + {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:1acd723ee2a8826f3d53910255643e33673e1d11db84ce5880675954183ec47e"}, + {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:bc57efac2da352a51cc4658878a68d2b1b67dbe9d33c36cb826ca449d80a8465"}, + {file = "wrapt-1.16.0-cp36-cp36m-win32.whl", hash = "sha256:da4813f751142436b075ed7aa012a8778aa43a99f7b36afe9b742d3ed8bdc95e"}, + {file = "wrapt-1.16.0-cp36-cp36m-win_amd64.whl", hash = "sha256:6f6eac2360f2d543cc875a0e5efd413b6cbd483cb3ad7ebf888884a6e0d2e966"}, + {file = "wrapt-1.16.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a0ea261ce52b5952bf669684a251a66df239ec6d441ccb59ec7afa882265d593"}, + {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7bd2d7ff69a2cac767fbf7a2b206add2e9a210e57947dd7ce03e25d03d2de292"}, + {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9159485323798c8dc530a224bd3ffcf76659319ccc7bbd52e01e73bd0241a0c5"}, + {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a86373cf37cd7764f2201b76496aba58a52e76dedfaa698ef9e9688bfd9e41cf"}, + {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:73870c364c11f03ed072dda68ff7aea6d2a3a5c3fe250d917a429c7432e15228"}, + {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:b935ae30c6e7400022b50f8d359c03ed233d45b725cfdd299462f41ee5ffba6f"}, + {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:db98ad84a55eb09b3c32a96c576476777e87c520a34e2519d3e59c44710c002c"}, + {file = "wrapt-1.16.0-cp37-cp37m-win32.whl", hash = "sha256:9153ed35fc5e4fa3b2fe97bddaa7cbec0ed22412b85bcdaf54aeba92ea37428c"}, + {file = "wrapt-1.16.0-cp37-cp37m-win_amd64.whl", hash = "sha256:66dfbaa7cfa3eb707bbfcd46dab2bc6207b005cbc9caa2199bcbc81d95071a00"}, + {file = "wrapt-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1dd50a2696ff89f57bd8847647a1c363b687d3d796dc30d4dd4a9d1689a706f0"}, + {file = "wrapt-1.16.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:44a2754372e32ab315734c6c73b24351d06e77ffff6ae27d2ecf14cf3d229202"}, + {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e9723528b9f787dc59168369e42ae1c3b0d3fadb2f1a71de14531d321ee05b0"}, + {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dbed418ba5c3dce92619656802cc5355cb679e58d0d89b50f116e4a9d5a9603e"}, + {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:941988b89b4fd6b41c3f0bfb20e92bd23746579736b7343283297c4c8cbae68f"}, + {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6a42cd0cfa8ffc1915aef79cb4284f6383d8a3e9dcca70c445dcfdd639d51267"}, + {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:1ca9b6085e4f866bd584fb135a041bfc32cab916e69f714a7d1d397f8c4891ca"}, + {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:d5e49454f19ef621089e204f862388d29e6e8d8b162efce05208913dde5b9ad6"}, + {file = "wrapt-1.16.0-cp38-cp38-win32.whl", hash = "sha256:c31f72b1b6624c9d863fc095da460802f43a7c6868c5dda140f51da24fd47d7b"}, + {file = "wrapt-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:490b0ee15c1a55be9c1bd8609b8cecd60e325f0575fc98f50058eae366e01f41"}, + {file = "wrapt-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9b201ae332c3637a42f02d1045e1d0cccfdc41f1f2f801dafbaa7e9b4797bfc2"}, + {file = "wrapt-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2076fad65c6736184e77d7d4729b63a6d1ae0b70da4868adeec40989858eb3fb"}, + {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5cd603b575ebceca7da5a3a251e69561bec509e0b46e4993e1cac402b7247b8"}, + {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b47cfad9e9bbbed2339081f4e346c93ecd7ab504299403320bf85f7f85c7d46c"}, + {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8212564d49c50eb4565e502814f694e240c55551a5f1bc841d4fcaabb0a9b8a"}, + {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:5f15814a33e42b04e3de432e573aa557f9f0f56458745c2074952f564c50e664"}, + {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:db2e408d983b0e61e238cf579c09ef7020560441906ca990fe8412153e3b291f"}, + {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:edfad1d29c73f9b863ebe7082ae9321374ccb10879eeabc84ba3b69f2579d537"}, + {file = "wrapt-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed867c42c268f876097248e05b6117a65bcd1e63b779e916fe2e33cd6fd0d3c3"}, + {file = "wrapt-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:eb1b046be06b0fce7249f1d025cd359b4b80fc1c3e24ad9eca33e0dcdb2e4a35"}, + {file = "wrapt-1.16.0-py3-none-any.whl", hash = "sha256:6906c4100a8fcbf2fa735f6059214bb13b97f75b1a61777fcf6432121ef12ef1"}, + {file = "wrapt-1.16.0.tar.gz", hash = "sha256:5f370f952971e7d17c7d1ead40e49f32345a7f7a5373571ef44d800d06b1899d"}, +] + +[[package]] +name = "yarl" +version = "1.9.4" +description = "Yet another URL library" +optional = false +python-versions = ">=3.7" +files = [ + {file = "yarl-1.9.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a8c1df72eb746f4136fe9a2e72b0c9dc1da1cbd23b5372f94b5820ff8ae30e0e"}, + {file = "yarl-1.9.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:a3a6ed1d525bfb91b3fc9b690c5a21bb52de28c018530ad85093cc488bee2dd2"}, + {file = "yarl-1.9.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c38c9ddb6103ceae4e4498f9c08fac9b590c5c71b0370f98714768e22ac6fa66"}, + {file = "yarl-1.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d9e09c9d74f4566e905a0b8fa668c58109f7624db96a2171f21747abc7524234"}, + {file = "yarl-1.9.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b8477c1ee4bd47c57d49621a062121c3023609f7a13b8a46953eb6c9716ca392"}, + {file = "yarl-1.9.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5ff2c858f5f6a42c2a8e751100f237c5e869cbde669a724f2062d4c4ef93551"}, + {file = "yarl-1.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:357495293086c5b6d34ca9616a43d329317feab7917518bc97a08f9e55648455"}, + {file = "yarl-1.9.4-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:54525ae423d7b7a8ee81ba189f131054defdb122cde31ff17477951464c1691c"}, + {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:801e9264d19643548651b9db361ce3287176671fb0117f96b5ac0ee1c3530d53"}, + {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e516dc8baf7b380e6c1c26792610230f37147bb754d6426462ab115a02944385"}, + {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:7d5aaac37d19b2904bb9dfe12cdb08c8443e7ba7d2852894ad448d4b8f442863"}, + {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:54beabb809ffcacbd9d28ac57b0db46e42a6e341a030293fb3185c409e626b8b"}, + {file = "yarl-1.9.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bac8d525a8dbc2a1507ec731d2867025d11ceadcb4dd421423a5d42c56818541"}, + {file = "yarl-1.9.4-cp310-cp310-win32.whl", hash = "sha256:7855426dfbddac81896b6e533ebefc0af2f132d4a47340cee6d22cac7190022d"}, + {file = "yarl-1.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:848cd2a1df56ddbffeb375535fb62c9d1645dde33ca4d51341378b3f5954429b"}, + {file = "yarl-1.9.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:35a2b9396879ce32754bd457d31a51ff0a9d426fd9e0e3c33394bf4b9036b099"}, + {file = "yarl-1.9.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4c7d56b293cc071e82532f70adcbd8b61909eec973ae9d2d1f9b233f3d943f2c"}, + {file = "yarl-1.9.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d8a1c6c0be645c745a081c192e747c5de06e944a0d21245f4cf7c05e457c36e0"}, + {file = "yarl-1.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4b3c1ffe10069f655ea2d731808e76e0f452fc6c749bea04781daf18e6039525"}, + {file = "yarl-1.9.4-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:549d19c84c55d11687ddbd47eeb348a89df9cb30e1993f1b128f4685cd0ebbf8"}, + {file = "yarl-1.9.4-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a7409f968456111140c1c95301cadf071bd30a81cbd7ab829169fb9e3d72eae9"}, + {file = "yarl-1.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e23a6d84d9d1738dbc6e38167776107e63307dfc8ad108e580548d1f2c587f42"}, + {file = "yarl-1.9.4-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d8b889777de69897406c9fb0b76cdf2fd0f31267861ae7501d93003d55f54fbe"}, + {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:03caa9507d3d3c83bca08650678e25364e1843b484f19986a527630ca376ecce"}, + {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:4e9035df8d0880b2f1c7f5031f33f69e071dfe72ee9310cfc76f7b605958ceb9"}, + {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:c0ec0ed476f77db9fb29bca17f0a8fcc7bc97ad4c6c1d8959c507decb22e8572"}, + {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:ee04010f26d5102399bd17f8df8bc38dc7ccd7701dc77f4a68c5b8d733406958"}, + {file = "yarl-1.9.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:49a180c2e0743d5d6e0b4d1a9e5f633c62eca3f8a86ba5dd3c471060e352ca98"}, + {file = "yarl-1.9.4-cp311-cp311-win32.whl", hash = "sha256:81eb57278deb6098a5b62e88ad8281b2ba09f2f1147c4767522353eaa6260b31"}, + {file = "yarl-1.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:d1d2532b340b692880261c15aee4dc94dd22ca5d61b9db9a8a361953d36410b1"}, + {file = "yarl-1.9.4-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0d2454f0aef65ea81037759be5ca9947539667eecebca092733b2eb43c965a81"}, + {file = "yarl-1.9.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:44d8ffbb9c06e5a7f529f38f53eda23e50d1ed33c6c869e01481d3fafa6b8142"}, + {file = "yarl-1.9.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:aaaea1e536f98754a6e5c56091baa1b6ce2f2700cc4a00b0d49eca8dea471074"}, + {file = "yarl-1.9.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3777ce5536d17989c91696db1d459574e9a9bd37660ea7ee4d3344579bb6f129"}, + {file = "yarl-1.9.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9fc5fc1eeb029757349ad26bbc5880557389a03fa6ada41703db5e068881e5f2"}, + {file = "yarl-1.9.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ea65804b5dc88dacd4a40279af0cdadcfe74b3e5b4c897aa0d81cf86927fee78"}, + {file = "yarl-1.9.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa102d6d280a5455ad6a0f9e6d769989638718e938a6a0a2ff3f4a7ff8c62cc4"}, + {file = "yarl-1.9.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09efe4615ada057ba2d30df871d2f668af661e971dfeedf0c159927d48bbeff0"}, + {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:008d3e808d03ef28542372d01057fd09168419cdc8f848efe2804f894ae03e51"}, + {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:6f5cb257bc2ec58f437da2b37a8cd48f666db96d47b8a3115c29f316313654ff"}, + {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:992f18e0ea248ee03b5a6e8b3b4738850ae7dbb172cc41c966462801cbf62cf7"}, + {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:0e9d124c191d5b881060a9e5060627694c3bdd1fe24c5eecc8d5d7d0eb6faabc"}, + {file = "yarl-1.9.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3986b6f41ad22988e53d5778f91855dc0399b043fc8946d4f2e68af22ee9ff10"}, + {file = "yarl-1.9.4-cp312-cp312-win32.whl", hash = "sha256:4b21516d181cd77ebd06ce160ef8cc2a5e9ad35fb1c5930882baff5ac865eee7"}, + {file = "yarl-1.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:a9bd00dc3bc395a662900f33f74feb3e757429e545d831eef5bb280252631984"}, + {file = "yarl-1.9.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:63b20738b5aac74e239622d2fe30df4fca4942a86e31bf47a81a0e94c14df94f"}, + {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7d7f7de27b8944f1fee2c26a88b4dabc2409d2fea7a9ed3df79b67277644e17"}, + {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c74018551e31269d56fab81a728f683667e7c28c04e807ba08f8c9e3bba32f14"}, + {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ca06675212f94e7a610e85ca36948bb8fc023e458dd6c63ef71abfd482481aa5"}, + {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5aef935237d60a51a62b86249839b51345f47564208c6ee615ed2a40878dccdd"}, + {file = "yarl-1.9.4-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2b134fd795e2322b7684155b7855cc99409d10b2e408056db2b93b51a52accc7"}, + {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:d25039a474c4c72a5ad4b52495056f843a7ff07b632c1b92ea9043a3d9950f6e"}, + {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:f7d6b36dd2e029b6bcb8a13cf19664c7b8e19ab3a58e0fefbb5b8461447ed5ec"}, + {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:957b4774373cf6f709359e5c8c4a0af9f6d7875db657adb0feaf8d6cb3c3964c"}, + {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:d7eeb6d22331e2fd42fce928a81c697c9ee2d51400bd1a28803965883e13cead"}, + {file = "yarl-1.9.4-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:6a962e04b8f91f8c4e5917e518d17958e3bdee71fd1d8b88cdce74dd0ebbf434"}, + {file = "yarl-1.9.4-cp37-cp37m-win32.whl", hash = "sha256:f3bc6af6e2b8f92eced34ef6a96ffb248e863af20ef4fde9448cc8c9b858b749"}, + {file = "yarl-1.9.4-cp37-cp37m-win_amd64.whl", hash = "sha256:ad4d7a90a92e528aadf4965d685c17dacff3df282db1121136c382dc0b6014d2"}, + {file = "yarl-1.9.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ec61d826d80fc293ed46c9dd26995921e3a82146feacd952ef0757236fc137be"}, + {file = "yarl-1.9.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:8be9e837ea9113676e5754b43b940b50cce76d9ed7d2461df1af39a8ee674d9f"}, + {file = "yarl-1.9.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:bef596fdaa8f26e3d66af846bbe77057237cb6e8efff8cd7cc8dff9a62278bbf"}, + {file = "yarl-1.9.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2d47552b6e52c3319fede1b60b3de120fe83bde9b7bddad11a69fb0af7db32f1"}, + {file = "yarl-1.9.4-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:84fc30f71689d7fc9168b92788abc977dc8cefa806909565fc2951d02f6b7d57"}, + {file = "yarl-1.9.4-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4aa9741085f635934f3a2583e16fcf62ba835719a8b2b28fb2917bb0537c1dfa"}, + {file = "yarl-1.9.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:206a55215e6d05dbc6c98ce598a59e6fbd0c493e2de4ea6cc2f4934d5a18d130"}, + {file = "yarl-1.9.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07574b007ee20e5c375a8fe4a0789fad26db905f9813be0f9fef5a68080de559"}, + {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:5a2e2433eb9344a163aced6a5f6c9222c0786e5a9e9cac2c89f0b28433f56e23"}, + {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:6ad6d10ed9b67a382b45f29ea028f92d25bc0bc1daf6c5b801b90b5aa70fb9ec"}, + {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:6fe79f998a4052d79e1c30eeb7d6c1c1056ad33300f682465e1b4e9b5a188b78"}, + {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:a825ec844298c791fd28ed14ed1bffc56a98d15b8c58a20e0e08c1f5f2bea1be"}, + {file = "yarl-1.9.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:8619d6915b3b0b34420cf9b2bb6d81ef59d984cb0fde7544e9ece32b4b3043c3"}, + {file = "yarl-1.9.4-cp38-cp38-win32.whl", hash = "sha256:686a0c2f85f83463272ddffd4deb5e591c98aac1897d65e92319f729c320eece"}, + {file = "yarl-1.9.4-cp38-cp38-win_amd64.whl", hash = "sha256:a00862fb23195b6b8322f7d781b0dc1d82cb3bcac346d1e38689370cc1cc398b"}, + {file = "yarl-1.9.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:604f31d97fa493083ea21bd9b92c419012531c4e17ea6da0f65cacdcf5d0bd27"}, + {file = "yarl-1.9.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8a854227cf581330ffa2c4824d96e52ee621dd571078a252c25e3a3b3d94a1b1"}, + {file = "yarl-1.9.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ba6f52cbc7809cd8d74604cce9c14868306ae4aa0282016b641c661f981a6e91"}, + {file = "yarl-1.9.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a6327976c7c2f4ee6816eff196e25385ccc02cb81427952414a64811037bbc8b"}, + {file = "yarl-1.9.4-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8397a3817d7dcdd14bb266283cd1d6fc7264a48c186b986f32e86d86d35fbac5"}, + {file = "yarl-1.9.4-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e0381b4ce23ff92f8170080c97678040fc5b08da85e9e292292aba67fdac6c34"}, + {file = "yarl-1.9.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23d32a2594cb5d565d358a92e151315d1b2268bc10f4610d098f96b147370136"}, + {file = "yarl-1.9.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ddb2a5c08a4eaaba605340fdee8fc08e406c56617566d9643ad8bf6852778fc7"}, + {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:26a1dc6285e03f3cc9e839a2da83bcbf31dcb0d004c72d0730e755b33466c30e"}, + {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:18580f672e44ce1238b82f7fb87d727c4a131f3a9d33a5e0e82b793362bf18b4"}, + {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:29e0f83f37610f173eb7e7b5562dd71467993495e568e708d99e9d1944f561ec"}, + {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:1f23e4fe1e8794f74b6027d7cf19dc25f8b63af1483d91d595d4a07eca1fb26c"}, + {file = "yarl-1.9.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:db8e58b9d79200c76956cefd14d5c90af54416ff5353c5bfd7cbe58818e26ef0"}, + {file = "yarl-1.9.4-cp39-cp39-win32.whl", hash = "sha256:c7224cab95645c7ab53791022ae77a4509472613e839dab722a72abe5a684575"}, + {file = "yarl-1.9.4-cp39-cp39-win_amd64.whl", hash = "sha256:824d6c50492add5da9374875ce72db7a0733b29c2394890aef23d533106e2b15"}, + {file = "yarl-1.9.4-py3-none-any.whl", hash = "sha256:928cecb0ef9d5a7946eb6ff58417ad2fe9375762382f1bf5c55e61645f2c43ad"}, + {file = "yarl-1.9.4.tar.gz", hash = "sha256:566db86717cf8080b99b58b083b773a908ae40f06681e87e589a976faf8246bf"}, +] + +[package.dependencies] +idna = ">=2.0" +multidict = ">=4.0" + +[[package]] +name = "zipp" +version = "3.17.0" +description = "Backport of pathlib-compatible object wrapper for zip files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "zipp-3.17.0-py3-none-any.whl", hash = "sha256:0e923e726174922dce09c53c59ad483ff7bbb8e572e00c7f7c46b88556409f31"}, + {file = "zipp-3.17.0.tar.gz", hash = "sha256:84e64a1c28cf7e91ed2078bb8cc8c259cb19b76942096c8d7b84947690cabaf0"}, +] + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy (>=0.9.1)", "pytest-ruff"] + +[metadata] +lock-version = "2.0" +python-versions = ">=3.8.1,<3.12" +content-hash = "1abf8c8fe8824de42816fc0bab833f23e98f29fb2b8a550e067f6d85cb1fcbaa" diff --git a/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/pyproject.toml b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/pyproject.toml new file mode 100644 index 00000000000000..5cd3d191cc538f --- /dev/null +++ b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/pyproject.toml @@ -0,0 +1,55 @@ +[build-system] +build-backend = "poetry.core.masonry.api" +requires = ["poetry-core"] + +[tool.codespell] +check-filenames = true +check-hidden = true +skip = "*.csv,*.html,*.json,*.jsonl,*.pdf,*.txt,*.ipynb" + +[tool.mypy] +disallow_untyped_defs = true +exclude = ["_static", "build", "examples", "notebooks", "venv"] +ignore_missing_imports = true +python_version = "3.8" + +[tool.poetry] +authors = ["Your Name "] +description = "llama-index callbacks uptrain integration" +license = "MIT" +name = "llama-index-callbacks-uptrain" +readme = "README.md" +version = "0.1.0" + +[tool.poetry.dependencies] +python = ">=3.8.1,<3.12" +llama-index-core = "0.10.0" +uptrain = ">=0.5.0" + +[tool.poetry.group.dev.dependencies] +ipython = "8.10.0" +jupyter = "^1.0.0" +mypy = "0.991" +pre-commit = "3.2.0" +pylint = "2.15.10" +pytest = "7.2.1" +pytest-mock = "3.11.1" +ruff = "0.0.292" +tree-sitter-languages = "1.9.1" +types-Deprecated = ">=0.1.0" +types-PyYAML = "^6.0.12.12" +types-protobuf = "^4.24.0.4" +types-redis = "4.5.5.0" +types-requests = "2.28.11.8" +types-setuptools = "67.1.0.0" + +[tool.poetry.group.dev.dependencies.black] +extras = ["jupyter"] +version = "<=23.9.1,>=23.7.0" + +[tool.poetry.group.dev.dependencies.codespell] +extras = ["toml"] +version = ">=v2.2.6" + +[[tool.poetry.packages]] +include = "llama_index/" diff --git a/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/tests/BUILD b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/tests/BUILD new file mode 100644 index 00000000000000..dabf212d7e7162 --- /dev/null +++ b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/tests/BUILD @@ -0,0 +1 @@ +python_tests() diff --git a/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/tests/__init__.py b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/tests/__init__.py new file mode 100644 index 00000000000000..e69de29bb2d1d6 diff --git a/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/tests/test_uptrain_callback.py b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/tests/test_uptrain_callback.py new file mode 100644 index 00000000000000..7abf9a195d59cf --- /dev/null +++ b/llama-index-integrations/callbacks/llama-index-callbacks-uptrain/tests/test_uptrain_callback.py @@ -0,0 +1,7 @@ +from llama_index.callbacks.uptrain.base import UpTrainCallbackHandler +from llama_index.core.callbacks.base_handler import BaseCallbackHandler + + +def test_handler_callable(): + names_of_base_classes = [b.__name__ for b in UpTrainCallbackHandler.__mro__] + assert BaseCallbackHandler.__name__ in names_of_base_classes diff --git a/llama-index-legacy/llama_index/legacy/callbacks/__init__.py b/llama-index-legacy/llama_index/legacy/callbacks/__init__.py index 097353e3bd3415..d419baa947969c 100644 --- a/llama-index-legacy/llama_index/legacy/callbacks/__init__.py +++ b/llama-index-legacy/llama_index/legacy/callbacks/__init__.py @@ -5,6 +5,7 @@ from .open_inference_callback import OpenInferenceCallbackHandler from .schema import CBEvent, CBEventType, EventPayload from .token_counting import TokenCountingHandler +from .uptrain_callback import UpTrainCallbackHandler from .utils import trace_method from .wandb_callback import WandbCallbackHandler @@ -21,4 +22,5 @@ "OpenAIFineTuningHandler", "GradientAIFineTuningHandler", "trace_method", + "UpTrainCallbackHandler", ] diff --git a/llama-index-legacy/llama_index/legacy/callbacks/global_handlers.py b/llama-index-legacy/llama_index/legacy/callbacks/global_handlers.py index f191de2181bdab..c52ed3ed354f14 100644 --- a/llama-index-legacy/llama_index/legacy/callbacks/global_handlers.py +++ b/llama-index-legacy/llama_index/legacy/callbacks/global_handlers.py @@ -14,6 +14,7 @@ ) from llama_index.legacy.callbacks.promptlayer_handler import PromptLayerHandler from llama_index.legacy.callbacks.simple_llm_handler import SimpleLLMHandler +from llama_index.legacy.callbacks.uptrain_callback import UpTrainCallbackHandler from llama_index.legacy.callbacks.wandb_callback import WandbCallbackHandler @@ -40,6 +41,8 @@ def create_global_handler(eval_mode: str, **eval_params: Any) -> BaseCallbackHan handler = deepeval_callback_handler(**eval_params) elif eval_mode == "simple": handler = SimpleLLMHandler(**eval_params) + elif eval_mode == "uptrain": + handler = UpTrainCallbackHandler(**eval_params) elif eval_mode == "argilla": handler = argilla_callback_handler(**eval_params) else: