def test_auc_file(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")

        ans = [1, 1, 1, 1, 1, 0, 0, 0, 0]
        score = [i * 0.8 + 0.1 for i in ans]
        score[0] = 0.4
        score[-1] = 0.6
        fLOG(score)
        t1 = get_temp_folder(__file__, "temp_answers")
        t2 = get_temp_folder(__file__, "temp_scores")
        f1 = "answer.txt"
        f2 = "answer.txt"
        fu1 = os.path.join(t1, f1)
        fu2 = os.path.join(t2, f2)
        out = os.path.join(t2, "scores.txt")
        with open(fu1, "w") as f:
            f.write("\n".join(str(_) for _ in ans))
        with open(fu2, "w") as f:
            f.write("\n".join(str(_) for _ in score))
        private_codalab_wrapper_binary_classification(
            AUC, "AUC", t1, t2, output=out)
        assert os.path.exists(out)
        with open(out, "r") as f:
            code = f.read()
        fLOG("**", code)

        self.assertEqual(code, "AUC:0.95")

    def test_encrypt_decrypt(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")

        password = "unittest" * 2

        temp = get_temp_folder(__file__, "temp_encrypt")
        temp2 = get_temp_folder(__file__, "temp_encrypt2")
        tempmm = get_temp_folder(__file__, "temp_encrypt_status")
        cstatus = os.path.join(tempmm, "crypt_status.txt")
        cmap = os.path.join(tempmm, "crypt_map.txt")
        srcf = os.path.abspath(os.path.join(temp, ".."))
        sys.argv = ["", srcf, temp, password,
                    "--status", cstatus,
                    "--map", cmap]
        encrypt(fLOG=fLOG)
        this = __file__

        sys.argv = ["", temp, temp2, password]
        decrypt(fLOG=fLOG)

        with open(__file__, "rb") as f:
            c1 = f.read()
        with open(os.path.join(temp2, os.path.split(this)[-1]), "rb") as f:
            c2 = f.read()

        self.assertEqual(c1, c2)
        fLOG("end")

    def test_install_revealjs(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")

        temp = get_temp_folder(__file__, "temp_install_revealjs")
        dest = get_temp_folder(__file__, "temp_install_revealjs_dest")
        fs = download_revealjs(temp, dest, fLOG=fLOG)
        fLOG(fs)
        assert len(fs) > 0
        for a in fs:
            assert os.path.exists(a)

    def test_rst_only(self):
        from docutils import nodes as skip_

        content = """
                    test a directive
                    ================

                    .. only:: html

                        only for html

                    .. only:: rst

                        only for rst

                    """.replace("                    ", "")
        if sys.version_info[0] >= 3:
            content = content.replace('u"', '"')

        tives = [("cmdref", CmdRef, cmdref_node,
                  visit_cmdref_node, depart_cmdref_node)]

        text = rst2html(content,  # fLOG=fLOG,
                        writer="rst", keep_warnings=True,
                        directives=tives, extlinks={'issue': ('http://%s', '_issue_')})

        temp = get_temp_folder(__file__, "temp_only")
        with open(os.path.join(temp, "out_cmdref.rst"), "w", encoding="utf8") as f:
            f.write(text)

        t1 = "only for rst"
        if t1 not in text:
            raise Exception(text)
        t1 = "only for html"
        if t1 in text:
            raise Exception(text)

        text = rst2html(content,  # fLOG=fLOG,
                        writer="html", keep_warnings=True,
                        directives=tives, extlinks={'issue': ('http://%s', '_issue_')})

        temp = get_temp_folder(__file__, "temp_only")
        with open(os.path.join(temp, "out_cmdref.rst"), "w", encoding="utf8") as f:
            f.write(text)

        t1 = "only for rst"
        if t1 in text:
            raise Exception(text)
        t1 = "only for html"
        if t1 not in text:
            raise Exception(text)

    def test_auc_multi_file(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")

        t1 = get_temp_folder(__file__, "temp_multi_answers")
        t2 = get_temp_folder(__file__, "temp_multi_scores")
        t3 = get_temp_folder(__file__, "temp_multi_scores2")
        truth = os.path.join(
            t1, "..", "data", "tbl_test_dossier.Y.dummy.truth.txt")
        ans = os.path.join(t1, "..", "data", "tbl_test_dossier.Y.dummy.txt")
        f1 = "answer.txt"
        f2 = "answer.txt"
        shutil.copy(truth, os.path.join(t1, f1))
        shutil.copy(ans, os.path.join(t2, f2))

        with open(truth, "r") as f:
            lines = [_.strip("\r\n ").split("\t") for _ in f.readlines()]
        lines = [[l[0], l[1], "1.0", "1.0"] for l in lines]
        f3 = "answer.txt"
        with open(os.path.join(t3, f3), "w") as f:
            f.write("\n".join("\t".join(_) for _ in lines))

        temp = get_temp_folder(__file__, "temp_multi_out")

        # =
        out = os.path.join(temp, "outpute.txt")
        private_codalab_wrapper_multi_classification(AUC_multi_multi,
                                                     ["orientation", "nature"],
                                                     t1, t3, output=out)
        assert os.path.exists(out)
        with open(out, "r") as f:
            code = f.read()

        self.assertEqual(
            code, "orientation_ERR:0.0\norientation_AUC:1.0\nnature_ERR:0.0\nnature_AUC:1.0")

        # dummy
        fLOG("------------ dummy")
        out = os.path.join(temp, "outputd.txt")
        private_codalab_wrapper_multi_classification(AUC_multi_multi,
                                                     ["orientation", "nature"],
                                                     t1, t2, output=out, ignored=["nul"])
        assert os.path.exists(out)
        with open(out, "r") as f:
            code = f.read()
        fLOG("**", code)

        self.assertEqual(
            code, "orientation_ERR:0.7183754333828628\norientation_AUC:0.5862428771453444\nnature_ERR:0.8236750866765725\nnature_AUC:0.5160556240766593")

    def test_notebook_runner_2a_ml(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")
        from ensae_teaching_cs.automation.notebook_test_helper import ls_notebooks, execute_notebooks, clean_function_1a
        from ensae_teaching_cs.data import simple_database
        temp = get_temp_folder(__file__, "temp_notebook2a_ml4")
        keepnote = ls_notebooks("td2a_ml")
        keepnote = [_ for _ in keepnote if "overfitting" in _]
        shutil.copy(simple_database(), temp)

        def filter(i, n):
            if "SNCF" in n:
                return False
            if "Scraping" in n:
                return False
            if "deep_python" in n:
                return False
            if "h2o" in n:
                # h2o is not working from a virtual environment
                return False
            if "td2a" in os.path.split(n)[-1]:
                # already tested by others tests
                return False
            if "libraries" in n:
                return False
            return True

        execute_notebooks(temp, keepnote, filter, fLOG=fLOG,
                          clean_function=clean_function_1a,
                          dump=ensae_teaching_cs)

    def test_join_multiple2(self):
        fLOG(__file__, self._testMethodName, OutputPrint=__name__ == "__main__")
        filename = os.path.join(os.path.split(
            __file__)[0], "data", "database_linked.zip")
        temp = get_temp_folder(__file__, "temp_join_multiple2")
        filename = unzip(filename, temp)
        assert os.path.exists(filename)

        db = Database(filename, LOG=fLOG)
        db.connect()

        where = {"bucket": ("==", "bu###1")}
        n1 = db.JoinTreeNode("profile_QSSH", where=where,
                             parent_key="query", key="query")
        n2 = db.JoinTreeNode("url_QSSH", where=where,
                             parent_key=('url', 'pos'), key=('url', 'pos'))
        n1.append(n2)

        sql, fields = db.inner_joins(n1, execute=False, create_index=False)

        view = db.execute_view(sql)
        assert view == [('facebbooklogin', 1, 0, 'bu###1', 86, 0,
                         'digg.com/security/Hackers_Put_Social_Networks_In_Crosshairs',
                         'digg.com/security/Hackers_Put_Social_Networks_In_Crosshairs',
                         1, 0, 1, 1, 0, 0, 0, 0)]
        assert "WHERE" in sql

        db.close()

    def test_folium(self):
        temp = get_temp_folder(__file__, "temp_folium")
        outfile = os.path.join(temp, "osm.map")

        map_osm = folium.Map(location=[48.85, 2.34])
        map_osm.save(outfile=outfile)
        self.assertTrue(os.path.exists(outfile))

    def test_notebook_js(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")
        path = os.path.abspath(os.path.split(__file__)[0])
        fold = os.path.normpath(os.path.join(path, "notebooks_js"))
        nbs = [os.path.join(fold, _)
               for _ in os.listdir(fold) if ".ipynb" in _]
        formats = ["slides", "present", "ipynb", "html",
                   "python", "rst", "pdf"]
        if sys.platform.startswith("win"):
            formats.append("docx")

        temp = get_temp_folder(__file__, "temp_nb_bug_js")

        res = process_notebooks(nbs, temp, temp, formats=formats)
        fLOG("*****", len(res))
        for _ in res:
            if not os.path.exists(_[0]):
                raise Exception(_[0])

        check = os.path.join(temp, "using_qgrid_with_jsdf.tex")
        with open(check, "r", encoding="utf8") as f:
            content = f.read()
        if "\\section{" not in content:
            raise Exception(content)
        checks = [os.path.join(temp, "reveal.js"),
                  os.path.join(temp, "require.js")]
        for check in checks:
            if not os.path.exists(check):
                raise Exception(check)

    def test_sphinx_ext_video_latex(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")

        temp = get_temp_folder(__file__, "temp_sphinx_ext_video_latex")

        fLOG('custom app init')
        src_ = self.setup_format(temp)
        app = CustomSphinxApp(src_, temp, buildername="latex")
        fLOG('custom app build')
        app.build()
        fLOG('custom app done')

        index = os.path.join(temp, "pyq-video.tex")
        self.assertExists(index)
        with open(index, "r", encoding="utf-8") as f:
            content = f.read()
        self.assertNotIn("unable to find", content)
        self.assertIn('mur.mp4}', content)
        index = os.path.join(temp, "mur.mp4")
        self.assertExists(index)
        index = os.path.join(temp, "jol", "mur2.mp4")
        self.assertExists(index)
        index = os.path.join(temp, "jol", 'im', "mur3.mp4")
        self.assertExists(index)

        if is_travis_or_appveyor() not in ('travis', 'appveyor'):
            latex = find_latex_path()
            fLOG("latex-compile", latex)
            compile_latex_output_final(temp, latex, doall=True)
            fLOG("compilatione done")
            index = os.path.join(temp, "pyq-video.pdf")
            self.assertExists(index)

    def test_example_pydy(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")

        temp = get_temp_folder(__file__, "temp_example_pydy")
        fix_tkinter_issues_virtualenv()
        import matplotlib.pyplot as plt
        fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8, 8))
        try:
            example_pydy(ax=ax)
        except Exception as e:
            if 'can only concatenate list (not "tuple") to list' in str(e):
                warnings.warn("Pydy needs to be updated for Python 3.7")
                return
            else:
                raise e
        self.assertNotEmpty(ax)
        img = os.path.join(temp, "img.png")
        fig.savefig(img)
        self.assertExists(img)
        if __name__ == "__main__":
            fig.show()
        plt.close('all')
        fLOG("end")

    def test_notebook_raw(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")
        path = os.path.abspath(os.path.split(__file__)[0])
        fold = os.path.normpath(os.path.join(path, "data"))
        nbs = [os.path.join(fold, _)
               for _ in os.listdir(fold) if "TD_2A" in _]
        self.assertGreater(len(nbs), 0)
        formats = ["latex", "present", "ipynb", "html",
                   "python", "rst", "pdf"]
        if sys.platform.startswith("win"):
            formats.append("docx")

        temp = get_temp_folder(__file__, "temp_nb_bug_raw")

        if is_travis_or_appveyor() in ('travis', 'appveyor'):
            return

        res = process_notebooks(nbs, temp, temp, formats=formats)
        fLOG("*****", len(res))
        for _ in res:
            fLOG(_)
            self.assertExists(_[0])

        check = os.path.join(temp, "TD_2A_Eco_Web_Scraping.tex")
        with open(check, "r", encoding="utf8") as f:
            content = f.read()
        if "\\begin{verbatim" not in content:
            raise Exception(content)

    def test_profiling(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")

        temp = get_temp_folder(__file__, "temp_profiling")
        data = os.path.join(temp, "..", "data", "sample1000.txt")
        with open(data, "r", encoding="utf-8") as f:
            lines = [_.strip(" \n\r\t") for _ in f.readlines()]

        def profile_exe():
            res = self.gain_dynamique_moyen_par_mot(lines, [1.0] * len(lines))
            return res

        def prof(n, show):
            pr = cProfile.Profile()
            pr.enable()
            profile_exe()
            pr.disable()
            s = io.StringIO()
            ps = pstats.Stats(pr, stream=s).sort_stats('cumulative')
            ps.print_stats()
            rem = os.path.normpath(os.path.join(temp, "..", "..", ".."))
            res = s.getvalue().replace(rem, "")
            if show:
                fLOG(res)
            with open(os.path.join(temp, "profiling%d.txt" % n), "w") as f:
                f.write(res)
        prof(1, show=False)
        prof(2, show=True)

    def a_test_notebook_runner(self, name, folder, valid=None, copy_folder=None):
        temp = get_temp_folder(__file__, "temp_notebook_123_{0}".format(name))
        doc = os.path.join(temp, "..", "..", "..", "_doc", "notebooks", folder)
        if not os.path.exists(doc):
            raise FileNotFoundError(doc)
        keepnote = [os.path.join(doc, _) for _ in os.listdir(doc) if name in _]
        self.assertTrue(len(keepnote) > 0)

        if copy_folder is not None:
            if not os.path.exists(copy_folder):
                raise FileNotFoundError(copy_folder)
            dest = os.path.split(copy_folder)[-1]
            dest = os.path.join(temp, dest)
            if not os.path.exists(dest):
                os.mkdir(dest)
            synchronize_folder(copy_folder, dest, fLOG=fLOG)

        import pyquickhelper
        import jyquickhelper
        import pyensae
        import ensae_teaching_cs
        add_path = get_additional_paths(
            [jyquickhelper, pyquickhelper, pyensae, ensae_teaching_cs])
        res = execute_notebook_list(
            temp, keepnote, additional_path=add_path, valid=valid)
        execute_notebook_list_finalize_ut(
            res, fLOG=fLOG, dump=ensae_teaching_cs)

    def test_module_c(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")
        path = os.path.abspath(os.path.split(__file__)[0])
        file = os.path.join(path, "data", "pyd",
                            "stdchelper.cp37-win_amd64.pyd")
        self.assertExists(file)
        mo = import_module(
            None, file, fLOG, additional_sys_path=None, first_try=True)
        self.assertIsInstance(mo, tuple)
        self.assertEqual(len(mo), 2)
        self.assertTrue(hasattr(mo[0], '__doc__'))
        if 'stdchelper' in sys.modules:
            del sys.modules['stdchelper']

        temp = get_temp_folder(__file__, "temp_module_c")
        store_obj = {}
        actions = copy_source_files(os.path.dirname(file), temp, fLOG=fLOG)
        store_obj = {}
        indexes = {}
        add_file_rst(temp, store_obj, actions, fLOG=fLOG,
                     rootrep=("module_c.", ""), indexes=indexes)
        self.assertNotEmpty(store_obj)
        self.assertEqual(len(store_obj), 4)
        if len(actions) != 2:
            raise Exception("{0}\n{1}".format(
                len(actions), "\n".join(str(_) for _ in actions)))
        self.assertEqual(len(indexes), 1)

    def test_image_video_epidemic(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")
        temp = get_temp_folder(__file__, "temp_image_video_epidemic")

        if is_travis_or_appveyor() in ("travis",):
            # pygame.error: No available video device
            return
        import pygame
        if is_travis_or_appveyor() == "circleci":
            # os.environ["SDL_VIDEODRIVER"] = "x11"
            flags = pygame.NOFRAME
        else:
            flags = 0

        pygame_simulation(pygame, fLOG=fLOG, iter=10, folder=temp, flags=flags)
        files = os.listdir(temp)
        self.assertTrue(len(files) > 9)
        png = [os.path.join(temp, _)
               for _ in files if os.path.splitext(_)[-1] == ".png"]
        self.assertTrue(len(png) > 0)
        out = os.path.join(temp, "epidemic.avi")

        v = make_video(png, out, size=(300, 300), format="XVID")
        self.assertTrue(v is not None)

    def test_notebook_rst_svg(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")
        temp = get_temp_folder(__file__, "temp_nb_rst_svg")
        nbs = [os.path.normpath(os.path.join(
            temp, '..', "data", "rst_notebooks", "notebook_with_svg.ipynb"))]
        formats = ["rst"]

        res = process_notebooks(nbs, temp, temp, formats=formats, fLOG=fLOG)
        name = res[0][0]
        with open(name, 'r', encoding='utf-8') as f:
            content = f.read()
        self.assertIn('SVG in a notebook.', content)
        self.assertIn('.. image::', content)

        nb = 0
        for line in content.split('\n'):
            if '.. image::' in line:
                name = line.replace('.. image::', '').strip(' \r\t')
                dest = os.path.join(temp, name)
                self.assertExists(dest)
                nb += 1
        self.assertGreater(nb, 0)

    def test_status(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")

        if is_travis_or_appveyor() == "travis":
            warnings.warn("run_cmd no end on travis")
            return
        temp = get_temp_folder(__file__, "temp_status")
        outfile = os.path.join(temp, "modules.xlsx")
        this = os.path.abspath(os.path.dirname(__file__))
        script = os.path.normpath(os.path.join(
            this, "..", "..", "src", "pymyinstall", "cli", "pymy_status.py"))
        cmd = "{0} -u {1} {2}".format(
            sys.executable, script, "numpy --out={0}".format(outfile))
        fLOG(cmd)
        out, err = run_cmd(cmd, wait=True)
        if len(out) == 0:
            if is_travis_or_appveyor() == "appveyor":
                warnings.warn(
                    "CLI ISSUE cmd:\n{0}\nOUT:\n{1}\nERR\n{2}".format(cmd, out, err))
                return
            else:
                raise Exception(
                    "cmd:\n{0}\nOUT:\n{1}\nERR\n{2}".format(cmd, out, err))
        if len(err) > 0:
            raise Exception(
                "cmd:\n{0}\nOUT:\n{1}\nERR\n{2}".format(cmd, out, err))
        if not os.path.exists(outfile):
            raise Exception(outfile)
        fLOG(out)

    def test_download_zip(self):
        fLOG(
            __file__,
            self._testMethodName,
            OutputPrint=__name__ == "__main__")
        fold = get_temp_folder(__file__, "temp_download")
        url = "https://docs.python.org/3/library/ftplib.html"
        f = download(url, fold)
        fLOG(f)
        self.assertTrue(os.path.exists(f))
        if not f.endswith("ftplib.html"):
            raise Exception(f)

        out1 = os.path.join(fold, "try.html.gz")
        gzip_files(out1, [f], fLOG=fLOG)
        self.assertTrue(os.path.exists(out1))

        out2 = os.path.join(fold, "try.zip")
        zip_files(out2, [f], fLOG=fLOG)
        self.assertTrue(os.path.exists(out2))

        if is_travis_or_appveyor() in ("circleci", None):
            out7 = os.path.join(fold, "try.7z")
            zip7_files(out7, [out1, out2], fLOG=fLOG, temp_folder=fold)
            if not os.path.exists(out7):
                raise FileNotFoundError(out7)
        else:
            fLOG("skip 7z")

    def test_post_list(self):
        # the test will fail if you add a file in data/blog others
        # with rst files which is not a blog post

        directives.register_directive("blogpost", BlogPostDirective)

        path = os.path.abspath(os.path.split(__file__)[0])
        fold = os.path.join(path, "data", "blog")
        out = get_temp_folder(__file__, "temp_post_list")
        p = BlogPostList(fold)
        cats = p.get_categories()
        months = p.get_months()
        self.assertEqual(cats, ['documentation', 'example'])
        self.assertEqual(months, ['2015-04'])

        res = p.write_aggregated(out)
        self.assertTrue(len(res) >= 4)
        for r in res:
            if r in (None, ''):
                raise ValueError("An empty value in {0}".format(res))
            if not os.path.exists(r):
                raise FileNotFoundError("Unable to find '{0}'".format(r))
            if 'main_0000.rst' in r:
                with open(r, 'r', encoding='utf-8') as f:
                    content = f.read()
                self.assertIn('...', content)