From 2c2ded89d24a55ebea8430cbb966aeef0aa1e699 Mon Sep 17 00:00:00 2001 From: Xavier Dupre Date: Sat, 5 Aug 2023 16:00:26 +0200 Subject: [PATCH 01/12] Add unittests for notebooks --- .../test_documentation_notebook.py | 99 +++++++++++++++++++ 1 file changed, 99 insertions(+) create mode 100644 _unittests/ut_xrun_doc/test_documentation_notebook.py diff --git a/_unittests/ut_xrun_doc/test_documentation_notebook.py b/_unittests/ut_xrun_doc/test_documentation_notebook.py new file mode 100644 index 00000000..af5d4530 --- /dev/null +++ b/_unittests/ut_xrun_doc/test_documentation_notebook.py @@ -0,0 +1,99 @@ +import unittest +import os +import sys +import importlib +import subprocess +import tempfile +import time +from nbconvert import PythonExporter +from teachpyx import __file__ as teachpyx_file +from teachpyx.ext_test_case import ExtTestCase + +VERBOSE = 0 +ROOT = os.path.realpath(os.path.abspath(os.path.join(teachpyx_file, "..", ".."))) + + +def import_source(module_file_path, module_name): + if not os.path.exists(module_file_path): + raise FileNotFoundError(module_file_path) + module_spec = importlib.util.spec_from_file_location(module_name, module_file_path) + if module_spec is None: + raise FileNotFoundError( + "Unable to find '{}' in '{}'.".format(module_name, module_file_path) + ) + module = importlib.util.module_from_spec(module_spec) + return module_spec.loader.exec_module(module) + + +class TestDocumentationNotebook(ExtTestCase): + def run_test(self, nb_name: str, verbose=0) -> int: + ppath = os.environ.get("PYTHONPATH", "") + if len(ppath) == 0: + os.environ["PYTHONPATH"] = ROOT + elif ROOT not in ppath: + sep = ";" if sys.platform == "win32" else ":" + os.environ["PYTHONPATH"] = ppath + sep + ROOT + + perf = time.perf_counter() + + exporter = PythonExporter() + content = exporter.from_filename(nb_name) + bcontent = content[0].encode("utf-8") + + with tempfile.NamedTemporaryFile() as tmp: + tmp.write(bcontent) + tmp.seek(0) + + fold, name = os.path.split(tmp.name) + + try: + mod = import_source(fold, os.path.splitext(name)[0]) + assert mod is not None + except FileNotFoundError: + # try another way + cmds = [sys.executable, "-u", os.path.join(fold, name)] + p = subprocess.Popen( + cmds, stdout=subprocess.PIPE, stderr=subprocess.PIPE + ) + res = p.communicate() + out, err = res + st = err.decode("ascii", errors="ignore") + if len(st) > 0 and "Traceback" in st: + raise AssertionError( + f"Example {nb_name!r} (cmd: {cmds} - " + f"exec_prefix={sys.exec_prefix!r}) " + f"failed due to\n{st}" + ) + + dt = time.perf_counter() - perf + if verbose: + print(f"{dt:.3f}: run {name!r}") + return 1 + + @classmethod + def add_test_methods_path(cls, fold): + found = os.listdir(fold) + last = os.path.split(fold)[-1] + for name in found: + if name.endswith(".ipynb"): + fullname = os.path.join(fold, name) + + def _test_(self, name=name): + res = self.run_test(fullname, verbose=VERBOSE) + self.assertIn(res, (-1, 1)) + + setattr(cls, f"test_{last}_{name}", _test_) + + @classmethod + def add_test_methods(cls): + this = os.path.abspath(os.path.dirname(__file__)) + fold = os.path.normpath( + os.path.join(this, "..", "..", "_doc", "practice", "exams") + ) + cls.add_test_methods_path(fold) + + +TestDocumentationNotebook.add_test_methods() + +if __name__ == "__main__": + unittest.main(verbosity=2) From e00d5f2ae3392fd6a3c6258b0234b4ed52c2cc22 Mon Sep 17 00:00:00 2001 From: Xavier Dupre Date: Sat, 5 Aug 2023 16:16:58 +0200 Subject: [PATCH 02/12] fix extension --- _unittests/ut_xrun_doc/test_documentation_notebook.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/_unittests/ut_xrun_doc/test_documentation_notebook.py b/_unittests/ut_xrun_doc/test_documentation_notebook.py index af5d4530..4a04bd62 100644 --- a/_unittests/ut_xrun_doc/test_documentation_notebook.py +++ b/_unittests/ut_xrun_doc/test_documentation_notebook.py @@ -40,7 +40,7 @@ def run_test(self, nb_name: str, verbose=0) -> int: content = exporter.from_filename(nb_name) bcontent = content[0].encode("utf-8") - with tempfile.NamedTemporaryFile() as tmp: + with tempfile.NamedTemporaryFile(suffix=".py") as tmp: tmp.write(bcontent) tmp.seek(0) From 1ef8e17c149ef58f80462e3e12c4bdd8c0e50084 Mon Sep 17 00:00:00 2001 From: Xavier Dupre Date: Sat, 5 Aug 2023 16:26:26 +0200 Subject: [PATCH 03/12] endswith --- _unittests/ut_xrun_doc/test_documentation_notebook.py | 3 ++- teachpyx/ext_test_case.py | 4 ++++ 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/_unittests/ut_xrun_doc/test_documentation_notebook.py b/_unittests/ut_xrun_doc/test_documentation_notebook.py index 4a04bd62..57071e66 100644 --- a/_unittests/ut_xrun_doc/test_documentation_notebook.py +++ b/_unittests/ut_xrun_doc/test_documentation_notebook.py @@ -19,7 +19,7 @@ def import_source(module_file_path, module_name): module_spec = importlib.util.spec_from_file_location(module_name, module_file_path) if module_spec is None: raise FileNotFoundError( - "Unable to find '{}' in '{}'.".format(module_name, module_file_path) + f"Unable to find {module_name!r} in {module_file_path!r}." ) module = importlib.util.module_from_spec(module_spec) return module_spec.loader.exec_module(module) @@ -41,6 +41,7 @@ def run_test(self, nb_name: str, verbose=0) -> int: bcontent = content[0].encode("utf-8") with tempfile.NamedTemporaryFile(suffix=".py") as tmp: + self.assertEndsWith(tmp.name, ".py") tmp.write(bcontent) tmp.seek(0) diff --git a/teachpyx/ext_test_case.py b/teachpyx/ext_test_case.py index 125e309a..2d49e739 100644 --- a/teachpyx/ext_test_case.py +++ b/teachpyx/ext_test_case.py @@ -170,6 +170,10 @@ def measure_time( class ExtTestCase(unittest.TestCase): _warns = [] + def assertEndsWith(self, string, suffix): + if not string.endswith(suffix): + raise AssertionError(f"{string!r} does not end with {suffix!r}.") + def assertExists(self, name): if not os.path.exists(name): raise AssertionError(f"File or folder {name!r} does not exists.") From 27ff92b3067b953e04aececa24c0b0a591596c80 Mon Sep 17 00:00:00 2001 From: Xavier Dupre Date: Sat, 5 Aug 2023 17:30:01 +0200 Subject: [PATCH 04/12] update notebook --- .../exams/interro_rapide_20_minutes_2014_10.ipynb | 10 ++++++++-- .../exams/interro_rapide_20_minutes_2015_11.ipynb | 12 ++++++++++-- _doc/practice/exams/td_note_2016.ipynb | 5 ++++- 3 files changed, 22 insertions(+), 5 deletions(-) diff --git a/_doc/practice/exams/interro_rapide_20_minutes_2014_10.ipynb b/_doc/practice/exams/interro_rapide_20_minutes_2014_10.ipynb index 7766daed..b8b4a04a 100644 --- a/_doc/practice/exams/interro_rapide_20_minutes_2014_10.ipynb +++ b/_doc/practice/exams/interro_rapide_20_minutes_2014_10.ipynb @@ -346,7 +346,10 @@ } ], "source": [ - "dictionnaire_depart.items()[0]" + "try:\n", + " dictionnaire_depart.items()[0]\n", + "except Exception as e:\n", + " print(e)" ] }, { @@ -413,7 +416,10 @@ } ], "source": [ - "iterateur(0, 10)[0]" + "try:\n", + " iterateur(0, 10)[0]\n", + "except Exception as e:\n", + " print(e)" ] }, { diff --git a/_doc/practice/exams/interro_rapide_20_minutes_2015_11.ipynb b/_doc/practice/exams/interro_rapide_20_minutes_2015_11.ipynb index 78571285..804a2acb 100644 --- a/_doc/practice/exams/interro_rapide_20_minutes_2015_11.ipynb +++ b/_doc/practice/exams/interro_rapide_20_minutes_2015_11.ipynb @@ -35,7 +35,11 @@ "\n", "l = [0, 1, 2, 3, 4]\n", "i = random.randint(0, 5)\n", - "del l[i] # déclenche une exception de temps en temps" + "try:\n", + " # déclenche une exception de temps en temps\n", + " del l[i]\n", + "except Exception as e:\n", + " print(e)" ] }, { @@ -68,7 +72,11 @@ "for i in range(0, 100):\n", " l = [0, 1, 2, 3, 4]\n", " i = random.randint(0, 5)\n", - " del l[i] # déclenche une exception quasi sûrement" + " try:\n", + " # déclenche une exception quasi sûrement\n", + " del l[i]\n", + " except Exception as e:\n", + " print(e)" ] }, { diff --git a/_doc/practice/exams/td_note_2016.ipynb b/_doc/practice/exams/td_note_2016.ipynb index bee50909..abab24c1 100644 --- a/_doc/practice/exams/td_note_2016.ipynb +++ b/_doc/practice/exams/td_note_2016.ipynb @@ -972,7 +972,10 @@ ], "source": [ "# déclenche une exception\n", - "\"3\" < 4" + "try:\n", + " \"3\" < 4\n", + "except Exception as e:\n", + " print(e)" ] }, { From 2ef996f794788c2e468c1e56cfca7a1376758311 Mon Sep 17 00:00:00 2001 From: Xavier Dupre Date: Sat, 5 Aug 2023 17:39:10 +0200 Subject: [PATCH 05/12] remove get_ipython --- .../test_documentation_notebook.py | 20 ++++++++++++++----- 1 file changed, 15 insertions(+), 5 deletions(-) diff --git a/_unittests/ut_xrun_doc/test_documentation_notebook.py b/_unittests/ut_xrun_doc/test_documentation_notebook.py index 57071e66..a280b437 100644 --- a/_unittests/ut_xrun_doc/test_documentation_notebook.py +++ b/_unittests/ut_xrun_doc/test_documentation_notebook.py @@ -26,6 +26,14 @@ def import_source(module_file_path, module_name): class TestDocumentationNotebook(ExtTestCase): + def post_process(self, content): + lines = [] + for line in content.split("\n"): + if "get_ipython()" in line: + line = "# " + line + lines.append(line) + return "\n".join(lines) + def run_test(self, nb_name: str, verbose=0) -> int: ppath = os.environ.get("PYTHONPATH", "") if len(ppath) == 0: @@ -37,8 +45,8 @@ def run_test(self, nb_name: str, verbose=0) -> int: perf = time.perf_counter() exporter = PythonExporter() - content = exporter.from_filename(nb_name) - bcontent = content[0].encode("utf-8") + content = self.post_process(exporter.from_filename(nb_name)[0]) + bcontent = content.encode("utf-8") with tempfile.NamedTemporaryFile(suffix=".py") as tmp: self.assertEndsWith(tmp.name, ".py") @@ -63,7 +71,7 @@ def run_test(self, nb_name: str, verbose=0) -> int: raise AssertionError( f"Example {nb_name!r} (cmd: {cmds} - " f"exec_prefix={sys.exec_prefix!r}) " - f"failed due to\n{st}" + f"failed due to\n{st}\n-----\n{content}" ) dt = time.perf_counter() - perf @@ -76,14 +84,16 @@ def add_test_methods_path(cls, fold): found = os.listdir(fold) last = os.path.split(fold)[-1] for name in found: + if "interro_rapide_" in name: + continue if name.endswith(".ipynb"): fullname = os.path.join(fold, name) - def _test_(self, name=name): + def _test_(self, fullname=fullname): res = self.run_test(fullname, verbose=VERBOSE) self.assertIn(res, (-1, 1)) - setattr(cls, f"test_{last}_{name}", _test_) + setattr(cls, f"test_{last}_{os.path.splitext(name)[0]}", _test_) @classmethod def add_test_methods(cls): From 606fbd01b83624342fd7c0c59d53d24fd68807ba Mon Sep 17 00:00:00 2001 From: Xavier Dupre Date: Sat, 5 Aug 2023 18:00:04 +0200 Subject: [PATCH 06/12] remove pyquickhelper --- .local.jenkins.lin.yml | 2 +- _doc/practice/exams/td_note_2016.ipynb | 4 +- teachpyx/faq/faq_python.py | 78 ++++++++++++++++++++++++-- 3 files changed, 77 insertions(+), 7 deletions(-) diff --git a/.local.jenkins.lin.yml b/.local.jenkins.lin.yml index f50eca8b..9f63f56c 100644 --- a/.local.jenkins.lin.yml +++ b/.local.jenkins.lin.yml @@ -9,7 +9,7 @@ virtualenv: install: - $PYINT -m pip install --upgrade pip - - $PYINT -m pip install --upgrade --no-cache-dir --no-deps --index http://localhost:8067/simple/ pyquickhelper pandas_streaming --extra-index-url=https://pypi.python.org/simple/ + - $PYINT -m pip install --upgrade --no-cache-dir --no-deps --index http://localhost:8067/simple/ pandas_streaming --extra-index-url=https://pypi.python.org/simple/ - $PYINT -m pip install -r requirements-dev.txt - $PYINT --version - $PYINT -m pip freeze diff --git a/_doc/practice/exams/td_note_2016.ipynb b/_doc/practice/exams/td_note_2016.ipynb index abab24c1..e98c4dec 100644 --- a/_doc/practice/exams/td_note_2016.ipynb +++ b/_doc/practice/exams/td_note_2016.ipynb @@ -551,9 +551,9 @@ } ], "source": [ - "from pyquickhelper.helpgen import NbImage\n", + "from ipython.display import Image\n", "\n", - "NbImage(\"exam2016_values.png\")" + "Image(\"exam2016_values.png\")" ] }, { diff --git a/teachpyx/faq/faq_python.py b/teachpyx/faq/faq_python.py index bf5cb1a1..71dd1997 100644 --- a/teachpyx/faq/faq_python.py +++ b/teachpyx/faq/faq_python.py @@ -484,6 +484,80 @@ def __lt__(self, autre_instance): pass +def get_installed_distributions( + local_only=True, + skip=None, + include_editables=True, + editables_only=False, + user_only=False, + use_cmd=False, +): + """ + Directs call to function *get_installed_distributions* from :epkg:`pip`. + + Return a list of installed Distribution objects. + + :param local_only: if True (default), only return installations + local to the current virtualenv, if in a virtualenv. + :param skip: argument is an iterable of lower-case project names to + ignore; defaults to ``pip.compat.stdlib_pkgs`` (if *skip* is None) + :param editables: if False, don't report editables. + :param editables_only: if True , only report editables. + :param user_only: if True , only report installations in the user + site directory. + :param use_cmd: if True, use a different process (updated package list) + :return: list of installed Distribution objects. + """ + if use_cmd: + raise NotImplementedError("use_cmd should be False.") # pragma: no cover + if skip is None: + try: + from pip._internal.utils.compat import stdlib_pkgs + + skip = stdlib_pkgs + except ImportError: # pragma: no cover + pass + try: + from pip._internal.metadata import get_default_environment + + return list( + map( + Distribution, + get_default_environment().iter_installed_distributions( + local_only=local_only, + skip=skip, + include_editables=include_editables, + editables_only=editables_only, + user_only=user_only, + ), + ) + ) + + except ImportError: # pragma: no cover + from pip._internal.utils.misc import get_installed_distributions as getd + + return list( + map( + Distribution, + getd( + local_only=local_only, + skip=skip, + include_editables=include_editables, + editables_only=editables_only, + user_only=user_only, + use_cmd=use_cmd, + ), + ) + ) + + +def get_packages_list(): + """ + calls ``pip list`` to retrieve the list of packages + """ + return get_installed_distributions(local_only=True) + + def list_of_installed_packages(): """ calls ``pip list`` to retrieve the list of packages @@ -541,10 +615,6 @@ def list_of_installed_packages(): C++ utilisée pour compiler Python. """ - from pyquickhelper.pycode.pip_helper import ( - get_packages_list, - ) # pylint: disable=C0415 - return get_packages_list() From d26bb8a85ef479760713931d0ad854aa5b4e0403 Mon Sep 17 00:00:00 2001 From: Xavier Dupre Date: Sat, 5 Aug 2023 18:01:08 +0200 Subject: [PATCH 07/12] add missing class --- teachpyx/faq/faq_python.py | 47 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/teachpyx/faq/faq_python.py b/teachpyx/faq/faq_python.py index 71dd1997..159db526 100644 --- a/teachpyx/faq/faq_python.py +++ b/teachpyx/faq/faq_python.py @@ -484,6 +484,53 @@ def __lt__(self, autre_instance): pass +class Distribution: + """ + Common interface for old and recent pip packages. + """ + + def __init__(self, dist): + self.dist = dist + + def __getattr__(self, attr): + if attr == "key": + if hasattr(self.__dict__["dist"], "key"): + return self.__dict__["dist"].key + return self.__dict__["dist"].canonical_name + if attr == "dist": + return self.__dict__["dist"] + if attr in { + "_get_metadata", + "requires", + "PKG_INFO", + "project_name", + "py_version", + "platform", + "extras", + }: + if hasattr(self.__dict__["dist"], attr): + return getattr(self.__dict__["dist"], attr) + try: + return getattr(self.__dict__["dist"]._dist, attr) + except AttributeError as e: + if attr == "project_name": + return getattr(self.__dict__["dist"]._dist, "name") + if attr == "py_version": + return getattr(self.__dict__["dist"]._dist, "version") + if attr in {"platform", "extras"}: + return None + raise AttributeError( + f"Unable to find {attr!r} in {dir(self.__dict__['dist']._dist)} or " + f"{dir(self.__dict__['dist'])}." + ) from e + try: + return getattr(self.__dict__["dist"], attr) + except AttributeError as e: + raise AttributeError( + f"Unable to find {attr!r} in {dir(self.__dict__['dist'])}." + ) from e + + def get_installed_distributions( local_only=True, skip=None, From 788e6dd77d50ad5afbcb799b58f0a852bc7d5f24 Mon Sep 17 00:00:00 2001 From: Xavier Dupre Date: Sat, 5 Aug 2023 18:11:11 +0200 Subject: [PATCH 08/12] modif --- teachpyx/faq/faq_python.py | 63 +++++++++++++++++++++++++++++++++++--- 1 file changed, 59 insertions(+), 4 deletions(-) diff --git a/teachpyx/faq/faq_python.py b/teachpyx/faq/faq_python.py index 159db526..9ffb4eb3 100644 --- a/teachpyx/faq/faq_python.py +++ b/teachpyx/faq/faq_python.py @@ -484,6 +484,23 @@ def __lt__(self, autre_instance): pass +class PQPipError(Exception): + """ + Any exception raised by one of the following function. + """ + + def __init__(self, *args): + """ + :param args: either a string 3 strings (cmd, out, err) + """ + if len(args) == 1: + Exception.__init__(self, args[0]) + else: + cmd, out, err = args + mes = f"CMD:\n{cmd}\nOUT:\n{out}\n[piperror]\n{err}" + Exception.__init__(self, mes) + + class Distribution: """ Common interface for old and recent pip packages. @@ -665,6 +682,48 @@ def list_of_installed_packages(): return get_packages_list() +def get_package_info(name=None, start=0, end=-1): + """ + Calls ``pip show`` to retrieve information about packages. + + :param name: name of he packages or None to get all of them in a list + :param start: start at package n (in list return by :func:`get_packages_list`) + :param end: end at package n, -1 for all + :return: dictionary or list of dictionaries + """ + from pip._internal.commands.show import search_packages_info + + if name is None: + res = [] + packs = get_packages_list() + if end == -1: + end = len(packs) # pragma: no cover + subp = packs[start:end] + if len(subp) == 0: + raise PQPipError( # pragma: no cover + "No package, start={0}, end={1}, len(subp)={2}, len(packs)={3}".format( + start, end, len(subp), len(packs) + ) + ) + for cp in subp: + pack = cp.project_name + info = get_package_info(pack) + res.append(info) + if len(res) == 0 and len(subp) > 0: + raise PQPipError( # pragma: no cover + f"Empty list, unexpected, start={start}, " + f"end={end}, len(subp)={len(subp)}" + ) + return res + + res = list(search_packages_info([name])) + if len(res) != 1: + raise PQPipError( # pragma: no cover + f"Unexpected number of results {len(res)} for {name}" + ) + return res[0] + + def information_about_package(name): """ Calls ``pip show`` to retrieve information about packages. @@ -719,10 +778,6 @@ def information_about_package(name): conda install """ - from pyquickhelper.pycode.pip_helper import ( - get_package_info, - ) # pylint: disable=C0415 - return get_package_info(name) From 8e20460708a2d05e18d60c4f901e0d9b03ca1b1c Mon Sep 17 00:00:00 2001 From: Xavier Dupre Date: Sat, 5 Aug 2023 18:24:12 +0200 Subject: [PATCH 09/12] ipython --- _doc/practice/exams/td_note_2016.ipynb | 2 +- requirements-dev.txt | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/_doc/practice/exams/td_note_2016.ipynb b/_doc/practice/exams/td_note_2016.ipynb index e98c4dec..764c79c6 100644 --- a/_doc/practice/exams/td_note_2016.ipynb +++ b/_doc/practice/exams/td_note_2016.ipynb @@ -551,7 +551,7 @@ } ], "source": [ - "from ipython.display import Image\n", + "from IPython.display import Image\n", "\n", "Image(\"exam2016_values.png\")" ] diff --git a/requirements-dev.txt b/requirements-dev.txt index 56368b18..0f04fbf4 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -4,6 +4,7 @@ blockdiag cloudpickle coverage furo +ipython jupyter matplotlib mutagen # mp3 From affc05d1e4e0d337e503e990daba21125c8251ca Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Xavier=20Dupr=C3=A9?= Date: Sat, 5 Aug 2023 23:58:04 +0200 Subject: [PATCH 10/12] notebook --- _doc/practice/exams/td_note_2021.ipynb | 328 ++++++++++++++++--------- 1 file changed, 216 insertions(+), 112 deletions(-) diff --git a/_doc/practice/exams/td_note_2021.ipynb b/_doc/practice/exams/td_note_2021.ipynb index f1d4dfdd..eb4cd6ac 100644 --- a/_doc/practice/exams/td_note_2021.ipynb +++ b/_doc/practice/exams/td_note_2021.ipynb @@ -15,12 +15,15 @@ "source": [ "## Exercice 1 : guérison\n", "\n", - "On commence par générer des données artificielles à partir de véritables données, disponible depuis le site [Données hospitalières relatives à l'épidémie de COVID-19](https://www.data.gouv.fr/fr/datasets/donnees-hospitalieres-relatives-a-lepidemie-de-covid-19/)." + "On commence par générer des données artificielles à partir de véritables données, disponible depuis le site [Données hospitalières relatives à l'épidémie de COVID-19](https://www.data.gouv.fr/fr/datasets/donnees-hospitalieres-relatives-a-lepidemie-de-covid-19/).\n", + "\n", + "* *rad* : personnes retournées à domicile (cumul)\n", + "* *dc* : personnes décédées (cumul)" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -93,7 +96,7 @@ "2020-03-22 4188 1251" ] }, - "execution_count": 3, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -111,7 +114,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -184,7 +187,7 @@ "4 2020-03-22 608.0 210.0" ] }, - "execution_count": 4, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -194,16 +197,119 @@ "diff.head()" ] }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "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", + "
jourraddc
11042023-03-27810.084.0
11052023-03-28966.077.0
11062023-03-291003.067.0
11072023-03-30736.071.0
11082023-03-311008.061.0
\n", + "
" + ], + "text/plain": [ + " jour rad dc\n", + "1104 2023-03-27 810.0 84.0\n", + "1105 2023-03-28 966.0 77.0\n", + "1106 2023-03-29 1003.0 67.0\n", + "1107 2023-03-30 736.0 71.0\n", + "1108 2023-03-31 1008.0 61.0" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "diff.tail()" + ] + }, { "cell_type": "markdown", "metadata": {}, "source": [ - "On convertit la date en jour de l'année puis on simule un loi exponentielle de paramètre 14 pour avoir la date de sortie." + "Les données sont parfois erronnées et corrigées. Bien que les séries soient cumulées, la différence censée être positive peut ne pas l'être. Même s'il faudrait se pencher un peu sur le problème pour corriger les données, dans notre cas, on ne tient pas compte des valeurs négatives." ] }, { "cell_type": "code", "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy\n", + "\n", + "diff[\"rad\"] = numpy.maximum(diff[\"rad\"], 0)\n", + "diff[\"dc\"] = numpy.maximum(diff[\"dc\"], 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On convertit la date en jour de l'année puis on simule un loi exponentielle de paramètre 14 pour avoir la date de sortie." + ] + }, + { + "cell_type": "code", + "execution_count": 5, "metadata": { "scrolled": false }, @@ -237,31 +343,31 @@ " \n", " \n", " 0\n", - " 39\n", + " 6\n", " 79\n", " 1\n", " \n", " \n", " 1\n", - " 71\n", + " 64\n", " 79\n", " 1\n", " \n", " \n", " 2\n", - " 58\n", + " 31\n", " 79\n", " 1\n", " \n", " \n", " 3\n", - " 79\n", + " 65\n", " 79\n", " 1\n", " \n", " \n", " 4\n", - " 53\n", + " 62\n", " 79\n", " 1\n", " \n", @@ -271,11 +377,11 @@ ], "text/plain": [ " entree sortie issue\n", - "0 39 79 1\n", - "1 71 79 1\n", - "2 58 79 1\n", - "3 79 79 1\n", - "4 53 79 1" + "0 6 79 1\n", + "1 64 79 1\n", + "2 31 79 1\n", + "3 65 79 1\n", + "4 62 79 1" ] }, "execution_count": 5, @@ -293,7 +399,13 @@ " for i in range(hosp.shape[0]):\n", " date = dt[i].dayofyear\n", " h = hosp.iloc[i, 1]\n", - " delay = rnd.exponential(mu, int(h))\n", + " try:\n", + " delay = rnd.exponential(mu, int(h))\n", + " except Exception as e:\n", + " print(hosp.shape, i)\n", + " print(hosp.iloc[i])\n", + " print(e)\n", + " raise e\n", " for j in range(delay.shape[0]):\n", " res.append([date - int(delay[j]), date, 1])\n", " h = hosp.iloc[i, 2]\n", @@ -309,7 +421,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -327,7 +439,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -423,7 +535,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -453,7 +565,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -484,7 +596,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -507,19 +619,17 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -532,19 +642,17 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -586,7 +694,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -604,7 +712,7 @@ " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -620,7 +728,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -638,7 +746,7 @@ " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])" ] }, - "execution_count": 14, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -665,7 +773,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -683,7 +791,7 @@ " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])" ] }, - "execution_count": 15, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -707,25 +815,25 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[0, 0, 0, 0, 0, 0, 1, 0, 1, 0],\n", - " [0, 0, 0, 0, 0, 0, 1, 0, 0, 1],\n", - " [1, 0, 0, 0, 0, 0, 1, 0, 1, 1],\n", - " [0, 1, 0, 1, 0, 0, 0, 0, 0, 0],\n", - " [1, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n", - " [0, 0, 1, 1, 0, 0, 1, 0, 1, 0],\n", - " [0, 0, 1, 0, 0, 0, 0, 1, 0, 0],\n", - " [0, 0, 1, 0, 0, 0, 1, 0, 0, 1],\n", - " [0, 0, 1, 0, 0, 0, 0, 1, 0, 0],\n", - " [0, 0, 0, 1, 0, 0, 0, 1, 0, 0]])" + "array([[0, 1, 0, 0, 0, 1, 1, 0, 0, 0],\n", + " [1, 1, 0, 1, 0, 0, 1, 1, 1, 0],\n", + " [0, 0, 0, 0, 0, 0, 0, 1, 0, 0],\n", + " [0, 0, 0, 0, 1, 0, 0, 0, 0, 1],\n", + " [0, 0, 0, 1, 0, 0, 1, 1, 1, 0],\n", + " [1, 0, 0, 0, 0, 1, 0, 0, 0, 0],\n", + " [1, 0, 0, 1, 1, 0, 0, 0, 0, 0],\n", + " [0, 0, 0, 0, 1, 1, 0, 0, 0, 1],\n", + " [0, 0, 0, 0, 1, 1, 0, 0, 0, 0],\n", + " [0, 0, 1, 0, 1, 0, 1, 0, 1, 0]])" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -738,7 +846,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -748,15 +856,15 @@ " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n", - " [0., 0., 0., 0., 1., 1., 1., 0., 0., 0.],\n", - " [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 1., 1., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])" ] }, - "execution_count": 17, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } @@ -785,7 +893,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -793,17 +901,17 @@ "text/plain": [ "array([[0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n", - " [0., 0., 0., 0., 1., 1., 0., 0., 0., 0.],\n", - " [0., 0., 0., 0., 1., 1., 1., 1., 0., 0.],\n", - " [0., 0., 1., 1., 1., 1., 1., 1., 1., 0.],\n", - " [0., 0., 0., 0., 1., 1., 0., 1., 0., 0.],\n", " [0., 0., 0., 0., 1., 1., 1., 0., 0., 0.],\n", - " [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 1., 1., 1., 0., 0.],\n", + " [0., 0., 0., 0., 1., 1., 0., 0., 0., 0.],\n", + " [0., 0., 0., 1., 1., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", + " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])" ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -827,7 +935,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -859,72 +967,72 @@ " \n", " 0\n", " 0.70\n", - " 9.1\n", + " 13.5\n", " \n", " \n", " 1\n", " 0.80\n", - " 9.6\n", + " 11.6\n", " \n", " \n", " 2\n", " 0.85\n", - " 3.8\n", + " 2.6\n", " \n", " \n", " 3\n", " 0.86\n", - " 2.4\n", + " 1.8\n", " \n", " \n", " 4\n", " 0.87\n", - " 2.4\n", + " 2.3\n", " \n", " \n", " 5\n", " 0.88\n", - " 1.4\n", + " 2.3\n", " \n", " \n", " 6\n", " 0.89\n", - " 1.6\n", + " 1.2\n", " \n", " \n", " 7\n", " 0.90\n", - " 1.2\n", + " 2.5\n", " \n", " \n", " 8\n", " 0.94\n", - " 1.2\n", + " 1.6\n", " \n", " \n", " 9\n", " 0.95\n", - " 1.5\n", + " 1.4\n", " \n", " \n", " 10\n", " 0.96\n", - " 1.0\n", + " 1.4\n", " \n", " \n", " 11\n", " 0.97\n", - " 1.2\n", + " 1.1\n", " \n", " \n", " 12\n", " 0.98\n", - " 1.2\n", + " 1.1\n", " \n", " \n", " 13\n", " 0.99\n", - " 1.1\n", + " 1.0\n", " \n", " \n", " 14\n", @@ -937,24 +1045,24 @@ ], "text/plain": [ " p prop\n", - "0 0.70 9.1\n", - "1 0.80 9.6\n", - "2 0.85 3.8\n", - "3 0.86 2.4\n", - "4 0.87 2.4\n", - "5 0.88 1.4\n", - "6 0.89 1.6\n", - "7 0.90 1.2\n", - "8 0.94 1.2\n", - "9 0.95 1.5\n", - "10 0.96 1.0\n", - "11 0.97 1.2\n", - "12 0.98 1.2\n", - "13 0.99 1.1\n", + "0 0.70 13.5\n", + "1 0.80 11.6\n", + "2 0.85 2.6\n", + "3 0.86 1.8\n", + "4 0.87 2.3\n", + "5 0.88 2.3\n", + "6 0.89 1.2\n", + "7 0.90 2.5\n", + "8 0.94 1.6\n", + "9 0.95 1.4\n", + "10 0.96 1.4\n", + "11 0.97 1.1\n", + "12 0.98 1.1\n", + "13 0.99 1.0\n", "14 1.00 1.0" ] }, - "execution_count": 19, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -997,19 +1105,17 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1029,7 +1135,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -1038,7 +1144,7 @@ "0.9999" ] }, - "execution_count": 21, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1051,7 +1157,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -1061,19 +1167,17 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1088,14 +1192,14 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": {}, "outputs": [], "source": [] @@ -1103,7 +1207,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1117,7 +1221,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.2" + "version": "3.11.4" } }, "nbformat": 4, From 7cb5afc5792f3ed8c7e809bfa3c42759dce8152d Mon Sep 17 00:00:00 2001 From: Xavier Dupre Date: Sat, 5 Aug 2023 19:11:00 +0200 Subject: [PATCH 11/12] requirement --- requirements-dev.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements-dev.txt b/requirements-dev.txt index 0f04fbf4..17494d65 100644 --- a/requirements-dev.txt +++ b/requirements-dev.txt @@ -6,6 +6,7 @@ coverage furo ipython jupyter +lifelines matplotlib mutagen # mp3 nbsphinx From da87dd491ee97430ab362044c8e43adb7ac2903f Mon Sep 17 00:00:00 2001 From: Xavier Dupre Date: Sat, 5 Aug 2023 19:17:18 +0200 Subject: [PATCH 12/12] change index --- _doc/i_ex.rst | 8 -------- _doc/index.rst | 15 ++++++++++++++- 2 files changed, 14 insertions(+), 9 deletions(-) diff --git a/_doc/i_ex.rst b/_doc/i_ex.rst index b217bbb9..e65d57b1 100644 --- a/_doc/i_ex.rst +++ b/_doc/i_ex.rst @@ -3,14 +3,6 @@ Tous les exemples ================= -Code -==== - -.. toctree:: - - auto_examples/index - api/index - Définitions =========== diff --git a/_doc/index.rst b/_doc/index.rst index 85560152..f3b8fd83 100644 --- a/_doc/index.rst +++ b/_doc/index.rst @@ -17,15 +17,28 @@ pas ou eu programmer. Le contenu est disponible sur .. toctree:: :maxdepth: 1 + :caption: Lectures introduction py/index - practice/index c_data/index c_resume/index articles/index + +.. toctree:: + :maxdepth: 1 + :caption: Exercices + + practice/index + auto_examples/index + api/index i_ex i_faq + +.. toctree:: + :maxdepth: 1 + :caption: Compléments + license CHANGELOGS