From e980c1271c9631ba0888d9b77ab4b5a89fc40429 Mon Sep 17 00:00:00 2001 From: Robert Osazuwa Ness Date: Mon, 2 Jan 2023 21:21:44 -0700 Subject: [PATCH] PC tutorial using ASIA data (#67) * Create PC algo tutorial * Add updated poetry lock file * Fix notebook and update docs for CI. Fix code spell Signed-off-by: Robert Ness Co-authored-by: Adam Li Signed-off-by: Adam Li --- .circleci/config.yml | 4 +- .codespellignore | 1 + .gitignore | 4 + README.md | 3 + doc/conf.py | 4 + doc/index.rst | 4 +- doc/tutorials.rst | 12 - doc/tutorials/index.rst | 18 + doc/tutorials/markovian/example-pc-algo.ipynb | 899 ++++++++++++++++ doc/use.rst | 2 +- doc/whats_new/_contributors.rst | 1 + doc/whats_new/v0.1.rst | 2 + dodiscover/constraint/pcalg.py | 51 +- poetry.lock | 977 +++++++++++++----- pyproject.toml | 1 + 15 files changed, 1704 insertions(+), 279 deletions(-) delete mode 100644 doc/tutorials.rst create mode 100644 doc/tutorials/index.rst create mode 100644 doc/tutorials/markovian/example-pc-algo.ipynb diff --git a/.circleci/config.yml b/.circleci/config.yml index bc6206b9..c6a30af8 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -46,8 +46,8 @@ jobs: - run: name: Install the latest version of Poetry command: | - curl -sSL https://raw.githubusercontent.com/python-poetry/poetry/master/get-poetry.py | POETRY_UNINSTALL=1 python - - curl -sSL https://install.python-poetry.org | python3 - --version 1.2.2 + curl -sSL https://install.python-poetry.org | python3 - --version 1.3.0 + poetry --version - run: name: Set BASH_ENV command: | diff --git a/.codespellignore b/.codespellignore index 77cb0080..e4ab998d 100644 --- a/.codespellignore +++ b/.codespellignore @@ -1 +1,2 @@ raison +wee \ No newline at end of file diff --git a/.gitignore b/.gitignore index 6ab30854..72a35bbe 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,10 @@ __pycache__/ # C extensions *.so +# possibly produced from drawing graphs +*.gv +*.png + junit-results.xml # Distribution / packaging diff --git a/README.md b/README.md index 48f4ea44..3d96ddab 100644 --- a/README.md +++ b/README.md @@ -49,5 +49,8 @@ To install the package from github, clone the repository and then `cd` into the # for graph functionality poetry install --extras graph_func + # to load datasets used in tutorials + poetry install --extras data + # if you would like an editable install of dodiscover for dev purposes pip install -e . diff --git a/doc/conf.py b/doc/conf.py index 18abf7a6..c8b3b805 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -263,6 +263,10 @@ "image_scrapers": scrapers, } +# prevent jupyter notebooks from being run even if empty cell +# nbsphinx_execute = "never" +nbsphinx_allow_errors = True + # Custom sidebar templates, maps document names to template names. html_sidebars = { "index": ["search-field.html"], diff --git a/doc/index.rst b/doc/index.rst index f13a22dc..f068a093 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -15,13 +15,13 @@ Contents -------- .. toctree:: - :maxdepth: 1 + :maxdepth: 2 :caption: Getting started: installation api use - tutorials + tutorials/index whats_new .. toctree:: diff --git a/doc/tutorials.rst b/doc/tutorials.rst deleted file mode 100644 index 97ece826..00000000 --- a/doc/tutorials.rst +++ /dev/null @@ -1,12 +0,0 @@ -:orphan: - -******** -Tutorial -******** - -.. _dodiscover_tutorials: - -Using dodiscover -===================== -This tutorial shows how to use dodiscover - diff --git a/doc/tutorials/index.rst b/doc/tutorials/index.rst new file mode 100644 index 00000000..46070e2f --- /dev/null +++ b/doc/tutorials/index.rst @@ -0,0 +1,18 @@ +********* +Tutorials +********* + +.. _models_tutorials: + +Basic causal discovery models without latent confounders +======================================================== +The first tutorial presents several algorithms for causal discovery without latent confounding: the Peters and Clarke (PC) algorithm. +These models provide a basis for learning causal structure from data when we make the **assumption** that there are +no latent confounders. + +.. toctree:: + :maxdepth: 1 + :titlesonly: + + markovian/example-pc-algo + diff --git a/doc/tutorials/markovian/example-pc-algo.ipynb b/doc/tutorials/markovian/example-pc-algo.ipynb new file mode 100644 index 00000000..d5fa254e --- /dev/null +++ b/doc/tutorials/markovian/example-pc-algo.ipynb @@ -0,0 +1,899 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3e91e320", + "metadata": {}, + "source": [ + "# PC algorithm for causal discovery from observational data without latent confounders\n", + "\n", + "In this tutorial, we will demonstrate how to use the PC algorithm to learn a causal graph structure and highlight some of the common challenges in applying causal discovery algorithms to data.\n", + "\n", + "The PC algorithm works on observational data when there are no unobserved latent confounders." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "95e12b39", + "metadata": {}, + "outputs": [], + "source": [ + "import bnlearn as bn\n", + "import networkx as nx\n", + "import numpy as np\n", + "\n", + "from pywhy_graphs import CPDAG\n", + "from pywhy_graphs.viz import draw\n", + "\n", + "from dodiscover import PC, make_context\n", + "from dodiscover.ci import GSquareCITest, Oracle" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e77e7416", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[bnlearn] >Extracting files..\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ATSLBEXD
011111111
111000000
211010111
311010110
411111111
\n", + "
" + ], + "text/plain": [ + " A T S L B E X D\n", + "0 1 1 1 1 1 1 1 1\n", + "1 1 1 0 0 0 0 0 0\n", + "2 1 1 0 1 0 1 1 1\n", + "3 1 1 0 1 0 1 1 0\n", + "4 1 1 1 1 1 1 1 1" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load example dataset\n", + "data = bn.import_example(data='asia')\n", + "data.rename(columns = {\n", + " 'tub': 'T',\n", + " 'lung': 'L',\n", + " 'bronc': 'B',\n", + " 'asia': 'A',\n", + " 'smoke': 'S',\n", + " 'either': 'E',\n", + " 'xray': 'X',\n", + " 'dysp': 'D'},\n", + " inplace=True\n", + ")\n", + "data.head()" + ] + }, + { + "cell_type": "markdown", + "id": "84323abd", + "metadata": {}, + "source": [ + "We'll use the PC algorithm to infer the ASIA network. The ASIA network is a case study of an expert system for diagnosing lung disease from Lauritzen and Spiegelhalter (1988). Given respiratory symptions and other evidence, the goal is to distinguish between tuberculosis, lung cancer or bronchitis in a given patient." + ] + }, + { + "cell_type": "markdown", + "id": "e5620376", + "metadata": {}, + "source": [ + "Our goal is to discover this graph structure from observational data. To this end, we'll use the dodiscover implementation of the PC algorithm. First, we'll implement the ground truth graph." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "33fa1389", + "metadata": {}, + "outputs": [], + "source": [ + "ground_truth_edges = [\n", + " (\"A\", \"T\"),\n", + " (\"T\", \"E\"),\n", + " (\"L\", \"E\"),\n", + " (\"S\", \"L\"),\n", + " (\"S\", \"B\"),\n", + " (\"B\", \"D\"),\n", + " (\"E\", \"D\"),\n", + " (\"E\", \"X\")\n", + " ]\n", + "\n", + "ground_truth = nx.DiGraph(ground_truth_edges)" + ] + }, + { + "cell_type": "markdown", + "id": "de591d7c", + "metadata": {}, + "source": [ + "The ground truth DAG can be visualized and is seen as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d7815b62", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pos = nx.spring_layout(ground_truth, seed=1234)\n", + "nx.draw(ground_truth, with_labels=True, pos=pos)" + ] + }, + { + "cell_type": "markdown", + "id": "ec0242ea", + "metadata": {}, + "source": [ + "The variables in the DAG have the following interpretation:\n", + "\n", + "* T: Whether or not the patient has **tuberculosis**.\n", + "* L: Whether or not the patient has **lung cancer**.\n", + "* B: Whether or not the patient has **bronchitis**.\n", + "* A: Whether or not the patient has recently visited **Asia**.\n", + "* S: Whether or not the patient is a **smoker**.\n", + "* E: An indicator of whether the patient has either lung cancer or tuberculosis (or both).\n", + "* X: Whether or not a chest X-ray shows evidence of tuberculosis or lung cancer.\n", + "* D: Whether or not the patient has **dyspnoea** (difficulty breathing).\n", + "\n", + "Note we have three kinds of variables, diseases (B, L, T, and E which indicates one or more diseases), symptoms (X and D), and behaviors (S and A). The goal of the model is to use symptoms and behaviors to diagnose (i.e. infer) diseases. Further, note that diseases are causes of symptoms, and are effects of behaviors." + ] + }, + { + "cell_type": "markdown", + "id": "b769b7f1", + "metadata": {}, + "source": [ + "This is the ground truth, but ground truth is not learnable from observational data alone. We can only learn a CPDAG (complete partially directed acyclic graph), which has a mixture of directed and undirected graph. The undirected edges are edges where we cannot learn causal direction from observations alone.\n", + "\n", + "In technical terms, the CPDAG represents an equivalence class of DAGs. In other words, the CPDAG represents all the DAGs that we could create by orienting the undirected edges (except for those DAGs that would introduce new colliders), because each of those DAGs are equally probable given the data. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "30a29f1d", + "metadata": {}, + "outputs": [], + "source": [ + "cpdag_directed = [\n", + " (\"T\", \"E\"),\n", + " (\"L\", \"E\"),\n", + " (\"B\", \"D\"),\n", + " (\"E\", \"D\"),\n", + " (\"E\", \"X\")\n", + " ]\n", + "\n", + "cpdag_undirected = [\n", + " (\"A\", \"T\"),\n", + " (\"S\", \"L\"),\n", + " (\"S\", \"B\"),\n", + " ]\n", + "\n", + "ground_truth_cpdag = CPDAG(cpdag_directed, cpdag_undirected)" + ] + }, + { + "cell_type": "markdown", + "id": "5a9d2aae", + "metadata": {}, + "source": [ + "## Instantiate some conditional independence tests\n", + "\n", + "The PC algorithm is a constraint-based causal discovery algorithm, which means it uses statistical constraints induced by causal relationships to learn those causal relationships. The most commonly used constraint is conditional independence. Constraint-based algorithms run a series of statistical tests for conditional independence (CI) and construct a graph consistent with those assumptions.\n", + "\n", + "So we need a way to test for CI constraints. There are various options for tests. If we are applying the algorithm on real data, we would want to use the CI test that best suits the data. \n", + "\n", + "If we are interested in evaluating how the discovery algorithm works in an ideal setting, we can use an oracle, which is imbued with the ground-truth graph, which can query all the d-separation statements needed. This can help one determine in a simulation setting, what is the best case graph the PC algorithm can learn.\n", + "\n", + "**Warnings about statistical tests for independence**. \n", + "* Note that because of finite sample sizes, any CI test will sometimes make erroneous conclusions. Errors results in incorrect orientations and edges in the learned graph. Further, constraint-based algorithms run multiple tests in sequence, which causes those errors to accumulate. One might use adjustments for multiple comparisons to compensate.\n", + "* The standard statistical test has a null and alternative hypothesis. The alternative hypothesis should be the hypothesis that the thing one is looking for is present, while the null hypothesis is that thing is not present. In causal discovery, the thing we are looking for is causal structure, and conditional independence is evidence of causal structure. So arguably, the alternative hypothesis should be the hypothesis of conditional independence. However, most CI test implementations take the hypothesis of independence as the null hypothesis.\n", + "* The p-value decreases with the size of the data. So the more data is provided, the more likely the test will favor dependence. For large data sizes, use smaller significance thresholds.\n", + "\n", + "For these reasons, the user should view the results of the CI test more as a heuristic than a rigorous statistical test. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "902d126f", + "metadata": {}, + "outputs": [], + "source": [ + "oracle = Oracle(ground_truth)" + ] + }, + { + "cell_type": "markdown", + "id": "591c00cf", + "metadata": {}, + "source": [ + "## Define the context\n", + "\n", + "A common anti-pattern in causal discovery is encouraging the user to see the discovery algorithm as a philosopher's stone that converts data to causal relationships. In other words, discovery libraries tend to encourage users tend to surrender the task of providing domain-specific assumptions that enable identifiability to the algorithm. PyWhy's key strength is how it guides users to specifying domain assumptions up front (in the form of a DAG) before the data is added, and then addresses identifiability given those assumptions and data. \n", + "\n", + "To this end, we introduce the `context.Context` class, where users provide data as the primary input to a discovery algorithm. The Context class houses both data, a priori assumptions and other relevant data that may be used in downstream structure learning algorithms.\n", + "\n", + "In this example, we'll use the context object to specify some fixed edges in the graph." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "89a4f0af", + "metadata": {}, + "outputs": [], + "source": [ + "context = make_context().variables(data=data).build()" + ] + }, + { + "cell_type": "markdown", + "id": "efcf01c7", + "metadata": {}, + "source": [ + "## Run discovery algorithm\n", + "\n", + "Now we are ready to run the PC algorithm. First, we will show the output of the oracle, which is the best case scenario the PC algorithm can learn given an infinite amount of data." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "e5cba859", + "metadata": {}, + "outputs": [], + "source": [ + "pc = PC(ci_estimator=oracle)\n", + "pc.fit(data, context)" + ] + }, + { + "cell_type": "markdown", + "id": "ff7ebc10", + "metadata": {}, + "source": [ + "The resulting completely partially directed acyclic graph (CPDAG) that is learned is a \"Markov equivalence class\", which encodes all the conditional dependences that were learned from the data." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "918c6f5f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "T\n", + "\n", + "T\n", + "\n", + "\n", + "\n", + "A\n", + "\n", + "A\n", + "\n", + "\n", + "\n", + "T->A\n", + "\n", + "\n", + "\n", + "\n", + "D\n", + "\n", + "D\n", + "\n", + "\n", + "\n", + "T->D\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "E\n", + "\n", + "E\n", + "\n", + "\n", + "\n", + "T->E\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "X\n", + "\n", + "X\n", + "\n", + "\n", + "\n", + "T->X\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "S\n", + "\n", + "S\n", + "\n", + "\n", + "\n", + "L\n", + "\n", + "L\n", + "\n", + "\n", + "\n", + "S->L\n", + "\n", + "\n", + "\n", + "\n", + "B\n", + "\n", + "B\n", + "\n", + "\n", + "\n", + "S->B\n", + "\n", + "\n", + "\n", + "\n", + "L->D\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "L->E\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "L->X\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "B->D\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "E->D\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "E->X\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "graph = pc.graph_\n", + "\n", + "draw(graph, direction='TB')" + ] + }, + { + "cell_type": "markdown", + "id": "162d98be", + "metadata": {}, + "source": [ + "Compare this against the ground truth CPDAG, which should match exactly." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "67d47367", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "A\n", + "\n", + "A\n", + "\n", + "\n", + "\n", + "T\n", + "\n", + "T\n", + "\n", + "\n", + "\n", + "A->T\n", + "\n", + "\n", + "\n", + "\n", + "E\n", + "\n", + "E\n", + "\n", + "\n", + "\n", + "T->E\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "D\n", + "\n", + "D\n", + "\n", + "\n", + "\n", + "T->D\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "X\n", + "\n", + "X\n", + "\n", + "\n", + "\n", + "T->X\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "S\n", + "\n", + "S\n", + "\n", + "\n", + "\n", + "L\n", + "\n", + "L\n", + "\n", + "\n", + "\n", + "S->L\n", + "\n", + "\n", + "\n", + "\n", + "B\n", + "\n", + "B\n", + "\n", + "\n", + "\n", + "S->B\n", + "\n", + "\n", + "\n", + "\n", + "L->E\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "L->D\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "L->X\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "B->D\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "E->D\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "E->X\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "draw(ground_truth_cpdag, direction='TB')" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "0569e7c4-a571-484c-a07b-e6935c55fd39", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The oracle learned CPDAG via the PC algorithm matches the ground truth in directed edges: True \n", + "and matches the undirected edges: True\n" + ] + } + ], + "source": [ + "match_directed = nx.is_isomorphic(ground_truth_cpdag.sub_directed_graph(), graph.sub_directed_graph())\n", + "match_undirected = nx.is_isomorphic(ground_truth_cpdag.sub_undirected_graph(), graph.sub_undirected_graph())\n", + "\n", + "print(f'The oracle learned CPDAG via the PC algorithm matches the ground truth in directed edges: {match_directed} \\n'\n", + " f'and matches the undirected edges: {match_undirected}')" + ] + }, + { + "cell_type": "markdown", + "id": "db1ff244", + "metadata": {}, + "source": [ + "Now, we will show the output given a real CI test, which performs CI hypothesis testing to determine CI in the data. Due to finite data and the presence of noise, there is always a possibility that the CI test makes a mistake. In order to maximize the chances that the graph is correct, you want to ensure that the CI test you are using matches the assumptions you have on your data. \n", + "\n", + "For example, the G^2 binary test is a well-suited test for binary data, which we validated is the type of data we have for the ASIA dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5b80aeba", + "metadata": {}, + "outputs": [], + "source": [ + "ci_estimator = GSquareCITest(data_type=\"binary\")\n", + "pc = PC(ci_estimator=ci_estimator, alpha=0.05)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "64a5d4a9-1e07-4282-813c-a080322eaff0", + "metadata": {}, + "outputs": [], + "source": [ + "pc.fit(data, context)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "c948064b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "B\n", + "\n", + "B\n", + "\n", + "\n", + "\n", + "S\n", + "\n", + "S\n", + "\n", + "\n", + "\n", + "B->S\n", + "\n", + "\n", + "\n", + "\n", + "D\n", + "\n", + "D\n", + "\n", + "\n", + "\n", + "B->D\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "L\n", + "\n", + "L\n", + "\n", + "\n", + "\n", + "L->S\n", + "\n", + "\n", + "\n", + "\n", + "E\n", + "\n", + "E\n", + "\n", + "\n", + "\n", + "L->E\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "X\n", + "\n", + "X\n", + "\n", + "\n", + "\n", + "X->D\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "T\n", + "\n", + "T\n", + "\n", + "\n", + "\n", + "T->E\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "A\n", + "\n", + "A\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "graph = pc.graph_\n", + "draw(graph, direction='TB')" + ] + }, + { + "cell_type": "markdown", + "id": "ff0b314b", + "metadata": {}, + "source": [ + "The resulting graph captures some of the graph but not all of it. The problem here is a violation of the [faithfulness assumption](https://plato.stanford.edu/entries/causal-models/#MiniFaitCond); e.g. in the Asia data, it is very hard to detect the edge between E and X. This highlights a common problem with causal discovery, where the inability to detect certain edges may lead to incorrect orientations.\n", + "\n", + "Beyond faithfulness violations, in general causal discovery algorithms struggle when there is no user-provided causal knowledge to constrain the problem. A core philosophy of dodiscovery is that causal domain knowledge should be provided to constrain the problem, and providing it should be easy. For example, for this data, we know that smoking (S) causes both lung cancer (L) and bronchitis (B) and not the other way around.\n", + "\n", + "## References\n", + "\n", + "Lauritzen S, Spiegelhalter D (1988). \"Local Computation with Probabilities on Graphical Structures and their Application to Expert Systems (with discussion)\". Journal of the Royal Statistical Society: Series B, 50(2):157–224.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pywhy-discover", + "language": "python", + "name": "pywhy-discover" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + }, + "vscode": { + "interpreter": { + "hash": "f69a7104467f431c4bacbebec40c4cb5787ef707a55bea5c5fb34f2af39396ab" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/doc/use.rst b/doc/use.rst index 6aea93d8..78a74b93 100644 --- a/doc/use.rst +++ b/doc/use.rst @@ -3,7 +3,7 @@ Using dodiscover ===================== -To be able to effectively use dodiscover, look at some of the examples here +To be able to effectively use dodiscover, look at some of the basic examples here to learn everything you need! diff --git a/doc/whats_new/_contributors.rst b/doc/whats_new/_contributors.rst index 14a98c41..4d8bbc02 100644 --- a/doc/whats_new/_contributors.rst +++ b/doc/whats_new/_contributors.rst @@ -22,3 +22,4 @@ .. _Adam Li: https://adam2392.github.io .. _Chris Trevino: https://py-why.github.io +.. _Robert Osazuwa Ness: https://py-why.github.io \ No newline at end of file diff --git a/doc/whats_new/v0.1.rst b/doc/whats_new/v0.1.rst index 03343a54..269c8bfe 100644 --- a/doc/whats_new/v0.1.rst +++ b/doc/whats_new/v0.1.rst @@ -37,6 +37,7 @@ Changelog - |Feature| Implement FCI algorithm, :class:`dodiscover.constraint.FCI` for learning causal structure from observational data with latent confounders under the ``dodiscover.constraint`` submodule, by `Adam Li`_ (:pr:`52`) - |Feature| Implement Structural Hamming Distance metric to compare directed graphs, :func:`dodiscover.metrics.structure_hamming_dist`, by `Adam Li`_ (:pr:`55`) - |Fix| Update dependency on networkx, which removes a PR branch dependency with pywhy-graphs having the MixedEdgeGraph class that was causing a dependency conflict, by `Adam Li`_ (:pr:`74`) +- |Enhancement| Add tutorial for PC algorithm with Asia data, by `Robert Osazuwa Ness`_ (:pr:`67`) Code and Documentation Contributors ----------------------------------- @@ -46,3 +47,4 @@ the project since version inception, including: * `Adam Li`_ * `Chris Trevino`_ +* `Robert Osazuwa Ness`_ diff --git a/dodiscover/constraint/pcalg.py b/dodiscover/constraint/pcalg.py index e4b79603..ec9e6020 100644 --- a/dodiscover/constraint/pcalg.py +++ b/dodiscover/constraint/pcalg.py @@ -1,5 +1,5 @@ import logging -from itertools import combinations, permutations +from itertools import combinations from typing import Optional import networkx as nx @@ -134,37 +134,36 @@ def orient_edges(self, graph: EquivalenceClass) -> None: A skeleton graph. If ``None``, then will initialize PC using a complete graph. By default None. """ - node_ids = graph.nodes - # For all the combination of nodes i and j, apply the following # rules. idx = 0 finished = False while idx < self.max_iter and not finished: # type: ignore change_flag = False - for (i, j) in permutations(node_ids, 2): - if i == j: - continue - # Rule 1: Orient i-j into i->j whenever there is an arrow k->i - # such that k and j are nonadjacent. - r1_add = self._apply_meek_rule1(graph, i, j) - - # Rule 2: Orient i-j into i->j whenever there is a chain - # i->k->j. - r2_add = self._apply_meek_rule2(graph, i, j) - - # Rule 3: Orient i-j into i->j whenever there are two chains - # i-k->j and i-l->j such that k and l are nonadjacent. - r3_add = self._apply_meek_rule3(graph, i, j) - - # Rule 4: Orient i-j into i->j whenever there are two chains - # i-k->l and k->l->j such that k and j are nonadjacent. - # - # However, this rule is not necessary when the PC-algorithm - # is used to estimate a DAG. - - if any([r1_add, r2_add, r3_add]) and not change_flag: - change_flag = True + for i in graph.nodes: + for j in graph.neighbors(i): + if i == j: + continue + # Rule 1: Orient i-j into i->j whenever there is an arrow k->i + # such that k and j are nonadjacent. + r1_add = self._apply_meek_rule1(graph, i, j) + + # Rule 2: Orient i-j into i->j whenever there is a chain + # i->k->j. + r2_add = self._apply_meek_rule2(graph, i, j) + + # Rule 3: Orient i-j into i->j whenever there are two chains + # i-k->j and i-l->j such that k and l are nonadjacent. + r3_add = self._apply_meek_rule3(graph, i, j) + + # Rule 4: Orient i-j into i->j whenever there are two chains + # i-k->l and k->l->j such that k and j are nonadjacent. + # + # However, this rule is not necessary when the PC-algorithm + # is used to estimate a DAG. + + if any([r1_add, r2_add, r3_add]) and not change_flag: + change_flag = True if not change_flag: finished = True logger.info(f"Finished applying R1-3, with {idx} iterations") diff --git a/poetry.lock b/poetry.lock index dff66254..b36ce27e 100644 --- a/poetry.lock +++ b/poetry.lock @@ -10,7 +10,7 @@ python-versions = "*" name = "appnope" version = "0.1.3" description = "Disable App Nap on macOS >= 10.9" -category = "dev" +category = "main" optional = false python-versions = "*" @@ -45,7 +45,7 @@ pytz = ">=2015.7" name = "backcall" version = "0.2.0" description = "Specifications for callback functions passed in to an API" -category = "dev" +category = "main" optional = false python-versions = "*" @@ -123,6 +123,42 @@ webencodings = "*" css = ["tinycss2 (>=1.1.0,<1.2)"] dev = ["Sphinx (==4.3.2)", "black (==22.3.0)", "build (==0.8.0)", "flake8 (==4.0.1)", "hashin (==0.17.0)", "mypy (==0.961)", "pip-tools (==6.6.2)", "pytest (==7.1.2)", "tox (==3.25.0)", "twine (==4.0.1)", "wheel (==0.37.1)"] +[[package]] +name = "bnlearn" +version = "0.7.12" +description = "Python package for learning the graphical structure of Bayesian networks, parameter learning, inference and sampling methods." +category = "main" +optional = true +python-versions = ">=3" +develop = false + +[package.dependencies] +df2onehot = "*" +fsspec = "*" +funcsigs = "*" +ipywidgets = "*" +ismember = "*" +matplotlib = ">=3.3.4" +networkx = ">=2.7.1" +numpy = "*" +packaging = "*" +pandas = "*" +pgmpy = ">=0.1.18" +pypickle = "*" +python-louvain = "*" +pyvis = "*" +scikit-learn = "*" +statsmodels = "*" +tabulate = "*" +tqdm = "*" +wget = "*" + +[package.source] +type = "git" +url = "https://github.com/erdogant/bnlearn.git" +reference = 'master' +resolved_reference = "172c209d1d64278b0b58573910805aad167f37e0" + [[package]] name = "certifi" version = "2022.12.7" @@ -135,7 +171,7 @@ python-versions = ">=3.6" name = "cffi" version = "1.15.1" description = "Foreign Function Interface for Python calling C code." -category = "dev" +category = "main" optional = false python-versions = "*" @@ -181,15 +217,29 @@ toml = ["tomli"] name = "colorama" version = "0.4.6" description = "Cross-platform colored terminal text." -category = "dev" +category = "main" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +[[package]] +name = "comm" +version = "0.1.2" +description = "Jupyter Python Comm implementation, for usage in ipykernel, xeus-python etc." +category = "main" +optional = true +python-versions = ">=3.6" + +[package.dependencies] +traitlets = ">=5.3" + +[package.extras] +test = ["pytest"] + [[package]] name = "contourpy" version = "1.0.6" description = "Python library for calculating contours of 2D quadrilateral grids" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -205,7 +255,7 @@ test-no-codebase = ["Pillow", "matplotlib", "pytest"] [[package]] name = "coverage" -version = "7.0.1" +version = "7.0.2" description = "Code coverage measurement for Python" category = "dev" optional = false @@ -221,15 +271,23 @@ toml = ["tomli"] name = "cycler" version = "0.11.0" description = "Composable style cycles" -category = "dev" +category = "main" optional = false python-versions = ">=3.6" +[[package]] +name = "debugpy" +version = "1.6.4" +description = "An implementation of the Debug Adapter Protocol for Python" +category = "main" +optional = true +python-versions = ">=3.7" + [[package]] name = "decorator" version = "5.1.1" description = "Decorators for Humans" -category = "dev" +category = "main" optional = false python-versions = ">=3.5" @@ -241,6 +299,21 @@ category = "dev" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +[[package]] +name = "df2onehot" +version = "1.0.2" +description = "Python package df2onehot is to convert a pandas dataframe into a stuctured dataframe." +category = "main" +optional = true +python-versions = ">=3" + +[package.dependencies] +numpy = "*" +pandas = "*" +scikit-learn = "*" +tqdm = "*" +wget = "*" + [[package]] name = "docstring-parser" version = "0.15" @@ -282,7 +355,7 @@ plotting = ["matplotlib"] name = "entrypoints" version = "0.4" description = "Discover and load entry points from installed packages." -category = "dev" +category = "main" optional = false python-versions = ">=3.6" @@ -341,7 +414,7 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" name = "fonttools" version = "4.38.0" description = "Tools to manipulate font files" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -359,6 +432,45 @@ ufo = ["fs (>=2.2.0,<3)"] unicode = ["unicodedata2 (>=14.0.0)"] woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"] +[[package]] +name = "fsspec" +version = "2022.11.0" +description = "File-system specification" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.extras] +abfs = ["adlfs"] +adl = ["adlfs"] +arrow = ["pyarrow (>=1)"] +dask = ["dask", "distributed"] +dropbox = ["dropbox", "dropboxdrivefs", "requests"] +entrypoints = ["importlib-metadata"] +fuse = ["fusepy"] +gcs = ["gcsfs"] +git = ["pygit2"] +github = ["requests"] +gs = ["gcsfs"] +gui = ["panel"] +hdfs = ["pyarrow (>=1)"] +http = ["aiohttp (!=4.0.0a0,!=4.0.0a1)", "requests"] +libarchive = ["libarchive-c"] +oci = ["ocifs"] +s3 = ["s3fs"] +sftp = ["paramiko"] +smb = ["smbprotocol"] +ssh = ["paramiko"] +tqdm = ["tqdm"] + +[[package]] +name = "funcsigs" +version = "1.0.2" +description = "Python function signatures from PEP362 for Python 2.6, 2.7 and 3.2+" +category = "main" +optional = true +python-versions = "*" + [[package]] name = "ghp-import" version = "2.1.0" @@ -386,7 +498,7 @@ smmap = ">=3.0.1,<6" [[package]] name = "GitPython" -version = "3.1.29" +version = "3.1.30" description = "GitPython is a python library used to interact with Git repositories" category = "dev" optional = false @@ -438,7 +550,7 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" [[package]] name = "importlib-metadata" -version = "5.2.0" +version = "6.0.0" description = "Read metadata from Python packages" category = "dev" optional = false @@ -475,11 +587,38 @@ category = "dev" optional = false python-versions = "*" +[[package]] +name = "ipykernel" +version = "6.19.4" +description = "IPython Kernel for Jupyter" +category = "main" +optional = true +python-versions = ">=3.8" + +[package.dependencies] +appnope = {version = "*", markers = "platform_system == \"Darwin\""} +comm = ">=0.1.1" +debugpy = ">=1.0" +ipython = ">=7.23.1" +jupyter-client = ">=6.1.12" +matplotlib-inline = ">=0.1" +nest-asyncio = "*" +packaging = "*" +psutil = "*" +pyzmq = ">=17" +tornado = ">=6.1" +traitlets = ">=5.4.0" + +[package.extras] +cov = ["coverage[toml]", "curio", "matplotlib", "pytest-cov", "trio"] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx", "sphinxcontrib-github-alt"] +test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio", "pytest-cov", "pytest-timeout"] + [[package]] name = "ipython" version = "7.34.0" description = "IPython: Productive Interactive Computing" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -508,6 +647,35 @@ parallel = ["ipyparallel"] qtconsole = ["qtconsole"] test = ["ipykernel", "nbformat", "nose (>=0.10.1)", "numpy (>=1.17)", "pygments", "requests", "testpath"] +[[package]] +name = "ipywidgets" +version = "8.0.4" +description = "Jupyter interactive widgets" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.dependencies] +ipykernel = ">=4.5.1" +ipython = ">=6.1.0" +jupyterlab-widgets = ">=3.0,<4.0" +traitlets = ">=4.3.1" +widgetsnbextension = ">=4.0,<5.0" + +[package.extras] +test = ["jsonschema", "pytest (>=3.6.0)", "pytest-cov", "pytz"] + +[[package]] +name = "ismember" +version = "1.0.2" +description = "Python package ismember returns array elements that are members of set array." +category = "main" +optional = true +python-versions = ">=3" + +[package.dependencies] +numpy = "*" + [[package]] name = "isort" version = "5.11.4" @@ -526,7 +694,7 @@ requirements-deprecated-finder = ["pip-api", "pipreqs"] name = "jedi" version = "0.18.2" description = "An autocompletion tool for Python that can be used for text editors." -category = "dev" +category = "main" optional = false python-versions = ">=3.6" @@ -542,7 +710,7 @@ testing = ["Django (<3.1)", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] name = "Jinja2" version = "3.1.2" description = "A very fast and expressive template engine." -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -560,6 +728,19 @@ category = "main" optional = false python-versions = ">=3.7" +[[package]] +name = "jsonpickle" +version = "3.0.1" +description = "Python library for serializing any arbitrary object graph into JSON" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.extras] +docs = ["jaraco.packaging (>=3.2)", "rst.linker (>=1.9)", "sphinx"] +testing = ["ecdsa", "feedparser", "gmpy2", "numpy", "pandas", "pymongo", "pytest (>=3.5,!=3.7.3)", "pytest-black-multipy", "pytest-checkdocs (>=1.2.3)", "pytest-cov", "pytest-flake8 (>=1.1.1)", "scikit-learn", "sqlalchemy"] +"testing.libs" = ["simplejson", "ujson"] + [[package]] name = "jsonschema" version = "4.17.3" @@ -582,7 +763,7 @@ format-nongpl = ["fqdn", "idna", "isoduration", "jsonpointer (>1.13)", "rfc3339- name = "jupyter-client" version = "7.4.8" description = "Jupyter protocol implementation and client libraries" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -601,9 +782,9 @@ test = ["codecov", "coverage", "ipykernel (>=6.12)", "ipython", "mypy", "pre-com [[package]] name = "jupyter-core" -version = "5.1.1" +version = "5.1.2" description = "Jupyter core package. A base package on which Jupyter projects rely." -category = "dev" +category = "main" optional = false python-versions = ">=3.8" @@ -613,7 +794,7 @@ pywin32 = {version = ">=1.0", markers = "sys_platform == \"win32\" and platform_ traitlets = ">=5.3" [package.extras] -docs = ["myst-parser", "sphinxcontrib-github-alt", "traitlets"] +docs = ["myst-parser", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"] test = ["ipykernel", "pre-commit", "pytest", "pytest-cov", "pytest-timeout"] [[package]] @@ -624,11 +805,19 @@ category = "dev" optional = false python-versions = ">=3.7" +[[package]] +name = "jupyterlab-widgets" +version = "3.0.5" +description = "Jupyter interactive widgets for JupyterLab" +category = "main" +optional = true +python-versions = ">=3.7" + [[package]] name = "kiwisolver" version = "1.4.4" description = "A fast implementation of the Cassowary constraint solver" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -689,7 +878,7 @@ testing = ["coverage", "pyyaml"] name = "MarkupSafe" version = "2.1.1" description = "Safely add untrusted strings to HTML/XML markup." -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -697,7 +886,7 @@ python-versions = ">=3.7" name = "matplotlib" version = "3.6.2" description = "Python plotting package" -category = "dev" +category = "main" optional = false python-versions = ">=3.8" @@ -717,7 +906,7 @@ setuptools_scm = ">=7" name = "matplotlib-inline" version = "0.1.6" description = "Inline Matplotlib backend for Jupyter" -category = "dev" +category = "main" optional = false python-versions = ">=3.5" @@ -919,7 +1108,7 @@ test = ["pep440", "pre-commit", "pytest", "testpath"] [[package]] name = "nbsphinx" -version = "0.8.10" +version = "0.8.11" description = "Jupyter Notebook Tools for Sphinx" category = "dev" optional = false @@ -937,7 +1126,7 @@ traitlets = ">=5" name = "nest-asyncio" version = "1.5.6" description = "Patch asyncio to allow nested event loops" -category = "dev" +category = "main" optional = false python-versions = ">=3.5" @@ -979,11 +1168,74 @@ sphinx = ">=4.2" [package.extras] testing = ["matplotlib", "pytest", "pytest-cov"] +[[package]] +name = "nvidia-cublas-cu11" +version = "11.10.3.66" +description = "CUBLAS native runtime libraries" +category = "main" +optional = true +python-versions = ">=3" + +[package.dependencies] +setuptools = "*" +wheel = "*" + +[[package]] +name = "nvidia-cuda-nvrtc-cu11" +version = "11.7.99" +description = "NVRTC native runtime libraries" +category = "main" +optional = true +python-versions = ">=3" + +[package.dependencies] +setuptools = "*" +wheel = "*" + +[[package]] +name = "nvidia-cuda-runtime-cu11" +version = "11.7.99" +description = "CUDA Runtime native Libraries" +category = "main" +optional = true +python-versions = ">=3" + +[package.dependencies] +setuptools = "*" +wheel = "*" + +[[package]] +name = "nvidia-cudnn-cu11" +version = "8.5.0.96" +description = "cuDNN runtime libraries" +category = "main" +optional = true +python-versions = ">=3" + +[package.dependencies] +setuptools = "*" +wheel = "*" + +[[package]] +name = "opt-einsum" +version = "3.3.0" +description = "Optimizing numpys einsum function" +category = "main" +optional = true +python-versions = ">=3.5" + +[package.dependencies] +numpy = ">=1.7" + +[package.extras] +docs = ["numpydoc", "sphinx (==1.2.3)", "sphinx-rtd-theme", "sphinxcontrib-napoleon"] +tests = ["pytest", "pytest-cov", "pytest-pep8"] + [[package]] name = "packaging" version = "22.0" description = "Core utilities for Python packages" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -1018,7 +1270,7 @@ python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" name = "parso" version = "0.8.3" description = "A Python Parser" -category = "dev" +category = "main" optional = false python-versions = ">=3.6" @@ -1046,7 +1298,7 @@ python-versions = ">=3.7" name = "patsy" version = "0.5.3" description = "A Python package for describing statistical models and for building design matrices." -category = "dev" +category = "main" optional = false python-versions = "*" @@ -1083,31 +1335,56 @@ Markdown = ">=3.0.0" name = "pexpect" version = "4.8.0" description = "Pexpect allows easy control of interactive console applications." -category = "dev" +category = "main" optional = false python-versions = "*" [package.dependencies] ptyprocess = ">=0.5" +[[package]] +name = "pgmpy" +version = "0.1.21" +description = "A library for Probabilistic Graphical Models" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +joblib = "*" +networkx = "*" +numpy = "*" +opt-einsum = "*" +pandas = "*" +pyparsing = "*" +scikit-learn = "*" +scipy = "*" +statsmodels = "*" +torch = "*" +tqdm = "*" + +[package.extras] +all = ["black", "codecov", "coverage", "daft", "joblib", "mock", "networkx", "numpy", "opt-einsum", "pandas", "pyparsing", "pytest", "pytest-cov", "scikit-learn", "scipy", "statsmodels", "torch", "tqdm", "xdoctest"] +tests = ["black", "codecov", "coverage", "mock", "pytest", "pytest-cov", "xdoctest"] + [[package]] name = "pickleshare" version = "0.7.5" description = "Tiny 'shelve'-like database with concurrency support" -category = "dev" +category = "main" optional = false python-versions = "*" [[package]] name = "Pillow" -version = "9.3.0" +version = "9.4.0" description = "Python Imaging Library (Fork)" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" [package.extras] -docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-issues (>=3.0.1)", "sphinx-removed-in", "sphinxext-opengraph"] +docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-issues (>=3.0.1)", "sphinx-removed-in", "sphinxext-opengraph"] tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] [[package]] @@ -1122,7 +1399,7 @@ python-versions = ">=3.6" name = "platformdirs" version = "2.6.2" description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -1180,7 +1457,7 @@ yaspin = ">=0.15.0,<3" name = "prompt-toolkit" version = "3.0.36" description = "Library for building powerful interactive command lines in Python" -category = "dev" +category = "main" optional = false python-versions = ">=3.6.2" @@ -1191,7 +1468,7 @@ wcwidth = "*" name = "psutil" version = "5.9.4" description = "Cross-platform lib for process and system monitoring in Python." -category = "dev" +category = "main" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" @@ -1202,7 +1479,7 @@ test = ["enum34", "ipaddress", "mock", "pywin32", "wmi"] name = "ptyprocess" version = "0.7.0" description = "Run a subprocess in a pseudo terminal" -category = "dev" +category = "main" optional = false python-versions = "*" @@ -1210,7 +1487,7 @@ python-versions = "*" name = "py" version = "1.11.0" description = "library with cross-python path, ini-parsing, io, code, log facilities" -category = "dev" +category = "main" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" @@ -1254,7 +1531,7 @@ python-versions = ">=3.6" name = "pycparser" version = "2.21" description = "C parser in Python" -category = "dev" +category = "main" optional = false python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" @@ -1280,17 +1557,17 @@ test = ["pydata-sphinx-theme[doc]", "pytest"] [[package]] name = "pydocstyle" -version = "6.1.1" +version = "6.2.0" description = "Python docstring style checker" category = "dev" optional = false python-versions = ">=3.6" [package.dependencies] -snowballstemmer = "*" +snowballstemmer = ">=2.2.0" [package.extras] -toml = ["toml"] +toml = ["toml (>=0.10.2)"] [[package]] name = "pydot" @@ -1313,9 +1590,9 @@ python-versions = ">=3.6" [[package]] name = "Pygments" -version = "2.13.0" +version = "2.14.0" description = "Pygments is a syntax highlighting package written in Python." -category = "dev" +category = "main" optional = false python-versions = ">=3.6" @@ -1345,16 +1622,24 @@ markdown = ">=3.2" name = "pyparsing" version = "3.0.9" description = "pyparsing module - Classes and methods to define and execute parsing grammars" -category = "dev" +category = "main" optional = false python-versions = ">=3.6.8" [package.extras] diagrams = ["jinja2", "railroad-diagrams"] +[[package]] +name = "pypickle" +version = "1.1.0" +description = "pypickle is to save and load variables in/from pickle files" +category = "main" +optional = true +python-versions = ">=3" + [[package]] name = "pyrsistent" -version = "0.19.2" +version = "0.19.3" description = "Persistent/Functional/Immutable data structures" category = "dev" optional = false @@ -1406,6 +1691,18 @@ python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7" [package.dependencies] six = ">=1.5" +[[package]] +name = "python-louvain" +version = "0.16" +description = "Louvain algorithm for community detection" +category = "main" +optional = true +python-versions = "*" + +[package.dependencies] +networkx = "*" +numpy = "*" + [[package]] name = "pytz" version = "2022.7" @@ -1414,6 +1711,20 @@ category = "main" optional = false python-versions = "*" +[[package]] +name = "pyvis" +version = "0.3.1" +description = "A Python network graph visualization library" +category = "main" +optional = true +python-versions = ">3.6" + +[package.dependencies] +ipython = ">=5.3.0" +jinja2 = ">=2.9.6" +jsonpickle = ">=1.4.1" +networkx = ">=1.11" + [[package]] name = "pywhy-graphs" version = "0.0.0" @@ -1442,7 +1753,7 @@ resolved_reference = "59246229b2f36a25a1dafbecaa346ab255cb15bb" name = "pywin32" version = "305" description = "Python for Window Extensions" -category = "dev" +category = "main" optional = false python-versions = "*" @@ -1469,7 +1780,7 @@ pyyaml = "*" name = "pyzmq" version = "24.0.1" description = "Python bindings for 0MQ" -category = "dev" +category = "main" optional = false python-versions = ">=3.6" @@ -1535,7 +1846,7 @@ test = ["asv", "gmpy2", "mpmath", "pytest", "pytest-cov", "pytest-xdist", "sciki name = "setuptools" version = "65.6.3" description = "Easily download, build, install, upgrade, and uninstall Python packages" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -1548,7 +1859,7 @@ testing-integration = ["build[virtualenv]", "filelock (>=3.4.0)", "jaraco.envs ( name = "setuptools-scm" version = "7.1.0" description = "the blessed package to manage your versions by scm tags" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -1773,7 +2084,7 @@ test = ["pytest"] name = "statsmodels" version = "0.13.2" description = "Statistical computations and models for Python" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -1793,7 +2104,7 @@ docs = ["ipykernel", "jupyter_client", "matplotlib", "nbconvert", "nbformat", "n name = "statsmodels" version = "0.13.3" description = "Statistical computations and models for Python" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -1813,7 +2124,7 @@ docs = ["ipykernel", "jupyter_client", "matplotlib", "nbconvert", "nbformat", "n name = "statsmodels" version = "0.13.4" description = "Statistical computations and models for Python" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -1833,7 +2144,7 @@ docs = ["ipykernel", "jupyter_client", "matplotlib", "nbconvert", "nbformat", "n name = "statsmodels" version = "0.13.5" description = "Statistical computations and models for Python" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -1874,6 +2185,17 @@ python-versions = ">=3.8" [package.dependencies] mpmath = ">=0.19" +[[package]] +name = "tabulate" +version = "0.9.0" +description = "Pretty-print tabular data" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.extras] +widechars = ["wcwidth"] + [[package]] name = "termcolor-whl" version = "1.1.2" @@ -1925,15 +2247,33 @@ python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" name = "tomli" version = "2.0.1" description = "A lil' TOML parser" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" +[[package]] +name = "torch" +version = "1.13.1" +description = "Tensors and Dynamic neural networks in Python with strong GPU acceleration" +category = "main" +optional = true +python-versions = ">=3.7.0" + +[package.dependencies] +nvidia-cublas-cu11 = {version = "11.10.3.66", markers = "platform_system == \"Linux\""} +nvidia-cuda-nvrtc-cu11 = {version = "11.7.99", markers = "platform_system == \"Linux\""} +nvidia-cuda-runtime-cu11 = {version = "11.7.99", markers = "platform_system == \"Linux\""} +nvidia-cudnn-cu11 = {version = "8.5.0.96", markers = "platform_system == \"Linux\""} +typing-extensions = "*" + +[package.extras] +opt-einsum = ["opt-einsum (>=3.3)"] + [[package]] name = "tornado" version = "6.2" description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." -category = "dev" +category = "main" optional = false python-versions = ">= 3.7" @@ -1941,7 +2281,7 @@ python-versions = ">= 3.7" name = "tqdm" version = "4.64.1" description = "Fast, Extensible Progress Meter" -category = "dev" +category = "main" optional = false python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,>=2.7" @@ -1958,7 +2298,7 @@ telegram = ["requests"] name = "traitlets" version = "5.8.0" description = "Traitlets Python configuration system" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -1970,7 +2310,7 @@ test = ["argcomplete (>=2.0)", "pre-commit", "pytest", "pytest-mock"] name = "typing-extensions" version = "4.4.0" description = "Backported and Experimental Type Hints for Python 3.7+" -category = "dev" +category = "main" optional = false python-versions = ">=3.7" @@ -1989,7 +2329,7 @@ socks = ["PySocks (>=1.5.6,!=1.5.7,<2.0)"] [[package]] name = "watchdog" -version = "2.2.0" +version = "2.2.1" description = "Filesystem events monitoring" category = "dev" optional = false @@ -2002,7 +2342,7 @@ watchmedo = ["PyYAML (>=3.10)"] name = "wcwidth" version = "0.2.5" description = "Measures the displayed width of unicode strings in a terminal" -category = "dev" +category = "main" optional = false python-versions = "*" @@ -2014,6 +2354,33 @@ category = "dev" optional = false python-versions = "*" +[[package]] +name = "wget" +version = "3.2" +description = "pure python download utility" +category = "main" +optional = true +python-versions = "*" + +[[package]] +name = "wheel" +version = "0.38.4" +description = "A built-package format for Python" +category = "main" +optional = true +python-versions = ">=3.7" + +[package.extras] +test = ["pytest (>=3.0.0)"] + +[[package]] +name = "widgetsnbextension" +version = "4.0.5" +description = "Jupyter interactive widgets for Jupyter Notebook" +category = "main" +optional = true +python-versions = ">=3.7" + [[package]] name = "yaspin" version = "2.2.0" @@ -2038,13 +2405,14 @@ docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker testing = ["flake8 (<5)", "func-timeout", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)"] [extras] +data = ["bnlearn"] graph_func = ["pywhy-graphs"] viz = ["pygraphviz"] [metadata] lock-version = "1.1" python-versions = ">=3.8,<3.11" -content-hash = "06fde37a5e8489a85b1fafb8307a87dc1984f2ad6dc68b0e3829fefdd259579e" +content-hash = "04f46cd30737462b965287f013d724bc0280c411923cb4b6de518960a5ee1e67" [metadata.files] alabaster = [ @@ -2093,6 +2461,7 @@ bleach = [ {file = "bleach-5.0.1-py3-none-any.whl", hash = "sha256:085f7f33c15bd408dd9b17a4ad77c577db66d76203e5984b1bd59baeee948b2a"}, {file = "bleach-5.0.1.tar.gz", hash = "sha256:0d03255c47eb9bd2f26aa9bb7f2107732e7e8fe195ca2f64709fcf3b0a4a085c"}, ] +bnlearn = [] certifi = [ {file = "certifi-2022.12.7-py3-none-any.whl", hash = "sha256:4ad3232f5e926d6718ec31cfc1fcadfde020920e278684144551c91769c7bc18"}, {file = "certifi-2022.12.7.tar.gz", hash = "sha256:35824b4c3a97115964b408844d64aa14db1cc518f6562e8d7261699d1350a9e3"}, @@ -2179,6 +2548,10 @@ colorama = [ {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] +comm = [ + {file = "comm-0.1.2-py3-none-any.whl", hash = "sha256:9f3abf3515112fa7c55a42a6a5ab358735c9dccc8b5910a9d8e3ef5998130666"}, + {file = "comm-0.1.2.tar.gz", hash = "sha256:3e2f5826578e683999b93716285b3b1f344f157bf75fa9ce0a797564e742f062"}, +] contourpy = [ {file = "contourpy-1.0.6-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:613c665529899b5d9fade7e5d1760111a0b011231277a0d36c49f0d3d6914bd6"}, {file = "contourpy-1.0.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:78ced51807ccb2f45d4ea73aca339756d75d021069604c2fccd05390dc3c28eb"}, @@ -2251,62 +2624,82 @@ contourpy = [ {file = "contourpy-1.0.6.tar.gz", hash = "sha256:6e459ebb8bb5ee4c22c19cc000174f8059981971a33ce11e17dddf6aca97a142"}, ] coverage = [ - {file = "coverage-7.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b3695c4f4750bca943b3e1f74ad4be8d29e4aeab927d50772c41359107bd5d5c"}, - {file = "coverage-7.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fa6a5a224b7f4cfb226f4fc55a57e8537fcc096f42219128c2c74c0e7d0953e1"}, - {file = "coverage-7.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:74f70cd92669394eaf8d7756d1b195c8032cf7bbbdfce3bc489d4e15b3b8cf73"}, - {file = "coverage-7.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b66bb21a23680dee0be66557dc6b02a3152ddb55edf9f6723fa4a93368f7158d"}, - {file = "coverage-7.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d87717959d4d0ee9db08a0f1d80d21eb585aafe30f9b0a54ecf779a69cb015f6"}, - {file = "coverage-7.0.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:854f22fa361d1ff914c7efa347398374cc7d567bdafa48ac3aa22334650dfba2"}, - {file = "coverage-7.0.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:1e414dc32ee5c3f36544ea466b6f52f28a7af788653744b8570d0bf12ff34bc0"}, - {file = "coverage-7.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6c5ad996c6fa4d8ed669cfa1e8551348729d008a2caf81489ab9ea67cfbc7498"}, - {file = "coverage-7.0.1-cp310-cp310-win32.whl", hash = "sha256:691571f31ace1837838b7e421d3a09a8c00b4aac32efacb4fc9bd0a5c647d25a"}, - {file = "coverage-7.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:89caf4425fe88889e2973a8e9a3f6f5f9bbe5dd411d7d521e86428c08a873a4a"}, - {file = "coverage-7.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:63d56165a7c76265468d7e0c5548215a5ba515fc2cba5232d17df97bffa10f6c"}, - {file = "coverage-7.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4f943a3b2bc520102dd3e0bb465e1286e12c9a54f58accd71b9e65324d9c7c01"}, - {file = "coverage-7.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:830525361249dc4cd013652b0efad645a385707a5ae49350c894b67d23fbb07c"}, - {file = "coverage-7.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fd1b9c5adc066db699ccf7fa839189a649afcdd9e02cb5dc9d24e67e7922737d"}, - {file = "coverage-7.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e00c14720b8b3b6c23b487e70bd406abafc976ddc50490f645166f111c419c39"}, - {file = "coverage-7.0.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:6d55d840e1b8c0002fce66443e124e8581f30f9ead2e54fbf6709fb593181f2c"}, - {file = "coverage-7.0.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:66b18c3cf8bbab0cce0d7b9e4262dc830e93588986865a8c78ab2ae324b3ed56"}, - {file = "coverage-7.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:12a5aa77783d49e05439fbe6e6b427484f8a0f9f456b46a51d8aac022cfd024d"}, - {file = "coverage-7.0.1-cp311-cp311-win32.whl", hash = "sha256:b77015d1cb8fe941be1222a5a8b4e3fbca88180cfa7e2d4a4e58aeabadef0ab7"}, - {file = "coverage-7.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:fb992c47cb1e5bd6a01e97182400bcc2ba2077080a17fcd7be23aaa6e572e390"}, - {file = "coverage-7.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:e78e9dcbf4f3853d3ae18a8f9272111242531535ec9e1009fa8ec4a2b74557dc"}, - {file = "coverage-7.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e60bef2e2416f15fdc05772bf87db06c6a6f9870d1db08fdd019fbec98ae24a9"}, - {file = "coverage-7.0.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9823e4789ab70f3ec88724bba1a203f2856331986cd893dedbe3e23a6cfc1e4e"}, - {file = "coverage-7.0.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9158f8fb06747ac17bd237930c4372336edc85b6e13bdc778e60f9d685c3ca37"}, - {file = "coverage-7.0.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:486ee81fa694b4b796fc5617e376326a088f7b9729c74d9defa211813f3861e4"}, - {file = "coverage-7.0.1-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:1285648428a6101b5f41a18991c84f1c3959cee359e51b8375c5882fc364a13f"}, - {file = "coverage-7.0.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:2c44fcfb3781b41409d0f060a4ed748537557de9362a8a9282182fafb7a76ab4"}, - {file = "coverage-7.0.1-cp37-cp37m-win32.whl", hash = "sha256:d6814854c02cbcd9c873c0f3286a02e3ac1250625cca822ca6bc1018c5b19f1c"}, - {file = "coverage-7.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:f66460f17c9319ea4f91c165d46840314f0a7c004720b20be58594d162a441d8"}, - {file = "coverage-7.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9b373c9345c584bb4b5f5b8840df7f4ab48c4cbb7934b58d52c57020d911b856"}, - {file = "coverage-7.0.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:d3022c3007d3267a880b5adcf18c2a9bf1fc64469b394a804886b401959b8742"}, - {file = "coverage-7.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:92651580bd46519067e36493acb394ea0607b55b45bd81dd4e26379ed1871f55"}, - {file = "coverage-7.0.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3cfc595d2af13856505631be072835c59f1acf30028d1c860b435c5fc9c15b69"}, - {file = "coverage-7.0.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0b4b3a4d9915b2be879aff6299c0a6129f3d08a775d5a061f503cf79571f73e4"}, - {file = "coverage-7.0.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:b6f22bb64cc39bcb883e5910f99a27b200fdc14cdd79df8696fa96b0005c9444"}, - {file = "coverage-7.0.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:72d1507f152abacea81f65fee38e4ef3ac3c02ff8bc16f21d935fd3a8a4ad910"}, - {file = "coverage-7.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:0a79137fc99815fff6a852c233628e735ec15903cfd16da0f229d9c4d45926ab"}, - {file = "coverage-7.0.1-cp38-cp38-win32.whl", hash = "sha256:b3763e7fcade2ff6c8e62340af9277f54336920489ceb6a8cd6cc96da52fcc62"}, - {file = "coverage-7.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:09f6b5a8415b6b3e136d5fec62b552972187265cb705097bf030eb9d4ffb9b60"}, - {file = "coverage-7.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:978258fec36c154b5e250d356c59af7d4c3ba02bef4b99cda90b6029441d797d"}, - {file = "coverage-7.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:19ec666533f0f70a0993f88b8273057b96c07b9d26457b41863ccd021a043b9a"}, - {file = "coverage-7.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cfded268092a84605f1cc19e5c737f9ce630a8900a3589e9289622db161967e9"}, - {file = "coverage-7.0.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07bcfb1d8ac94af886b54e18a88b393f6a73d5959bb31e46644a02453c36e475"}, - {file = "coverage-7.0.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:397b4a923cc7566bbc7ae2dfd0ba5a039b61d19c740f1373791f2ebd11caea59"}, - {file = "coverage-7.0.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:aec2d1515d9d39ff270059fd3afbb3b44e6ec5758af73caf18991807138c7118"}, - {file = "coverage-7.0.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:c20cfebcc149a4c212f6491a5f9ff56f41829cd4f607b5be71bb2d530ef243b1"}, - {file = "coverage-7.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:fd556ff16a57a070ce4f31c635953cc44e25244f91a0378c6e9bdfd40fdb249f"}, - {file = "coverage-7.0.1-cp39-cp39-win32.whl", hash = "sha256:b9ea158775c7c2d3e54530a92da79496fb3fb577c876eec761c23e028f1e216c"}, - {file = "coverage-7.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:d1991f1dd95eba69d2cd7708ff6c2bbd2426160ffc73c2b81f617a053ebcb1a8"}, - {file = "coverage-7.0.1-pp37.pp38.pp39-none-any.whl", hash = "sha256:3dd4ee135e08037f458425b8842d24a95a0961831a33f89685ff86b77d378f89"}, - {file = "coverage-7.0.1.tar.gz", hash = "sha256:a4a574a19eeb67575a5328a5760bbbb737faa685616586a9f9da4281f940109c"}, + {file = "coverage-7.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c1f02d016b9b6b5ad21949a21646714bfa7b32d6041a30f97674f05d6d6996e3"}, + {file = "coverage-7.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2d4f68e4fa286fb6b00d58a1e87c79840e289d3f6e5dcb912ad7b0fbd9629fb"}, + {file = "coverage-7.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:426895ac9f2938bec193aa998e7a77a3e65d3e46903f348e794b4192b9a5b61e"}, + {file = "coverage-7.0.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dcb708ab06f3f4dfc99e9f84821c9120e5f12113b90fad132311a2cb97525379"}, + {file = "coverage-7.0.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8217f73faf08623acb25fb2affd5d20cbcd8185213db308e46a37e6fd6a56a49"}, + {file = "coverage-7.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:bcb57d175ff0cb4ff97fc547c74c1cb8d4c9612003f6d267ee78dad8f23d8b30"}, + {file = "coverage-7.0.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:7d47d666e17e57ef65fefc87229fde262bd5c9039ae8424bc53aa2d8f07dc178"}, + {file = "coverage-7.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:321316a7b979892a13c148a9d37852b5a76f26717e4b911b606a649394629532"}, + {file = "coverage-7.0.2-cp310-cp310-win32.whl", hash = "sha256:420f10c852b9a489cf5a764534669a19f49732a0576c76d9489ebf287f81af6d"}, + {file = "coverage-7.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a27a8dca0dc6f0944ed9fd83c556d862e227a5cd4220e62af5d4c750389938f0"}, + {file = "coverage-7.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ac1033942851bf01f28c76318155ea92d6648aecb924cab81fa23781d095e9ab"}, + {file = "coverage-7.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:36c1a1b6d38ebf8a4335f65226ec36b5d6fd67743fdcbad5c52bdcd46c4f5842"}, + {file = "coverage-7.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5e1874c601128cf54c1d4b471e915658a334fbc56d7b3c324ddc7511597ea82"}, + {file = "coverage-7.0.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8e133ca2f8141b415ff396ba789bdeffdea8ff9a5c7fc9996ccf591d7d40ee93"}, + {file = "coverage-7.0.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e97b21482aa5c21e049e4755c95955ad71fb54c9488969e2f17cf30922aa5f6"}, + {file = "coverage-7.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:8bd466135fb07f693dbdd999a5569ffbc0590e9c64df859243162f0ebee950c8"}, + {file = "coverage-7.0.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:38f281bb9bdd4269c451fed9451203512dadefd64676f14ed1e82c77eb5644fc"}, + {file = "coverage-7.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7c669be1b01e4b2bf23aa49e987d9bedde0234a7da374a9b77ca5416d7c57002"}, + {file = "coverage-7.0.2-cp311-cp311-win32.whl", hash = "sha256:80583c536e7e010e301002088919d4ea90566d1789ee02551574fdf3faa275ae"}, + {file = "coverage-7.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:a7b018811a0e1d3869d8d0600849953acd355a3a29c6bee0fbd24d7772bcc0a2"}, + {file = "coverage-7.0.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:e8931af864bd599c6af626575a02103ae626f57b34e3af5537d40b040d33d2ad"}, + {file = "coverage-7.0.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1a613d60be1a02c7a5184ea5c4227f48c08e0635608b9c17ae2b17efef8f2501"}, + {file = "coverage-7.0.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3fbb59f84c8549113dcdce7c6d16c5731fe53651d0b46c0a25a5ebc7bb655869"}, + {file = "coverage-7.0.2-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3d40ad86a348c79c614e2b90566267dd6d45f2e6b4d2bfb794d78ea4a4b60b63"}, + {file = "coverage-7.0.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:7e184aa18f921b612ea08666c25dd92a71241c8ed40917f2824219c92289b8c7"}, + {file = "coverage-7.0.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:fd22ee7bff4b5c37bb6385efee1c501b75e29ca40286f037cb91c2182d1348ce"}, + {file = "coverage-7.0.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:3d72e3d20b03e63bd27b1c4d6b754cd93eca82ecc5dd77b99262d5f64862ca35"}, + {file = "coverage-7.0.2-cp37-cp37m-win32.whl", hash = "sha256:5f44ba7c07e0aa4a7a2723b426c254e952da82a33d65b4a52afae4bef74a4203"}, + {file = "coverage-7.0.2-cp37-cp37m-win_amd64.whl", hash = "sha256:efa9d943189321f67f71070c309aa6f6130fa1ec35c9dfd0da0ed238938ce573"}, + {file = "coverage-7.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:da458bdc9b0bcd9b8ca85bc73148631b18cc8ba03c47f29f4c017809990351aa"}, + {file = "coverage-7.0.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:87d95eea58fb71f69b4f1c761099a19e0e9cb27d45dc1cc7042523128ee56337"}, + {file = "coverage-7.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dfafc350f43fd7dc67df18c940c3b7ed208ebb797abe9fb3047f0c65be8e4c0f"}, + {file = "coverage-7.0.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:46db409fc0c3ee5c859b84c7de9cb507166287d588390889fdf06a1afe452e16"}, + {file = "coverage-7.0.2-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8805673b1953313adfc487d5323b4c87864e77057944a0888c98dd2f7a6052f"}, + {file = "coverage-7.0.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:62e5b942378d5f0b87caace567a70dc634ddd4d219a236fa221dc97d2fc412c8"}, + {file = "coverage-7.0.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a99b2f2dd1236e8d9dc35974a3dc298a408cdfd512b0bb2451798cff1ce63408"}, + {file = "coverage-7.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:04691b8e832a900ed15f5bcccc2008fc2d1c8e7411251fd7d1422a84e1d72841"}, + {file = "coverage-7.0.2-cp38-cp38-win32.whl", hash = "sha256:b6936cd38757dd323fefc157823e46436610328f0feb1419a412316f24b77f36"}, + {file = "coverage-7.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:483e120ea324c7fced6126bb9bf0535c71e9233d29cbc7e2fc4560311a5f8a32"}, + {file = "coverage-7.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:4438ba539bef21e288092b30ea2fc30e883d9af5b66ebeaf2fd7c25e2f074e39"}, + {file = "coverage-7.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3a2d81c95d3b02638ee6ae647edc79769fd29bf5e9e5b6b0c29040579f33c260"}, + {file = "coverage-7.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c40aaf7930680e0e5f3bd6d3d3dc97a7897f53bdce925545c4b241e0c5c3ca6a"}, + {file = "coverage-7.0.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2b31f7f246dbff339b3b76ee81329e3eca5022ce270c831c65e841dbbb40115f"}, + {file = "coverage-7.0.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a6e1c77ff6f10eab496fbbcdaa7dfae84968928a0aadc43ce3c3453cec29bd79"}, + {file = "coverage-7.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:8e6c0ca447b557a32642f22d0987be37950eda51c4f19fc788cebc99426284b6"}, + {file = "coverage-7.0.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9de96025ce25b9f4e744fbe558a003e673004af255da9b1f6ec243720ac5deeb"}, + {file = "coverage-7.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:312fd77258bf1044ef4faa82091f2e88216e4b62dcf1a461d3e917144c8b09b7"}, + {file = "coverage-7.0.2-cp39-cp39-win32.whl", hash = "sha256:4d7be755d7544dac2b9814e98366a065d15a16e13847eb1f5473bb714483391e"}, + {file = "coverage-7.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:b6eab230b18458707b5c501548e997e42934b1c189fb4d1b78bf5aacc1c6a137"}, + {file = "coverage-7.0.2-pp37.pp38.pp39-none-any.whl", hash = "sha256:1d732b5dcafed67d81c5b5a0c404c31a61e13148946a3b910a340f72fdd1ec95"}, + {file = "coverage-7.0.2.tar.gz", hash = "sha256:405d8528a0ea07ca516d9007ecad4e1bd10e2eeef27411c6188d78c4e2dfcddc"}, ] cycler = [ {file = "cycler-0.11.0-py3-none-any.whl", hash = "sha256:3a27e95f763a428a739d2add979fa7494c912a32c17c4c38c4d5f082cad165a3"}, {file = "cycler-0.11.0.tar.gz", hash = "sha256:9c87405839a19696e837b3b818fed3f5f69f16f1eec1a1ad77e043dcea9c772f"}, ] +debugpy = [ + {file = "debugpy-1.6.4-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:6ae238943482c78867ac707c09122688efb700372b617ffd364261e5e41f7a2f"}, + {file = "debugpy-1.6.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2a39e7da178e1f22f4bc04b57f085e785ed1bcf424aaf318835a1a7129eefe35"}, + {file = "debugpy-1.6.4-cp310-cp310-win32.whl", hash = "sha256:143f79d0798a9acea21cd1d111badb789f19d414aec95fa6389cfea9485ddfb1"}, + {file = "debugpy-1.6.4-cp310-cp310-win_amd64.whl", hash = "sha256:563f148f94434365ec0ce94739c749aabf60bf67339e68a9446499f3582d62f3"}, + {file = "debugpy-1.6.4-cp37-cp37m-macosx_10_15_x86_64.whl", hash = "sha256:1caee68f7e254267df908576c0d0938f8f88af16383f172cb9f0602e24c30c01"}, + {file = "debugpy-1.6.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40e2a83d31a16b83666f19fa06d97b2cc311af88e6266590579737949971a17e"}, + {file = "debugpy-1.6.4-cp37-cp37m-win32.whl", hash = "sha256:82229790442856962aec4767b98ba2559fe0998f897e9f21fb10b4fd24b6c436"}, + {file = "debugpy-1.6.4-cp37-cp37m-win_amd64.whl", hash = "sha256:67edf033f9e512958f7b472975ff9d9b7ff64bf4440f6f6ae44afdc66b89e6b6"}, + {file = "debugpy-1.6.4-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:4ab5e938925e5d973f567d6ef32751b17d10f3be3a8c4d73c52f53e727f69bf1"}, + {file = "debugpy-1.6.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d8df268e9f72fc06efc2e75e8dc8e2b881d6a397356faec26efb2ee70b6863b7"}, + {file = "debugpy-1.6.4-cp38-cp38-win32.whl", hash = "sha256:86bd25f38f8b6c5d430a5e2931eebbd5f580c640f4819fcd236d0498790c7204"}, + {file = "debugpy-1.6.4-cp38-cp38-win_amd64.whl", hash = "sha256:62ba4179b372a62abf9c89b56997d70a4100c6dea6c2a4e0e4be5f45920b3253"}, + {file = "debugpy-1.6.4-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:d2968e589bda4e485a9c61f113754a28e48d88c5152ed8e0b2564a1fadbe50a5"}, + {file = "debugpy-1.6.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e62b8034ede98932b92268669318848a0d42133d857087a3b9cec03bb844c615"}, + {file = "debugpy-1.6.4-cp39-cp39-win32.whl", hash = "sha256:3d9c31baf64bf959a593996c108e911c5a9aa1693a296840e5469473f064bcec"}, + {file = "debugpy-1.6.4-cp39-cp39-win_amd64.whl", hash = "sha256:ea4bf208054e6d41749f17612066da861dff10102729d32c85b47f155223cf2b"}, + {file = "debugpy-1.6.4-py2.py3-none-any.whl", hash = "sha256:e886a1296cd20a10172e94788009ce74b759e54229ebd64a43fa5c2b4e62cd76"}, + {file = "debugpy-1.6.4.zip", hash = "sha256:d5ab9bd3f4e7faf3765fd52c7c43c074104ab1e109621dc73219099ed1a5399d"}, +] decorator = [ {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, @@ -2315,6 +2708,10 @@ defusedxml = [ {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"}, {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"}, ] +df2onehot = [ + {file = "df2onehot-1.0.2-py3-none-any.whl", hash = "sha256:6e41e6ab760ae65ec5f762f7b17302e8e5aff6c35f0b928b659c950c2039d5d6"}, + {file = "df2onehot-1.0.2.tar.gz", hash = "sha256:2092ce9d0ea23b3904aaee78473966bf847aa8fb6bb71608b966fcce754b63e1"}, +] docstring-parser = [ {file = "docstring_parser-0.15-py3-none-any.whl", hash = "sha256:d1679b86250d269d06a99670924d6bce45adc00b08069dae8c47d98e89b667a9"}, {file = "docstring_parser-0.15.tar.gz", hash = "sha256:48ddc093e8b1865899956fcc03b03e66bb7240c310fac5af81814580c55bf682"}, @@ -2367,6 +2764,14 @@ fonttools = [ {file = "fonttools-4.38.0-py3-none-any.whl", hash = "sha256:820466f43c8be8c3009aef8b87e785014133508f0de64ec469e4efb643ae54fb"}, {file = "fonttools-4.38.0.zip", hash = "sha256:2bb244009f9bf3fa100fc3ead6aeb99febe5985fa20afbfbaa2f8946c2fbdaf1"}, ] +fsspec = [ + {file = "fsspec-2022.11.0-py3-none-any.whl", hash = "sha256:d6e462003e3dcdcb8c7aa84c73a228f8227e72453cd22570e2363e8844edfe7b"}, + {file = "fsspec-2022.11.0.tar.gz", hash = "sha256:259d5fd5c8e756ff2ea72f42e7613c32667dc2049a4ac3d84364a7ca034acb8b"}, +] +funcsigs = [ + {file = "funcsigs-1.0.2-py2.py3-none-any.whl", hash = "sha256:330cc27ccbf7f1e992e69fef78261dc7c6569012cf397db8d3de0234e6c937ca"}, + {file = "funcsigs-1.0.2.tar.gz", hash = "sha256:a7bb0f2cf3a3fd1ab2732cb49eba4252c2af4240442415b4abce3b87022a8f50"}, +] ghp-import = [ {file = "ghp-import-2.1.0.tar.gz", hash = "sha256:9c535c4c61193c2df8871222567d7fd7e5014d835f97dc7b7439069e2413d343"}, {file = "ghp_import-2.1.0-py3-none-any.whl", hash = "sha256:8337dd7b50877f163d4c0289bc1f1c7f127550241988d568c1db512c4324a619"}, @@ -2376,8 +2781,8 @@ gitdb = [ {file = "gitdb-4.0.10.tar.gz", hash = "sha256:6eb990b69df4e15bad899ea868dc46572c3f75339735663b81de79b06f17eb9a"}, ] GitPython = [ - {file = "GitPython-3.1.29-py3-none-any.whl", hash = "sha256:41eea0deec2deea139b459ac03656f0dd28fc4a3387240ec1d3c259a2c47850f"}, - {file = "GitPython-3.1.29.tar.gz", hash = "sha256:cc36bfc4a3f913e66805a28e84703e419d9c264c1077e537b54f0e1af85dbefd"}, + {file = "GitPython-3.1.30-py3-none-any.whl", hash = "sha256:cd455b0000615c60e286208ba540271af9fe531fa6a87cc590a7298785ab2882"}, + {file = "GitPython-3.1.30.tar.gz", hash = "sha256:769c2d83e13f5d938b7688479da374c4e3d49f71549aaf462b646db9602ea6f8"}, ] graphviz = [ {file = "graphviz-0.20.1-py3-none-any.whl", hash = "sha256:587c58a223b51611c0cf461132da386edd896a029524ca61a1462b880bf97977"}, @@ -2396,8 +2801,8 @@ imagesize = [ {file = "imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a"}, ] importlib-metadata = [ - {file = "importlib_metadata-5.2.0-py3-none-any.whl", hash = "sha256:0eafa39ba42bf225fc00e67f701d71f85aead9f878569caf13c3724f704b970f"}, - {file = "importlib_metadata-5.2.0.tar.gz", hash = "sha256:404d48d62bba0b7a77ff9d405efd91501bef2e67ff4ace0bed40a0cf28c3c7cd"}, + {file = "importlib_metadata-6.0.0-py3-none-any.whl", hash = "sha256:7efb448ec9a5e313a57655d35aa54cd3e01b7e1fbcf72dce1bf06119420f5bad"}, + {file = "importlib_metadata-6.0.0.tar.gz", hash = "sha256:e354bedeb60efa6affdcc8ae121b73544a7aa74156d047311948f6d711cd378d"}, ] importlib-resources = [ {file = "importlib_resources-5.10.2-py3-none-any.whl", hash = "sha256:7d543798b0beca10b6a01ac7cafda9f822c54db9e8376a6bf57e0cbd74d486b6"}, @@ -2407,10 +2812,22 @@ iniconfig = [ {file = "iniconfig-1.1.1-py2.py3-none-any.whl", hash = "sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3"}, {file = "iniconfig-1.1.1.tar.gz", hash = "sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32"}, ] +ipykernel = [ + {file = "ipykernel-6.19.4-py3-none-any.whl", hash = "sha256:0ecdae0060da61c5222ad221681f3b99b5bef739e11a3b1eb5778aa47f056f1f"}, + {file = "ipykernel-6.19.4.tar.gz", hash = "sha256:4140c282a6c71cdde59abe5eae2c71bf1eeb4a69316ab76e1c4c25150a49722b"}, +] ipython = [ {file = "ipython-7.34.0-py3-none-any.whl", hash = "sha256:c175d2440a1caff76116eb719d40538fbb316e214eda85c5515c303aacbfb23e"}, {file = "ipython-7.34.0.tar.gz", hash = "sha256:af3bdb46aa292bce5615b1b2ebc76c2080c5f77f54bda2ec72461317273e7cd6"}, ] +ipywidgets = [ + {file = "ipywidgets-8.0.4-py3-none-any.whl", hash = "sha256:ebb195e743b16c3947fe8827190fb87b4d00979c0fbf685afe4d2c4927059fa1"}, + {file = "ipywidgets-8.0.4.tar.gz", hash = "sha256:c0005a77a47d77889cafed892b58e33b4a2a96712154404c6548ec22272811ea"}, +] +ismember = [ + {file = "ismember-1.0.2-py3-none-any.whl", hash = "sha256:67319cd9f02d6f66124a22c16f42d174a4697aaaf23a931eff44fae4525ec493"}, + {file = "ismember-1.0.2.tar.gz", hash = "sha256:b1a784e45ba9d1fd18303fe3b829270a6922954cc5798f49fdf843758a8d0d10"}, +] isort = [ {file = "isort-5.11.4-py3-none-any.whl", hash = "sha256:c033fd0edb91000a7f09527fe5c75321878f98322a77ddcc81adbd83724afb7b"}, {file = "isort-5.11.4.tar.gz", hash = "sha256:6db30c5ded9815d813932c04c2f85a360bcdd35fed496f4d8f35495ef0a261b6"}, @@ -2427,6 +2844,10 @@ joblib = [ {file = "joblib-1.2.0-py3-none-any.whl", hash = "sha256:091138ed78f800342968c523bdde947e7a305b8594b910a0fea2ab83c3c6d385"}, {file = "joblib-1.2.0.tar.gz", hash = "sha256:e1cee4a79e4af22881164f218d4311f60074197fb707e082e803b61f6d137018"}, ] +jsonpickle = [ + {file = "jsonpickle-3.0.1-py2.py3-none-any.whl", hash = "sha256:130d8b293ea0add3845de311aaba55e6d706d0bb17bc123bd2c8baf8a39ac77c"}, + {file = "jsonpickle-3.0.1.tar.gz", hash = "sha256:032538804795e73b94ead410800ac387fdb6de98f8882ac957fcd247e3a85200"}, +] jsonschema = [ {file = "jsonschema-4.17.3-py3-none-any.whl", hash = "sha256:a870ad254da1a8ca84b6a2905cac29d265f805acc57af304784962a2aa6508f6"}, {file = "jsonschema-4.17.3.tar.gz", hash = "sha256:0f864437ab8b6076ba6707453ef8f98a6a0d512a80e93f8abdb676f737ecb60d"}, @@ -2436,13 +2857,17 @@ jupyter-client = [ {file = "jupyter_client-7.4.8.tar.gz", hash = "sha256:109a3c33b62a9cf65aa8325850a0999a795fac155d9de4f7555aef5f310ee35a"}, ] jupyter-core = [ - {file = "jupyter_core-5.1.1-py3-none-any.whl", hash = "sha256:f1038179d0f179b0e92c8fa2289c012b29dafdc9484b41821079f1a496f5a0f2"}, - {file = "jupyter_core-5.1.1.tar.gz", hash = "sha256:f342d29eb6edb06f8dffa69adea987b3a9ee2b6702338a8cb6911516ea0b432d"}, + {file = "jupyter_core-5.1.2-py3-none-any.whl", hash = "sha256:0f99cc639c8d00d591acfcc028aeea81473ea6c72fabe86426398220e2d91b1d"}, + {file = "jupyter_core-5.1.2.tar.gz", hash = "sha256:62b00d52f030643d29f86aafdfd9b36d42421823599a272eb4c2df1d1cc7f723"}, ] jupyterlab-pygments = [ {file = "jupyterlab_pygments-0.2.2-py2.py3-none-any.whl", hash = "sha256:2405800db07c9f770863bcf8049a529c3dd4d3e28536638bd7c1c01d2748309f"}, {file = "jupyterlab_pygments-0.2.2.tar.gz", hash = "sha256:7405d7fde60819d905a9fa8ce89e4cd830e318cdad22a0030f7a901da705585d"}, ] +jupyterlab-widgets = [ + {file = "jupyterlab_widgets-3.0.5-py3-none-any.whl", hash = "sha256:a04a42e50231b355b7087e16a818f541e53589f7647144ea0344c4bf16f300e5"}, + {file = "jupyterlab_widgets-3.0.5.tar.gz", hash = "sha256:eeaecdeaf6c03afc960ddae201ced88d5979b4ca9c3891bcb8f6631af705f5ef"}, +] kiwisolver = [ {file = "kiwisolver-1.4.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:2f5e60fabb7343a836360c4f0919b8cd0d6dbf08ad2ca6b9cf90bf0c76a3c4f6"}, {file = "kiwisolver-1.4.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:10ee06759482c78bdb864f4109886dff7b8a56529bc1609d4f1112b93fe6423c"}, @@ -2690,8 +3115,8 @@ nbformat = [ {file = "nbformat-5.7.1.tar.gz", hash = "sha256:3810a0130453ed031970521d20989b8a592f3c2e73283a8280ae34ae1f75b3f8"}, ] nbsphinx = [ - {file = "nbsphinx-0.8.10-py3-none-any.whl", hash = "sha256:6076fba58020420927899362579f12779a43091eb238f414519ec25b4a8cfc96"}, - {file = "nbsphinx-0.8.10.tar.gz", hash = "sha256:a8d68046f8aab916e2940b9b3819bd3ef9ddce868aa38845ea366645cabb6254"}, + {file = "nbsphinx-0.8.11-py3-none-any.whl", hash = "sha256:e5c6c76b12fbc425d5538d4b8c0d6fb0c134c28459d4a1b54f41d704b34b4bd1"}, + {file = "nbsphinx-0.8.11.tar.gz", hash = "sha256:abe18c04b33d9bcdfb3d66f1195f6b0d51eeca463ecb07f6061de497e43316e4"}, ] nest-asyncio = [ {file = "nest_asyncio-1.5.6-py3-none-any.whl", hash = "sha256:b9a953fb40dceaa587d109609098db21900182b16440652454a146cffb06e8b8"}, @@ -2735,6 +3160,27 @@ numpydoc = [ {file = "numpydoc-1.5.0-py3-none-any.whl", hash = "sha256:c997759fb6fc32662801cece76491eedbc0ec619b514932ffd2b270ae89c07f9"}, {file = "numpydoc-1.5.0.tar.gz", hash = "sha256:b0db7b75a32367a0e25c23b397842c65e344a1206524d16c8069f0a1c91b5f4c"}, ] +nvidia-cublas-cu11 = [ + {file = "nvidia_cublas_cu11-11.10.3.66-py3-none-manylinux1_x86_64.whl", hash = "sha256:d32e4d75f94ddfb93ea0a5dda08389bcc65d8916a25cb9f37ac89edaeed3bded"}, + {file = "nvidia_cublas_cu11-11.10.3.66-py3-none-win_amd64.whl", hash = "sha256:8ac17ba6ade3ed56ab898a036f9ae0756f1e81052a317bf98f8c6d18dc3ae49e"}, +] +nvidia-cuda-nvrtc-cu11 = [ + {file = "nvidia_cuda_nvrtc_cu11-11.7.99-2-py3-none-manylinux1_x86_64.whl", hash = "sha256:9f1562822ea264b7e34ed5930567e89242d266448e936b85bc97a3370feabb03"}, + {file = "nvidia_cuda_nvrtc_cu11-11.7.99-py3-none-manylinux1_x86_64.whl", hash = "sha256:f7d9610d9b7c331fa0da2d1b2858a4a8315e6d49765091d28711c8946e7425e7"}, + {file = "nvidia_cuda_nvrtc_cu11-11.7.99-py3-none-win_amd64.whl", hash = "sha256:f2effeb1309bdd1b3854fc9b17eaf997808f8b25968ce0c7070945c4265d64a3"}, +] +nvidia-cuda-runtime-cu11 = [ + {file = "nvidia_cuda_runtime_cu11-11.7.99-py3-none-manylinux1_x86_64.whl", hash = "sha256:cc768314ae58d2641f07eac350f40f99dcb35719c4faff4bc458a7cd2b119e31"}, + {file = "nvidia_cuda_runtime_cu11-11.7.99-py3-none-win_amd64.whl", hash = "sha256:bc77fa59a7679310df9d5c70ab13c4e34c64ae2124dd1efd7e5474b71be125c7"}, +] +nvidia-cudnn-cu11 = [ + {file = "nvidia_cudnn_cu11-8.5.0.96-2-py3-none-manylinux1_x86_64.whl", hash = "sha256:402f40adfc6f418f9dae9ab402e773cfed9beae52333f6d86ae3107a1b9527e7"}, + {file = "nvidia_cudnn_cu11-8.5.0.96-py3-none-manylinux1_x86_64.whl", hash = "sha256:71f8111eb830879ff2836db3cccf03bbd735df9b0d17cd93761732ac50a8a108"}, +] +opt-einsum = [ + {file = "opt_einsum-3.3.0-py3-none-any.whl", hash = "sha256:2455e59e3947d3c275477df7f5205b30635e266fe6dc300e3d9f9646bfcea147"}, + {file = "opt_einsum-3.3.0.tar.gz", hash = "sha256:59f6475f77bbc37dcf7cd748519c0ec60722e91e63ca114e68821c0c54a46549"}, +] packaging = [ {file = "packaging-22.0-py3-none-any.whl", hash = "sha256:957e2148ba0e1a3b282772e791ef1d8083648bc131c8ab0c1feba110ce1146c3"}, {file = "packaging-22.0.tar.gz", hash = "sha256:2198ec20bd4c017b8f9717e00f0c8714076fc2fd93816750ab48e2c41de2cfd3"}, @@ -2800,72 +3246,78 @@ pexpect = [ {file = "pexpect-4.8.0-py2.py3-none-any.whl", hash = "sha256:0b48a55dcb3c05f3329815901ea4fc1537514d6ba867a152b581d69ae3710937"}, {file = "pexpect-4.8.0.tar.gz", hash = "sha256:fc65a43959d153d0114afe13997d439c22823a27cefceb5ff35c2178c6784c0c"}, ] +pgmpy = [ + {file = "pgmpy-0.1.21-py3-none-any.whl", hash = "sha256:3c442320e7822892813b4eb56e048729d3bde053a707b5bb032685af6b372246"}, + {file = "pgmpy-0.1.21.tar.gz", hash = "sha256:90e9abf636629b6c1528df5847d2861b06220d103b5da414fcc74df0ee94cbf1"}, +] pickleshare = [ {file = "pickleshare-0.7.5-py2.py3-none-any.whl", hash = "sha256:9649af414d74d4df115d5d718f82acb59c9d418196b7b4290ed47a12ce62df56"}, {file = "pickleshare-0.7.5.tar.gz", hash = "sha256:87683d47965c1da65cdacaf31c8441d12b8044cdec9aca500cd78fc2c683afca"}, ] Pillow = [ - {file = "Pillow-9.3.0-1-cp37-cp37m-win32.whl", hash = "sha256:e6ea6b856a74d560d9326c0f5895ef8050126acfdc7ca08ad703eb0081e82b74"}, - {file = "Pillow-9.3.0-1-cp37-cp37m-win_amd64.whl", hash = "sha256:32a44128c4bdca7f31de5be641187367fe2a450ad83b833ef78910397db491aa"}, - {file = "Pillow-9.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:0b7257127d646ff8676ec8a15520013a698d1fdc48bc2a79ba4e53df792526f2"}, - {file = "Pillow-9.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b90f7616ea170e92820775ed47e136208e04c967271c9ef615b6fbd08d9af0e3"}, - {file = "Pillow-9.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:68943d632f1f9e3dce98908e873b3a090f6cba1cbb1b892a9e8d97c938871fbe"}, - {file = "Pillow-9.3.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:be55f8457cd1eac957af0c3f5ece7bc3f033f89b114ef30f710882717670b2a8"}, - {file = "Pillow-9.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d77adcd56a42d00cc1be30843d3426aa4e660cab4a61021dc84467123f7a00c"}, - {file = "Pillow-9.3.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:829f97c8e258593b9daa80638aee3789b7df9da5cf1336035016d76f03b8860c"}, - {file = "Pillow-9.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:801ec82e4188e935c7f5e22e006d01611d6b41661bba9fe45b60e7ac1a8f84de"}, - {file = "Pillow-9.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:871b72c3643e516db4ecf20efe735deb27fe30ca17800e661d769faab45a18d7"}, - {file = "Pillow-9.3.0-cp310-cp310-win32.whl", hash = "sha256:655a83b0058ba47c7c52e4e2df5ecf484c1b0b0349805896dd350cbc416bdd91"}, - {file = "Pillow-9.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:9f47eabcd2ded7698106b05c2c338672d16a6f2a485e74481f524e2a23c2794b"}, - {file = "Pillow-9.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:57751894f6618fd4308ed8e0c36c333e2f5469744c34729a27532b3db106ee20"}, - {file = "Pillow-9.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7db8b751ad307d7cf238f02101e8e36a128a6cb199326e867d1398067381bff4"}, - {file = "Pillow-9.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3033fbe1feb1b59394615a1cafaee85e49d01b51d54de0cbf6aa8e64182518a1"}, - {file = "Pillow-9.3.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:22b012ea2d065fd163ca096f4e37e47cd8b59cf4b0fd47bfca6abb93df70b34c"}, - {file = "Pillow-9.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b9a65733d103311331875c1dca05cb4606997fd33d6acfed695b1232ba1df193"}, - {file = "Pillow-9.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:502526a2cbfa431d9fc2a079bdd9061a2397b842bb6bc4239bb176da00993812"}, - {file = "Pillow-9.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:90fb88843d3902fe7c9586d439d1e8c05258f41da473952aa8b328d8b907498c"}, - {file = "Pillow-9.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:89dca0ce00a2b49024df6325925555d406b14aa3efc2f752dbb5940c52c56b11"}, - {file = "Pillow-9.3.0-cp311-cp311-win32.whl", hash = "sha256:3168434d303babf495d4ba58fc22d6604f6e2afb97adc6a423e917dab828939c"}, - {file = "Pillow-9.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:18498994b29e1cf86d505edcb7edbe814d133d2232d256db8c7a8ceb34d18cef"}, - {file = "Pillow-9.3.0-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:772a91fc0e03eaf922c63badeca75e91baa80fe2f5f87bdaed4280662aad25c9"}, - {file = "Pillow-9.3.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afa4107d1b306cdf8953edde0534562607fe8811b6c4d9a486298ad31de733b2"}, - {file = "Pillow-9.3.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b4012d06c846dc2b80651b120e2cdd787b013deb39c09f407727ba90015c684f"}, - {file = "Pillow-9.3.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:77ec3e7be99629898c9a6d24a09de089fa5356ee408cdffffe62d67bb75fdd72"}, - {file = "Pillow-9.3.0-cp37-cp37m-manylinux_2_28_aarch64.whl", hash = "sha256:6c738585d7a9961d8c2821a1eb3dcb978d14e238be3d70f0a706f7fa9316946b"}, - {file = "Pillow-9.3.0-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:828989c45c245518065a110434246c44a56a8b2b2f6347d1409c787e6e4651ee"}, - {file = "Pillow-9.3.0-cp37-cp37m-win32.whl", hash = "sha256:82409ffe29d70fd733ff3c1025a602abb3e67405d41b9403b00b01debc4c9a29"}, - {file = "Pillow-9.3.0-cp37-cp37m-win_amd64.whl", hash = "sha256:41e0051336807468be450d52b8edd12ac60bebaa97fe10c8b660f116e50b30e4"}, - {file = "Pillow-9.3.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:b03ae6f1a1878233ac620c98f3459f79fd77c7e3c2b20d460284e1fb370557d4"}, - {file = "Pillow-9.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:4390e9ce199fc1951fcfa65795f239a8a4944117b5935a9317fb320e7767b40f"}, - {file = "Pillow-9.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40e1ce476a7804b0fb74bcfa80b0a2206ea6a882938eaba917f7a0f004b42502"}, - {file = "Pillow-9.3.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a0a06a052c5f37b4ed81c613a455a81f9a3a69429b4fd7bb913c3fa98abefc20"}, - {file = "Pillow-9.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03150abd92771742d4a8cd6f2fa6246d847dcd2e332a18d0c15cc75bf6703040"}, - {file = "Pillow-9.3.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:15c42fb9dea42465dfd902fb0ecf584b8848ceb28b41ee2b58f866411be33f07"}, - {file = "Pillow-9.3.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:51e0e543a33ed92db9f5ef69a0356e0b1a7a6b6a71b80df99f1d181ae5875636"}, - {file = "Pillow-9.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:3dd6caf940756101205dffc5367babf288a30043d35f80936f9bfb37f8355b32"}, - {file = "Pillow-9.3.0-cp38-cp38-win32.whl", hash = "sha256:f1ff2ee69f10f13a9596480335f406dd1f70c3650349e2be67ca3139280cade0"}, - {file = "Pillow-9.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:276a5ca930c913f714e372b2591a22c4bd3b81a418c0f6635ba832daec1cbcfc"}, - {file = "Pillow-9.3.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:73bd195e43f3fadecfc50c682f5055ec32ee2c933243cafbfdec69ab1aa87cad"}, - {file = "Pillow-9.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1c7c8ae3864846fc95f4611c78129301e203aaa2af813b703c55d10cc1628535"}, - {file = "Pillow-9.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e0918e03aa0c72ea56edbb00d4d664294815aa11291a11504a377ea018330d3"}, - {file = "Pillow-9.3.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b0915e734b33a474d76c28e07292f196cdf2a590a0d25bcc06e64e545f2d146c"}, - {file = "Pillow-9.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:af0372acb5d3598f36ec0914deed2a63f6bcdb7b606da04dc19a88d31bf0c05b"}, - {file = "Pillow-9.3.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:ad58d27a5b0262c0c19b47d54c5802db9b34d38bbf886665b626aff83c74bacd"}, - {file = "Pillow-9.3.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:97aabc5c50312afa5e0a2b07c17d4ac5e865b250986f8afe2b02d772567a380c"}, - {file = "Pillow-9.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9aaa107275d8527e9d6e7670b64aabaaa36e5b6bd71a1015ddd21da0d4e06448"}, - {file = "Pillow-9.3.0-cp39-cp39-win32.whl", hash = "sha256:bac18ab8d2d1e6b4ce25e3424f709aceef668347db8637c2296bcf41acb7cf48"}, - {file = "Pillow-9.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:b472b5ea442148d1c3e2209f20f1e0bb0eb556538690fa70b5e1f79fa0ba8dc2"}, - {file = "Pillow-9.3.0-pp37-pypy37_pp73-macosx_10_10_x86_64.whl", hash = "sha256:ab388aaa3f6ce52ac1cb8e122c4bd46657c15905904b3120a6248b5b8b0bc228"}, - {file = "Pillow-9.3.0-pp37-pypy37_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dbb8e7f2abee51cef77673be97760abff1674ed32847ce04b4af90f610144c7b"}, - {file = "Pillow-9.3.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bca31dd6014cb8b0b2db1e46081b0ca7d936f856da3b39744aef499db5d84d02"}, - {file = "Pillow-9.3.0-pp37-pypy37_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c7025dce65566eb6e89f56c9509d4f628fddcedb131d9465cacd3d8bac337e7e"}, - {file = "Pillow-9.3.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:ebf2029c1f464c59b8bdbe5143c79fa2045a581ac53679733d3a91d400ff9efb"}, - {file = "Pillow-9.3.0-pp38-pypy38_pp73-macosx_10_10_x86_64.whl", hash = "sha256:b59430236b8e58840a0dfb4099a0e8717ffb779c952426a69ae435ca1f57210c"}, - {file = "Pillow-9.3.0-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:12ce4932caf2ddf3e41d17fc9c02d67126935a44b86df6a206cf0d7161548627"}, - {file = "Pillow-9.3.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ae5331c23ce118c53b172fa64a4c037eb83c9165aba3a7ba9ddd3ec9fa64a699"}, - {file = "Pillow-9.3.0-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:0b07fffc13f474264c336298d1b4ce01d9c5a011415b79d4ee5527bb69ae6f65"}, - {file = "Pillow-9.3.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:073adb2ae23431d3b9bcbcff3fe698b62ed47211d0716b067385538a1b0f28b8"}, - {file = "Pillow-9.3.0.tar.gz", hash = "sha256:c935a22a557a560108d780f9a0fc426dd7459940dc54faa49d83249c8d3e760f"}, + {file = "Pillow-9.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:2968c58feca624bb6c8502f9564dd187d0e1389964898f5e9e1fbc8533169157"}, + {file = "Pillow-9.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c5c1362c14aee73f50143d74389b2c158707b4abce2cb055b7ad37ce60738d47"}, + {file = "Pillow-9.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd752c5ff1b4a870b7661234694f24b1d2b9076b8bf337321a814c612665f343"}, + {file = "Pillow-9.4.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9a3049a10261d7f2b6514d35bbb7a4dfc3ece4c4de14ef5876c4b7a23a0e566d"}, + {file = "Pillow-9.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:16a8df99701f9095bea8a6c4b3197da105df6f74e6176c5b410bc2df2fd29a57"}, + {file = "Pillow-9.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:94cdff45173b1919350601f82d61365e792895e3c3a3443cf99819e6fbf717a5"}, + {file = "Pillow-9.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:ed3e4b4e1e6de75fdc16d3259098de7c6571b1a6cc863b1a49e7d3d53e036070"}, + {file = "Pillow-9.4.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d5b2f8a31bd43e0f18172d8ac82347c8f37ef3e0b414431157718aa234991b28"}, + {file = "Pillow-9.4.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:09b89ddc95c248ee788328528e6a2996e09eaccddeeb82a5356e92645733be35"}, + {file = "Pillow-9.4.0-cp310-cp310-win32.whl", hash = "sha256:f09598b416ba39a8f489c124447b007fe865f786a89dbfa48bb5cf395693132a"}, + {file = "Pillow-9.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:f6e78171be3fb7941f9910ea15b4b14ec27725865a73c15277bc39f5ca4f8391"}, + {file = "Pillow-9.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:3fa1284762aacca6dc97474ee9c16f83990b8eeb6697f2ba17140d54b453e133"}, + {file = "Pillow-9.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:eaef5d2de3c7e9b21f1e762f289d17b726c2239a42b11e25446abf82b26ac132"}, + {file = "Pillow-9.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a4dfdae195335abb4e89cc9762b2edc524f3c6e80d647a9a81bf81e17e3fb6f0"}, + {file = "Pillow-9.4.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6abfb51a82e919e3933eb137e17c4ae9c0475a25508ea88993bb59faf82f3b35"}, + {file = "Pillow-9.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:451f10ef963918e65b8869e17d67db5e2f4ab40e716ee6ce7129b0cde2876eab"}, + {file = "Pillow-9.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:6663977496d616b618b6cfa43ec86e479ee62b942e1da76a2c3daa1c75933ef4"}, + {file = "Pillow-9.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:60e7da3a3ad1812c128750fc1bc14a7ceeb8d29f77e0a2356a8fb2aa8925287d"}, + {file = "Pillow-9.4.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:19005a8e58b7c1796bc0167862b1f54a64d3b44ee5d48152b06bb861458bc0f8"}, + {file = "Pillow-9.4.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f715c32e774a60a337b2bb8ad9839b4abf75b267a0f18806f6f4f5f1688c4b5a"}, + {file = "Pillow-9.4.0-cp311-cp311-win32.whl", hash = "sha256:b222090c455d6d1a64e6b7bb5f4035c4dff479e22455c9eaa1bdd4c75b52c80c"}, + {file = "Pillow-9.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:ba6612b6548220ff5e9df85261bddc811a057b0b465a1226b39bfb8550616aee"}, + {file = "Pillow-9.4.0-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:5f532a2ad4d174eb73494e7397988e22bf427f91acc8e6ebf5bb10597b49c493"}, + {file = "Pillow-9.4.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dd5a9c3091a0f414a963d427f920368e2b6a4c2f7527fdd82cde8ef0bc7a327"}, + {file = "Pillow-9.4.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ef21af928e807f10bf4141cad4746eee692a0dd3ff56cfb25fce076ec3cc8abe"}, + {file = "Pillow-9.4.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:847b114580c5cc9ebaf216dd8c8dbc6b00a3b7ab0131e173d7120e6deade1f57"}, + {file = "Pillow-9.4.0-cp37-cp37m-manylinux_2_28_aarch64.whl", hash = "sha256:653d7fb2df65efefbcbf81ef5fe5e5be931f1ee4332c2893ca638c9b11a409c4"}, + {file = "Pillow-9.4.0-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:46f39cab8bbf4a384ba7cb0bc8bae7b7062b6a11cfac1ca4bc144dea90d4a9f5"}, + {file = "Pillow-9.4.0-cp37-cp37m-win32.whl", hash = "sha256:7ac7594397698f77bce84382929747130765f66406dc2cd8b4ab4da68ade4c6e"}, + {file = "Pillow-9.4.0-cp37-cp37m-win_amd64.whl", hash = "sha256:46c259e87199041583658457372a183636ae8cd56dbf3f0755e0f376a7f9d0e6"}, + {file = "Pillow-9.4.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:0e51f608da093e5d9038c592b5b575cadc12fd748af1479b5e858045fff955a9"}, + {file = "Pillow-9.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:765cb54c0b8724a7c12c55146ae4647e0274a839fb6de7bcba841e04298e1011"}, + {file = "Pillow-9.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:519e14e2c49fcf7616d6d2cfc5c70adae95682ae20f0395e9280db85e8d6c4df"}, + {file = "Pillow-9.4.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d197df5489004db87d90b918033edbeee0bd6df3848a204bca3ff0a903bef837"}, + {file = "Pillow-9.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0845adc64fe9886db00f5ab68c4a8cd933ab749a87747555cec1c95acea64b0b"}, + {file = "Pillow-9.4.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:e1339790c083c5a4de48f688b4841f18df839eb3c9584a770cbd818b33e26d5d"}, + {file = "Pillow-9.4.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:a96e6e23f2b79433390273eaf8cc94fec9c6370842e577ab10dabdcc7ea0a66b"}, + {file = "Pillow-9.4.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:7cfc287da09f9d2a7ec146ee4d72d6ea1342e770d975e49a8621bf54eaa8f30f"}, + {file = "Pillow-9.4.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:d7081c084ceb58278dd3cf81f836bc818978c0ccc770cbbb202125ddabec6628"}, + {file = "Pillow-9.4.0-cp38-cp38-win32.whl", hash = "sha256:df41112ccce5d47770a0c13651479fbcd8793f34232a2dd9faeccb75eb5d0d0d"}, + {file = "Pillow-9.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:7a21222644ab69ddd9967cfe6f2bb420b460dae4289c9d40ff9a4896e7c35c9a"}, + {file = "Pillow-9.4.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:0f3269304c1a7ce82f1759c12ce731ef9b6e95b6df829dccd9fe42912cc48569"}, + {file = "Pillow-9.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:cb362e3b0976dc994857391b776ddaa8c13c28a16f80ac6522c23d5257156bed"}, + {file = "Pillow-9.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a2e0f87144fcbbe54297cae708c5e7f9da21a4646523456b00cc956bd4c65815"}, + {file = "Pillow-9.4.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:28676836c7796805914b76b1837a40f76827ee0d5398f72f7dcc634bae7c6264"}, + {file = "Pillow-9.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0884ba7b515163a1a05440a138adeb722b8a6ae2c2b33aea93ea3118dd3a899e"}, + {file = "Pillow-9.4.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:53dcb50fbdc3fb2c55431a9b30caeb2f7027fcd2aeb501459464f0214200a503"}, + {file = "Pillow-9.4.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:e8c5cf126889a4de385c02a2c3d3aba4b00f70234bfddae82a5eaa3ee6d5e3e6"}, + {file = "Pillow-9.4.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:6c6b1389ed66cdd174d040105123a5a1bc91d0aa7059c7261d20e583b6d8cbd2"}, + {file = "Pillow-9.4.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:0dd4c681b82214b36273c18ca7ee87065a50e013112eea7d78c7a1b89a739153"}, + {file = "Pillow-9.4.0-cp39-cp39-win32.whl", hash = "sha256:6d9dfb9959a3b0039ee06c1a1a90dc23bac3b430842dcb97908ddde05870601c"}, + {file = "Pillow-9.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:54614444887e0d3043557d9dbc697dbb16cfb5a35d672b7a0fcc1ed0cf1c600b"}, + {file = "Pillow-9.4.0-pp38-pypy38_pp73-macosx_10_10_x86_64.whl", hash = "sha256:b9b752ab91e78234941e44abdecc07f1f0d8f51fb62941d32995b8161f68cfe5"}, + {file = "Pillow-9.4.0-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d3b56206244dc8711f7e8b7d6cad4663917cd5b2d950799425076681e8766286"}, + {file = "Pillow-9.4.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aabdab8ec1e7ca7f1434d042bf8b1e92056245fb179790dc97ed040361f16bfd"}, + {file = "Pillow-9.4.0-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:db74f5562c09953b2c5f8ec4b7dfd3f5421f31811e97d1dbc0a7c93d6e3a24df"}, + {file = "Pillow-9.4.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:e9d7747847c53a16a729b6ee5e737cf170f7a16611c143d95aa60a109a59c336"}, + {file = "Pillow-9.4.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:b52ff4f4e002f828ea6483faf4c4e8deea8d743cf801b74910243c58acc6eda3"}, + {file = "Pillow-9.4.0-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:575d8912dca808edd9acd6f7795199332696d3469665ef26163cd090fa1f8bfa"}, + {file = "Pillow-9.4.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c3c4ed2ff6760e98d262e0cc9c9a7f7b8a9f61aa4d47c58835cdaf7b0b8811bb"}, + {file = "Pillow-9.4.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e621b0246192d3b9cb1dc62c78cfa4c6f6d2ddc0ec207d43c0dedecb914f152a"}, + {file = "Pillow-9.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:8f127e7b028900421cad64f51f75c051b628db17fb00e099eb148761eed598c9"}, + {file = "Pillow-9.4.0.tar.gz", hash = "sha256:a1c2d7780448eb93fbcc3789bf3916aa5720d942e37945f4056680317f1cd23e"}, ] pkgutil_resolve_name = [ {file = "pkgutil_resolve_name-1.3.10-py3-none-any.whl", hash = "sha256:ca27cc078d25c5ad71a9de0a7a330146c4e014c2462d9af19c6b828280649c5e"}, @@ -2936,8 +3388,8 @@ pydata-sphinx-theme = [ {file = "pydata_sphinx_theme-0.9.0.tar.gz", hash = "sha256:03598a86915b596f4bf80bef79a4d33276a83e670bf360def699dbb9f99dc57a"}, ] pydocstyle = [ - {file = "pydocstyle-6.1.1-py3-none-any.whl", hash = "sha256:6987826d6775056839940041beef5c08cc7e3d71d63149b48e36727f70144dc4"}, - {file = "pydocstyle-6.1.1.tar.gz", hash = "sha256:1d41b7c459ba0ee6c345f2eb9ae827cab14a7533a88c5c6f7e94923f72df92dc"}, + {file = "pydocstyle-6.2.0-py3-none-any.whl", hash = "sha256:39573fa08919ac492b063724af39a1afdcfea8cdaa2c7b8018ca0dfff5d7e36f"}, + {file = "pydocstyle-6.2.0.tar.gz", hash = "sha256:b2d280501a4c0d9feeb96e9171dc3f6f7d0064c55270f4c7b1baa18452019fd9"}, ] pydot = [ {file = "pydot-1.4.2-py2.py3-none-any.whl", hash = "sha256:66c98190c65b8d2e2382a441b4c0edfdb4f4c025ef9cb9874de478fb0793a451"}, @@ -2948,8 +3400,8 @@ pyflakes = [ {file = "pyflakes-2.5.0.tar.gz", hash = "sha256:491feb020dca48ccc562a8c0cbe8df07ee13078df59813b83959cbdada312ea3"}, ] Pygments = [ - {file = "Pygments-2.13.0-py3-none-any.whl", hash = "sha256:f643f331ab57ba3c9d89212ee4a2dabc6e94f117cf4eefde99a0574720d14c42"}, - {file = "Pygments-2.13.0.tar.gz", hash = "sha256:56a8508ae95f98e2b9bdf93a6be5ae3f7d8af858b43e02c5a2ff083726be40c1"}, + {file = "Pygments-2.14.0-py3-none-any.whl", hash = "sha256:fa7bd7bd2771287c0de303af8bfdfc731f51bd2c6a47ab69d117138893b82717"}, + {file = "Pygments-2.14.0.tar.gz", hash = "sha256:b3ed06a9e8ac9a9aae5a6f5dbe78a8a58655d17b43b93c078f094ddc476ae297"}, ] pygraphviz = [ {file = "pygraphviz-1.10.zip", hash = "sha256:457e093a888128903251a266a8cc16b4ba93f3f6334b3ebfed92c7471a74d867"}, @@ -2962,29 +3414,38 @@ pyparsing = [ {file = "pyparsing-3.0.9-py3-none-any.whl", hash = "sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc"}, {file = "pyparsing-3.0.9.tar.gz", hash = "sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb"}, ] +pypickle = [ + {file = "pypickle-1.1.0-py3-none-any.whl", hash = "sha256:3f0454b36e7d833aa76c4b8495802a2369da488de585f97071dc99733982a273"}, + {file = "pypickle-1.1.0.tar.gz", hash = "sha256:431739b9e22cc7fd093f9f605660cdbb7a5582182ca44de1616c32b651f969ef"}, +] pyrsistent = [ - {file = "pyrsistent-0.19.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d6982b5a0237e1b7d876b60265564648a69b14017f3b5f908c5be2de3f9abb7a"}, - {file = "pyrsistent-0.19.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:187d5730b0507d9285a96fca9716310d572e5464cadd19f22b63a6976254d77a"}, - {file = "pyrsistent-0.19.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:055ab45d5911d7cae397dc418808d8802fb95262751872c841c170b0dbf51eed"}, - {file = "pyrsistent-0.19.2-cp310-cp310-win32.whl", hash = "sha256:456cb30ca8bff00596519f2c53e42c245c09e1a4543945703acd4312949bfd41"}, - {file = "pyrsistent-0.19.2-cp310-cp310-win_amd64.whl", hash = "sha256:b39725209e06759217d1ac5fcdb510e98670af9e37223985f330b611f62e7425"}, - {file = "pyrsistent-0.19.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:2aede922a488861de0ad00c7630a6e2d57e8023e4be72d9d7147a9fcd2d30712"}, - {file = "pyrsistent-0.19.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:879b4c2f4d41585c42df4d7654ddffff1239dc4065bc88b745f0341828b83e78"}, - {file = "pyrsistent-0.19.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c43bec251bbd10e3cb58ced80609c5c1eb238da9ca78b964aea410fb820d00d6"}, - {file = "pyrsistent-0.19.2-cp37-cp37m-win32.whl", hash = "sha256:d690b18ac4b3e3cab73b0b7aa7dbe65978a172ff94970ff98d82f2031f8971c2"}, - {file = "pyrsistent-0.19.2-cp37-cp37m-win_amd64.whl", hash = "sha256:3ba4134a3ff0fc7ad225b6b457d1309f4698108fb6b35532d015dca8f5abed73"}, - {file = "pyrsistent-0.19.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:a178209e2df710e3f142cbd05313ba0c5ebed0a55d78d9945ac7a4e09d923308"}, - {file = "pyrsistent-0.19.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e371b844cec09d8dc424d940e54bba8f67a03ebea20ff7b7b0d56f526c71d584"}, - {file = "pyrsistent-0.19.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:111156137b2e71f3a9936baf27cb322e8024dac3dc54ec7fb9f0bcf3249e68bb"}, - {file = "pyrsistent-0.19.2-cp38-cp38-win32.whl", hash = "sha256:e5d8f84d81e3729c3b506657dddfe46e8ba9c330bf1858ee33108f8bb2adb38a"}, - {file = "pyrsistent-0.19.2-cp38-cp38-win_amd64.whl", hash = "sha256:9cd3e9978d12b5d99cbdc727a3022da0430ad007dacf33d0bf554b96427f33ab"}, - {file = "pyrsistent-0.19.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:f1258f4e6c42ad0b20f9cfcc3ada5bd6b83374516cd01c0960e3cb75fdca6770"}, - {file = "pyrsistent-0.19.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:21455e2b16000440e896ab99e8304617151981ed40c29e9507ef1c2e4314ee95"}, - {file = "pyrsistent-0.19.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bfd880614c6237243ff53a0539f1cb26987a6dc8ac6e66e0c5a40617296a045e"}, - {file = "pyrsistent-0.19.2-cp39-cp39-win32.whl", hash = "sha256:71d332b0320642b3261e9fee47ab9e65872c2bd90260e5d225dabeed93cbd42b"}, - {file = "pyrsistent-0.19.2-cp39-cp39-win_amd64.whl", hash = "sha256:dec3eac7549869365fe263831f576c8457f6c833937c68542d08fde73457d291"}, - {file = "pyrsistent-0.19.2-py3-none-any.whl", hash = "sha256:ea6b79a02a28550c98b6ca9c35b9f492beaa54d7c5c9e9949555893c8a9234d0"}, - {file = "pyrsistent-0.19.2.tar.gz", hash = "sha256:bfa0351be89c9fcbcb8c9879b826f4353be10f58f8a677efab0c017bf7137ec2"}, + {file = "pyrsistent-0.19.3-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:20460ac0ea439a3e79caa1dbd560344b64ed75e85d8703943e0b66c2a6150e4a"}, + {file = "pyrsistent-0.19.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4c18264cb84b5e68e7085a43723f9e4c1fd1d935ab240ce02c0324a8e01ccb64"}, + {file = "pyrsistent-0.19.3-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4b774f9288dda8d425adb6544e5903f1fb6c273ab3128a355c6b972b7df39dcf"}, + {file = "pyrsistent-0.19.3-cp310-cp310-win32.whl", hash = "sha256:5a474fb80f5e0d6c9394d8db0fc19e90fa540b82ee52dba7d246a7791712f74a"}, + {file = "pyrsistent-0.19.3-cp310-cp310-win_amd64.whl", hash = "sha256:49c32f216c17148695ca0e02a5c521e28a4ee6c5089f97e34fe24163113722da"}, + {file = "pyrsistent-0.19.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f0774bf48631f3a20471dd7c5989657b639fd2d285b861237ea9e82c36a415a9"}, + {file = "pyrsistent-0.19.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ab2204234c0ecd8b9368dbd6a53e83c3d4f3cab10ecaf6d0e772f456c442393"}, + {file = "pyrsistent-0.19.3-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e42296a09e83028b3476f7073fcb69ffebac0e66dbbfd1bd847d61f74db30f19"}, + {file = "pyrsistent-0.19.3-cp311-cp311-win32.whl", hash = "sha256:64220c429e42a7150f4bfd280f6f4bb2850f95956bde93c6fda1b70507af6ef3"}, + {file = "pyrsistent-0.19.3-cp311-cp311-win_amd64.whl", hash = "sha256:016ad1afadf318eb7911baa24b049909f7f3bb2c5b1ed7b6a8f21db21ea3faa8"}, + {file = "pyrsistent-0.19.3-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:c4db1bd596fefd66b296a3d5d943c94f4fac5bcd13e99bffe2ba6a759d959a28"}, + {file = "pyrsistent-0.19.3-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aeda827381f5e5d65cced3024126529ddc4289d944f75e090572c77ceb19adbf"}, + {file = "pyrsistent-0.19.3-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:42ac0b2f44607eb92ae88609eda931a4f0dfa03038c44c772e07f43e738bcac9"}, + {file = "pyrsistent-0.19.3-cp37-cp37m-win32.whl", hash = "sha256:e8f2b814a3dc6225964fa03d8582c6e0b6650d68a232df41e3cc1b66a5d2f8d1"}, + {file = "pyrsistent-0.19.3-cp37-cp37m-win_amd64.whl", hash = "sha256:c9bb60a40a0ab9aba40a59f68214eed5a29c6274c83b2cc206a359c4a89fa41b"}, + {file = "pyrsistent-0.19.3-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:a2471f3f8693101975b1ff85ffd19bb7ca7dd7c38f8a81701f67d6b4f97b87d8"}, + {file = "pyrsistent-0.19.3-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc5d149f31706762c1f8bda2e8c4f8fead6e80312e3692619a75301d3dbb819a"}, + {file = "pyrsistent-0.19.3-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3311cb4237a341aa52ab8448c27e3a9931e2ee09561ad150ba94e4cfd3fc888c"}, + {file = "pyrsistent-0.19.3-cp38-cp38-win32.whl", hash = "sha256:f0e7c4b2f77593871e918be000b96c8107da48444d57005b6a6bc61fb4331b2c"}, + {file = "pyrsistent-0.19.3-cp38-cp38-win_amd64.whl", hash = "sha256:c147257a92374fde8498491f53ffa8f4822cd70c0d85037e09028e478cababb7"}, + {file = "pyrsistent-0.19.3-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b735e538f74ec31378f5a1e3886a26d2ca6351106b4dfde376a26fc32a044edc"}, + {file = "pyrsistent-0.19.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:99abb85579e2165bd8522f0c0138864da97847875ecbd45f3e7e2af569bfc6f2"}, + {file = "pyrsistent-0.19.3-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3a8cb235fa6d3fd7aae6a4f1429bbb1fec1577d978098da1252f0489937786f3"}, + {file = "pyrsistent-0.19.3-cp39-cp39-win32.whl", hash = "sha256:c74bed51f9b41c48366a286395c67f4e894374306b197e62810e0fdaf2364da2"}, + {file = "pyrsistent-0.19.3-cp39-cp39-win_amd64.whl", hash = "sha256:878433581fc23e906d947a6814336eee031a00e6defba224234169ae3d3d6a98"}, + {file = "pyrsistent-0.19.3-py3-none-any.whl", hash = "sha256:ccf0d6bd208f8111179f0c26fdf84ed7c3891982f2edaeae7422575f47e66b64"}, + {file = "pyrsistent-0.19.3.tar.gz", hash = "sha256:1a2994773706bbb4995c31a97bc94f1418314923bd1048c6d964837040376440"}, ] pytest = [ {file = "pytest-7.2.0-py3-none-any.whl", hash = "sha256:892f933d339f068883b6fd5a459f03d85bfcb355e4981e146d2c7616c21fef71"}, @@ -2998,10 +3459,16 @@ python-dateutil = [ {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"}, ] +python-louvain = [ + {file = "python-louvain-0.16.tar.gz", hash = "sha256:b7ba2df5002fd28d3ee789a49532baad11fe648e4f2117cf0798e7520a1da56b"}, +] pytz = [ {file = "pytz-2022.7-py2.py3-none-any.whl", hash = "sha256:93007def75ae22f7cd991c84e02d434876818661f8df9ad5df9e950ff4e52cfd"}, {file = "pytz-2022.7.tar.gz", hash = "sha256:7ccfae7b4b2c067464a6733c6261673fdb8fd1be905460396b97a073e9fa683a"}, ] +pyvis = [ + {file = "pyvis-0.3.1.tar.gz", hash = "sha256:aa817caac54afc9a4df38ada6f46636b842a8bd57197bb6aca5084699da04307"}, +] pywhy-graphs = [] pywin32 = [ {file = "pywin32-305-cp310-cp310-win32.whl", hash = "sha256:421f6cd86e84bbb696d54563c48014b12a23ef95a14e0bdba526be756d89f116"}, @@ -3364,6 +3831,10 @@ sympy = [ {file = "sympy-1.11.1-py3-none-any.whl", hash = "sha256:938f984ee2b1e8eae8a07b884c8b7a1146010040fccddc6539c54f401c8f6fcf"}, {file = "sympy-1.11.1.tar.gz", hash = "sha256:e32380dce63cb7c0108ed525570092fd45168bdae2faa17e528221ef72e88658"}, ] +tabulate = [ + {file = "tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f"}, + {file = "tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c"}, +] termcolor-whl = [ {file = "termcolor_whl-1.1.2-py2.py3-none-any.whl", hash = "sha256:3e7eda7348bb90ddea2d7a2171df65ed4a37adf62574fbd5459198410fdba881"}, ] @@ -3387,6 +3858,29 @@ tomli = [ {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"}, {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"}, ] +torch = [ + {file = "torch-1.13.1-cp310-cp310-manylinux1_x86_64.whl", hash = "sha256:fd12043868a34a8da7d490bf6db66991108b00ffbeecb034228bfcbbd4197143"}, + {file = "torch-1.13.1-cp310-cp310-manylinux2014_aarch64.whl", hash = "sha256:d9fe785d375f2e26a5d5eba5de91f89e6a3be5d11efb497e76705fdf93fa3c2e"}, + {file = "torch-1.13.1-cp310-cp310-win_amd64.whl", hash = "sha256:98124598cdff4c287dbf50f53fb455f0c1e3a88022b39648102957f3445e9b76"}, + {file = "torch-1.13.1-cp310-none-macosx_10_9_x86_64.whl", hash = "sha256:393a6273c832e047581063fb74335ff50b4c566217019cc6ace318cd79eb0566"}, + {file = "torch-1.13.1-cp310-none-macosx_11_0_arm64.whl", hash = "sha256:0122806b111b949d21fa1a5f9764d1fd2fcc4a47cb7f8ff914204fd4fc752ed5"}, + {file = "torch-1.13.1-cp311-cp311-manylinux1_x86_64.whl", hash = "sha256:22128502fd8f5b25ac1cd849ecb64a418382ae81dd4ce2b5cebaa09ab15b0d9b"}, + {file = "torch-1.13.1-cp37-cp37m-manylinux1_x86_64.whl", hash = "sha256:76024be052b659ac1304ab8475ab03ea0a12124c3e7626282c9c86798ac7bc11"}, + {file = "torch-1.13.1-cp37-cp37m-manylinux2014_aarch64.whl", hash = "sha256:ea8dda84d796094eb8709df0fcd6b56dc20b58fdd6bc4e8d7109930dafc8e419"}, + {file = "torch-1.13.1-cp37-cp37m-win_amd64.whl", hash = "sha256:2ee7b81e9c457252bddd7d3da66fb1f619a5d12c24d7074de91c4ddafb832c93"}, + {file = "torch-1.13.1-cp37-none-macosx_10_9_x86_64.whl", hash = "sha256:0d9b8061048cfb78e675b9d2ea8503bfe30db43d583599ae8626b1263a0c1380"}, + {file = "torch-1.13.1-cp37-none-macosx_11_0_arm64.whl", hash = "sha256:f402ca80b66e9fbd661ed4287d7553f7f3899d9ab54bf5c67faada1555abde28"}, + {file = "torch-1.13.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:727dbf00e2cf858052364c0e2a496684b9cb5aa01dc8a8bc8bbb7c54502bdcdd"}, + {file = "torch-1.13.1-cp38-cp38-manylinux2014_aarch64.whl", hash = "sha256:df8434b0695e9ceb8cc70650afc1310d8ba949e6db2a0525ddd9c3b2b181e5fe"}, + {file = "torch-1.13.1-cp38-cp38-win_amd64.whl", hash = "sha256:5e1e722a41f52a3f26f0c4fcec227e02c6c42f7c094f32e49d4beef7d1e213ea"}, + {file = "torch-1.13.1-cp38-none-macosx_10_9_x86_64.whl", hash = "sha256:33e67eea526e0bbb9151263e65417a9ef2d8fa53cbe628e87310060c9dcfa312"}, + {file = "torch-1.13.1-cp38-none-macosx_11_0_arm64.whl", hash = "sha256:eeeb204d30fd40af6a2d80879b46a7efbe3cf43cdbeb8838dd4f3d126cc90b2b"}, + {file = "torch-1.13.1-cp39-cp39-manylinux1_x86_64.whl", hash = "sha256:50ff5e76d70074f6653d191fe4f6a42fdbe0cf942fbe2a3af0b75eaa414ac038"}, + {file = "torch-1.13.1-cp39-cp39-manylinux2014_aarch64.whl", hash = "sha256:2c3581a3fd81eb1f0f22997cddffea569fea53bafa372b2c0471db373b26aafc"}, + {file = "torch-1.13.1-cp39-cp39-win_amd64.whl", hash = "sha256:0aa46f0ac95050c604bcf9ef71da9f1172e5037fdf2ebe051962d47b123848e7"}, + {file = "torch-1.13.1-cp39-none-macosx_10_9_x86_64.whl", hash = "sha256:6930791efa8757cb6974af73d4996b6b50c592882a324b8fb0589c6a9ba2ddaf"}, + {file = "torch-1.13.1-cp39-none-macosx_11_0_arm64.whl", hash = "sha256:e0df902a7c7dd6c795698532ee5970ce898672625635d885eade9976e5a04949"}, +] tornado = [ {file = "tornado-6.2-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:20f638fd8cc85f3cbae3c732326e96addff0a15e22d80f049e00121651e82e72"}, {file = "tornado-6.2-cp37-abi3-macosx_10_9_x86_64.whl", hash = "sha256:87dcafae3e884462f90c90ecc200defe5e580a7fbbb4365eda7c7c1eb809ebc9"}, @@ -3417,34 +3911,34 @@ urllib3 = [ {file = "urllib3-1.26.13.tar.gz", hash = "sha256:c083dd0dce68dbfbe1129d5271cb90f9447dea7d52097c6e0126120c521ddea8"}, ] watchdog = [ - {file = "watchdog-2.2.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ed91c3ccfc23398e7aa9715abf679d5c163394b8cad994f34f156d57a7c163dc"}, - {file = "watchdog-2.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:76a2743402b794629a955d96ea2e240bd0e903aa26e02e93cd2d57b33900962b"}, - {file = "watchdog-2.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:920a4bda7daa47545c3201a3292e99300ba81ca26b7569575bd086c865889090"}, - {file = "watchdog-2.2.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ceaa9268d81205876bedb1069f9feab3eccddd4b90d9a45d06a0df592a04cae9"}, - {file = "watchdog-2.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1893d425ef4fb4f129ee8ef72226836619c2950dd0559bba022b0818c63a7b60"}, - {file = "watchdog-2.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9e99c1713e4436d2563f5828c8910e5ff25abd6ce999e75f15c15d81d41980b6"}, - {file = "watchdog-2.2.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:a5bd9e8656d07cae89ac464ee4bcb6f1b9cecbedc3bf1334683bed3d5afd39ba"}, - {file = "watchdog-2.2.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:3a048865c828389cb06c0bebf8a883cec3ae58ad3e366bcc38c61d8455a3138f"}, - {file = "watchdog-2.2.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e722755d995035dd32177a9c633d158f2ec604f2a358b545bba5bed53ab25bca"}, - {file = "watchdog-2.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:af4b5c7ba60206759a1d99811b5938ca666ea9562a1052b410637bb96ff97512"}, - {file = "watchdog-2.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:619d63fa5be69f89ff3a93e165e602c08ed8da402ca42b99cd59a8ec115673e1"}, - {file = "watchdog-2.2.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:1f2b0665c57358ce9786f06f5475bc083fea9d81ecc0efa4733fd0c320940a37"}, - {file = "watchdog-2.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:441024df19253bb108d3a8a5de7a186003d68564084576fecf7333a441271ef7"}, - {file = "watchdog-2.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1a410dd4d0adcc86b4c71d1317ba2ea2c92babaf5b83321e4bde2514525544d5"}, - {file = "watchdog-2.2.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:28704c71afdb79c3f215c90231e41c52b056ea880b6be6cee035c6149d658ed1"}, - {file = "watchdog-2.2.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2ac0bd7c206bb6df78ef9e8ad27cc1346f2b41b1fef610395607319cdab89bc1"}, - {file = "watchdog-2.2.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:27e49268735b3c27310883012ab3bd86ea0a96dcab90fe3feb682472e30c90f3"}, - {file = "watchdog-2.2.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:2af1a29fd14fc0a87fb6ed762d3e1ae5694dcde22372eebba50e9e5be47af03c"}, - {file = "watchdog-2.2.0-py3-none-manylinux2014_armv7l.whl", hash = "sha256:c7bd98813d34bfa9b464cf8122e7d4bec0a5a427399094d2c17dd5f70d59bc61"}, - {file = "watchdog-2.2.0-py3-none-manylinux2014_i686.whl", hash = "sha256:56fb3f40fc3deecf6e518303c7533f5e2a722e377b12507f6de891583f1b48aa"}, - {file = "watchdog-2.2.0-py3-none-manylinux2014_ppc64.whl", hash = "sha256:74535e955359d79d126885e642d3683616e6d9ab3aae0e7dcccd043bd5a3ff4f"}, - {file = "watchdog-2.2.0-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:cf05e6ff677b9655c6e9511d02e9cc55e730c4e430b7a54af9c28912294605a4"}, - {file = "watchdog-2.2.0-py3-none-manylinux2014_s390x.whl", hash = "sha256:d6ae890798a3560688b441ef086bb66e87af6b400a92749a18b856a134fc0318"}, - {file = "watchdog-2.2.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:e5aed2a700a18c194c39c266900d41f3db0c1ebe6b8a0834b9995c835d2ca66e"}, - {file = "watchdog-2.2.0-py3-none-win32.whl", hash = "sha256:d0fb5f2b513556c2abb578c1066f5f467d729f2eb689bc2db0739daf81c6bb7e"}, - {file = "watchdog-2.2.0-py3-none-win_amd64.whl", hash = "sha256:1f8eca9d294a4f194ce9df0d97d19b5598f310950d3ac3dd6e8d25ae456d4c8a"}, - {file = "watchdog-2.2.0-py3-none-win_ia64.whl", hash = "sha256:ad0150536469fa4b693531e497ffe220d5b6cd76ad2eda474a5e641ee204bbb6"}, - {file = "watchdog-2.2.0.tar.gz", hash = "sha256:83cf8bc60d9c613b66a4c018051873d6273d9e45d040eed06d6a96241bd8ec01"}, + {file = "watchdog-2.2.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:a09483249d25cbdb4c268e020cb861c51baab2d1affd9a6affc68ffe6a231260"}, + {file = "watchdog-2.2.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5100eae58133355d3ca6c1083a33b81355c4f452afa474c2633bd2fbbba398b3"}, + {file = "watchdog-2.2.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e618a4863726bc7a3c64f95c218437f3349fb9d909eb9ea3a1ed3b567417c661"}, + {file = "watchdog-2.2.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:102a60093090fc3ff76c983367b19849b7cc24ec414a43c0333680106e62aae1"}, + {file = "watchdog-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:748ca797ff59962e83cc8e4b233f87113f3cf247c23e6be58b8a2885c7337aa3"}, + {file = "watchdog-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6ccd8d84b9490a82b51b230740468116b8205822ea5fdc700a553d92661253a3"}, + {file = "watchdog-2.2.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:6e01d699cd260d59b84da6bda019dce0a3353e3fcc774408ae767fe88ee096b7"}, + {file = "watchdog-2.2.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:8586d98c494690482c963ffb24c49bf9c8c2fe0589cec4dc2f753b78d1ec301d"}, + {file = "watchdog-2.2.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:adaf2ece15f3afa33a6b45f76b333a7da9256e1360003032524d61bdb4c422ae"}, + {file = "watchdog-2.2.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:83a7cead445008e880dbde833cb9e5cc7b9a0958edb697a96b936621975f15b9"}, + {file = "watchdog-2.2.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f8ac23ff2c2df4471a61af6490f847633024e5aa120567e08d07af5718c9d092"}, + {file = "watchdog-2.2.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:d0f29fd9f3f149a5277929de33b4f121a04cf84bb494634707cfa8ea8ae106a8"}, + {file = "watchdog-2.2.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:967636031fa4c4955f0f3f22da3c5c418aa65d50908d31b73b3b3ffd66d60640"}, + {file = "watchdog-2.2.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:96cbeb494e6cbe3ae6aacc430e678ce4b4dd3ae5125035f72b6eb4e5e9eb4f4e"}, + {file = "watchdog-2.2.1-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:61fdb8e9c57baf625e27e1420e7ca17f7d2023929cd0065eb79c83da1dfbeacd"}, + {file = "watchdog-2.2.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:4cb5ecc332112017fbdb19ede78d92e29a8165c46b68a0b8ccbd0a154f196d5e"}, + {file = "watchdog-2.2.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:a480d122740debf0afac4ddd583c6c0bb519c24f817b42ed6f850e2f6f9d64a8"}, + {file = "watchdog-2.2.1-py3-none-manylinux2014_aarch64.whl", hash = "sha256:978a1aed55de0b807913b7482d09943b23a2d634040b112bdf31811a422f6344"}, + {file = "watchdog-2.2.1-py3-none-manylinux2014_armv7l.whl", hash = "sha256:8c28c23972ec9c524967895ccb1954bc6f6d4a557d36e681a36e84368660c4ce"}, + {file = "watchdog-2.2.1-py3-none-manylinux2014_i686.whl", hash = "sha256:c27d8c1535fd4474e40a4b5e01f4ba6720bac58e6751c667895cbc5c8a7af33c"}, + {file = "watchdog-2.2.1-py3-none-manylinux2014_ppc64.whl", hash = "sha256:d6b87477752bd86ac5392ecb9eeed92b416898c30bd40c7e2dd03c3146105646"}, + {file = "watchdog-2.2.1-py3-none-manylinux2014_ppc64le.whl", hash = "sha256:cece1aa596027ff56369f0b50a9de209920e1df9ac6d02c7f9e5d8162eb4f02b"}, + {file = "watchdog-2.2.1-py3-none-manylinux2014_s390x.whl", hash = "sha256:8b5cde14e5c72b2df5d074774bdff69e9b55da77e102a91f36ef26ca35f9819c"}, + {file = "watchdog-2.2.1-py3-none-manylinux2014_x86_64.whl", hash = "sha256:e038be858425c4f621900b8ff1a3a1330d9edcfeaa1c0468aeb7e330fb87693e"}, + {file = "watchdog-2.2.1-py3-none-win32.whl", hash = "sha256:bc43c1b24d2f86b6e1cc15f68635a959388219426109233e606517ff7d0a5a73"}, + {file = "watchdog-2.2.1-py3-none-win_amd64.whl", hash = "sha256:17f1708f7410af92ddf591e94ae71a27a13974559e72f7e9fde3ec174b26ba2e"}, + {file = "watchdog-2.2.1-py3-none-win_ia64.whl", hash = "sha256:195ab1d9d611a4c1e5311cbf42273bc541e18ea8c32712f2fb703cfc6ff006f9"}, + {file = "watchdog-2.2.1.tar.gz", hash = "sha256:cdcc23c9528601a8a293eb4369cbd14f6b4f34f07ae8769421252e9c22718b6f"}, ] wcwidth = [ {file = "wcwidth-0.2.5-py2.py3-none-any.whl", hash = "sha256:beb4802a9cebb9144e99086eff703a642a13d6a0052920003a230f3294bbe784"}, @@ -3454,6 +3948,17 @@ webencodings = [ {file = "webencodings-0.5.1-py2.py3-none-any.whl", hash = "sha256:a0af1213f3c2226497a97e2b3aa01a7e4bee4f403f95be16fc9acd2947514a78"}, {file = "webencodings-0.5.1.tar.gz", hash = "sha256:b36a1c245f2d304965eb4e0a82848379241dc04b865afcc4aab16748587e1923"}, ] +wget = [ + {file = "wget-3.2.zip", hash = "sha256:35e630eca2aa50ce998b9b1a127bb26b30dfee573702782aa982f875e3f16061"}, +] +wheel = [ + {file = "wheel-0.38.4-py3-none-any.whl", hash = "sha256:b60533f3f5d530e971d6737ca6d58681ee434818fab630c83a734bb10c083ce8"}, + {file = "wheel-0.38.4.tar.gz", hash = "sha256:965f5259b566725405b05e7cf774052044b1ed30119b5d586b2703aafe8719ac"}, +] +widgetsnbextension = [ + {file = "widgetsnbextension-4.0.5-py3-none-any.whl", hash = "sha256:eaaaf434fb9b08bd197b2a14ffe45ddb5ac3897593d43c69287091e5f3147bf7"}, + {file = "widgetsnbextension-4.0.5.tar.gz", hash = "sha256:003f716d930d385be3fd9de42dd9bf008e30053f73bddde235d14fbeaeff19af"}, +] yaspin = [ {file = "yaspin-2.2.0-py3-none-any.whl", hash = "sha256:a6948034483cb263a467bef5a564eb35458e950fcade2cd7ad1d7d4339db4711"}, {file = "yaspin-2.2.0.tar.gz", hash = "sha256:febdf35f3e0e45845dc2caa79a18780f9ec7a85a37a9a2c0389b314ba82d8912"}, diff --git a/pyproject.toml b/pyproject.toml index b8c889e6..1f39eb94 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -88,6 +88,7 @@ sphinx_rtd_theme = { version = "^1.0.0" } graphviz = { version = "^0.20.1" } ipython = { version = "^7.4.0" } nbsphinx = { version = "^0.8" } +bnlearn = { git = "https://github.com/erdogant/bnlearn.git", branch = 'master', optional = true } dowhy = { version = "^0.8" } typing-extensions = { version = "*" } # needed in dowhy's package joblib = { version = "^1.1.0" } # needed in dowhy's package