def load_jupyter_server_extension(nbapp):
    """Load the nbserver"""
    windows = sys.platform.startswith('win')
    webapp = nbapp.web_app
    webapp.settings['example_manager'] = Examples(parent=nbapp)
    base_url = webapp.settings['base_url']

    install_nbextension(static, destination='nbexamples', symlink=not windows,
                        user=True)
    cfgm = nbapp.config_manager
    cfgm.update('tree', {
        'load_extensions': {
            'nbexamples/main': True,
        }
    })
    cfgm.update('notebook', {
        'load_extensions': {
            'nbexamples/submit-example-button': True,
        }
    })

    ExampleActionHandler.base_url = base_url  # used to redirect after fetch
    webapp.add_handlers(".*$", [
        (ujoin(base_url, pat), handler)
        for pat, handler in default_handlers
    ])

 def test_create_nbextensions_user(self):
     with TemporaryDirectory() as td:
         install_nbextension(self.src, user=True)
         self.assert_installed(
             pjoin(basename(self.src), u'ƒile'),
             user=True
         )

def load_jupyter_server_extension(nbapp):
    """Load the nbserver"""
    windows = sys.platform.startswith('win')
    webapp = nbapp.web_app
    webapp.settings['shared_manager'] = SharedManager(parent=nbapp)
    base_url = webapp.settings['base_url']

    install_nbextension(static, destination='nbshared', symlink=not windows, user=True)

    # cfgm = nbapp.config_manager
    # cfgm.update('tree', {
    #     'load_extensions': {
    #         'nbexamples/main': True,
    #     }
    # })
    # cfgm.update('notebook', {
    #     'load_extensions': {
    #         'nbexamples/submit-example-button': True,
    #     }
    # })

    webapp.add_handlers(".*$", [
        (ujoin(base_url, pat), handler)
        for pat, handler in default_handlers
    ])

 def setup_extensions(self, CUR_EXT, EXT_DIR, DIR):
     # Install the extensions to the required directories
     ensure_dir_exists(DIR)
     if os.path.exists(CUR_EXT):
         question = "ACTION: The Stepsize extension directory already " \
                    "exists, do you want to overwrite %s with the " \
                    "current installation?" % (CUR_EXT)
         prompt = self.query(question)
         if prompt == "yes":
             try:
                 install_nbextension(EXT_DIR, overwrite=True,
                                     nbextensions_dir=DIR)
                 print("OUTCOME: Added the extension to your "
                       "%s directory" % (DIR))
             except:
                 print("WARNING: Unable to install the extension to your "
                       "(nb)extensions folder")
                 print("ERROR: %s" % (sys.exc_info()[0]))
                 raise
         else:
             return
     else:
         try:
             install_nbextension(EXT_DIR, overwrite=True,
                                 nbextensions_dir=DIR)
             print("OUTCOME: Added the extension to your %s directory"
                   % (DIR))
         except:
             print("WARNING: Unable to install the extension to your "
                   "(nb)extensions folder")
             print("ERROR: %s" % (sys.exc_info()[0]))
             raise

def install(user=False, symlink=False, quiet=False, enable=False):
    """Install the widget nbextension and optionally enable it.
    
    Parameters
    ----------
    user: bool
        Install for current user instead of system-wide.
    symlink: bool
        Symlink instead of copy (for development).
    enable: bool
        Enable the extension after installing it.
    quiet: bool
        Suppress print statements about progress.
    """
    if not quiet:
        print("Installing nbextension ...")
    staticdir = pjoin(dirname(abspath(__file__)), "static")
    install_nbextension(staticdir, destination="widgets", user=user, symlink=symlink)

    if enable:
        if not quiet:
            print("Enabling the extension ...")
        cm = ConfigManager()
        cm.update("notebook", {"load_extensions": {"widgets/extension": True}})
    if not quiet:
        print("Done.")

def _install_notebook_extension():
    print('Installing notebook extension')
    install_nbextension(EXT_DIR, overwrite=True, user=True)
    cm = ConfigManager()
    print('Enabling extension for notebook')
    cm.update('notebook', {"load_extensions": {'urth_cms_js/notebook/main': True}})
    print('Enabling extension for dashboard')
    cm.update('tree', {"load_extensions": {'urth_cms_js/dashboard/main': True}})
    print('Enabling extension for text editor')
    cm.update('edit', {"load_extensions": {'urth_cms_js/editor/main': True}})
    print('Enabling notebook and associated files bundler')
    cm.update('notebook', { 
      'jupyter_cms_bundlers': {
        'notebook_associations_download': {
          'label': 'IPython Notebook bundle (.zip)',
          'module_name': 'urth.cms.nb_bundler',
          'group': 'download'
        }
      }
    })

    print('Installing notebook server extension')
    fn = os.path.join(jupyter_config_dir(), 'jupyter_notebook_config.py')
    with open(fn, 'r+') as fh:
        lines = fh.read()
        if SERVER_EXT_CONFIG not in lines:
            fh.seek(0, 2)
            fh.write('\n')
            fh.write(SERVER_EXT_CONFIG)

def install(user=False, symlink=False, overwrite=False, enable=False,
            **kwargs):
    """Install the nbpresent nbextension.

    Parameters
    ----------
    user: bool
        Install for current user instead of system-wide.
    symlink: bool
        Symlink instead of copy (for development).
    overwrite: bool
        Overwrite previously-installed files for this extension
    enable: bool
        Enable the extension on every notebook launch
    **kwargs: keyword arguments
        Other keyword arguments passed to the install_nbextension command
    """
    print("Installing nbpresent nbextension...")
    directory = join(dirname(abspath(__file__)), 'static', 'nbpresent')
    install_nbextension(directory, destination='nbpresent',
                        symlink=symlink, user=user, overwrite=overwrite,
                        **kwargs)

    if enable:
        print("Enabling nbpresent at every notebook launch...")
        cm = ConfigManager()
        cm.update('notebook',
                  {"load_extensions": {"nbpresent/nbpresent.min": True}})

def enable_notebook():
    """Enable IPython notebook widgets to be displayed.

    This function should be called before using TrajectoryWidget.
    """
    display(_REQUIRE_CONFIG)
    staticdir =  resource_filename('mdview', os.path.join('html', 'static'))
    install_nbextension(staticdir, destination='mdview', user=True)

 def test_single_dir_trailing_slash(self):
     d = u'∂ir/'
     install_nbextension(pjoin(self.src, d))
     self.assert_installed(self.files[-1])
     if os.name == 'nt':
         d = u'∂ir\\'
         install_nbextension(pjoin(self.src, d))
         self.assert_installed(self.files[-1])

def install(config_dir, use_symlink=False, enable=True):
    # Install the livereveal code.
    install_nbextension(livereveal_dir, symlink=use_symlink,
                        overwrite=use_symlink, user=True)

    if enable:
        cm = ConfigManager(config_dir=config_dir)
        cm.update('notebook', {"load_extensions": {"livereveal/main": True}})

 def test_create_nbextensions_user(self):
     with TemporaryDirectory() as td:
         self.data_dir = pjoin(td, u'jupyter_data')
         install_nbextension(self.src, user=True)
         self.assert_installed(
             pjoin(basename(self.src), u'ƒile'),
             user=True
         )

 def test_quiet(self):
     stdout = StringIO()
     stderr = StringIO()
     with patch.object(sys, 'stdout', stdout), \
          patch.object(sys, 'stderr', stderr):
         install_nbextension(self.src, verbose=0)
     self.assertEqual(stdout.getvalue(), '')
     self.assertEqual(stderr.getvalue(), '')

 def test_install_zip(self):
     path = pjoin(self.src, "myjsext.zip")
     with zipfile.ZipFile(path, 'w') as f:
         f.writestr("a.js", b"b();")
         f.writestr("foo/a.js", b"foo();")
     install_nbextension(path)
     self.assert_installed("a.js")
     self.assert_installed(pjoin("foo", "a.js"))

def install(enable=False, **kwargs):
    """Install the nbpresent nbextension assets and optionally enables the
       nbextension and server extension for every run.

    Parameters
    ----------
    enable: bool
        Enable the extension on every notebook launch
    **kwargs: keyword arguments
        Other keyword arguments passed to the install_nbextension command
    """
    from notebook.nbextensions import install_nbextension
    from notebook.services.config import ConfigManager

    directory = join(dirname(abspath(__file__)), "static", "nbpresent")

    kwargs = {k: v for k, v in kwargs.items() if not (v is None)}

    kwargs["destination"] = "nbpresent"
    install_nbextension(directory, **kwargs)

    if enable:
        path = jupyter_config_dir()
        if "prefix" in kwargs:
            path = join(kwargs["prefix"], "etc", "jupyter")
            if not exists(path):
                print("Making directory", path)
                os.makedirs(path)

        cm = ConfigManager(config_dir=path)
        print("Enabling nbpresent server component in", cm.config_dir)
        cfg = cm.get("jupyter_notebook_config")
        print("Existing config...")
        pprint(cfg)
        server_extensions = cfg.setdefault("NotebookApp", {}).setdefault("server_extensions", [])
        if "nbpresent" not in server_extensions:
            cfg["NotebookApp"]["server_extensions"] += ["nbpresent"]

        cm.update("jupyter_notebook_config", cfg)
        print("New config...")
        pprint(cm.get("jupyter_notebook_config"))

        _jupyter_config_dir = jupyter_config_dir()
        # try:
        #     subprocess.call(["conda", "info", "--root"])
        #     print("conda detected")
        #     _jupyter_config_dir = ENV_CONFIG_PATH[0]
        # except OSError:
        #     print("conda not detected")

        cm = ConfigManager(config_dir=join(_jupyter_config_dir, "nbconfig"))
        print("Enabling nbpresent nbextension at notebook launch in", cm.config_dir)

        if not exists(cm.config_dir):
            print("Making directory", cm.config_dir)
            os.makedirs(cm.config_dir)

        cm.update("notebook", {"load_extensions": {"nbpresent/nbpresent.min": True}})

 def test_create_nbextensions_system(self):
     with TemporaryDirectory() as td:
         self.system_nbext = pjoin(td, u'nbextensions')
         with patch.object(nbextensions, 'SYSTEM_JUPYTER_PATH', [td]):
             install_nbextension(self.src, user=False)
             self.assert_installed(
                 pjoin(basename(self.src), u'ƒile'),
                 user=False
             )

 def test_install_destination_bad(self):
     with TemporaryDirectory() as d:
         zf = u'ƒ.zip'
         zsrc = pjoin(d, zf)
         with zipfile.ZipFile(zsrc, 'w') as z:
             z.writestr("a.js", b"b();")
     
         with self.assertRaises(ValueError):
             install_nbextension(zsrc, destination='foo')

 def test_install_symlink(self):
     with TemporaryDirectory() as d:
         f = u'ƒ.js'
         src = pjoin(d, f)
         touch(src)
         install_nbextension(src, symlink=True)
     dest = pjoin(self.system_nbext, f)
     assert os.path.islink(dest)
     link = os.readlink(dest)
     self.assertEqual(link, src)

 def test_check_nbextension(self):
     with TemporaryDirectory() as d:
         f = u'ƒ.js'
         src = pjoin(d, f)
         touch(src)
         install_nbextension(src, user=True)
     
     assert check_nbextension(f, user=True)
     assert check_nbextension([f], user=True)
     assert not check_nbextension([f, pjoin('dne', f)], user=True)

 def install(self):
     """
     Install an extension (copy or symlinks)
     """
     try:
         install_nbextension(self.kwargs['static'], **self._install_params())
         self._echo("Installing {}".format(self.name), 'ok')
     except Exception as e:
         self._echo(e, None)
         self._echo("Installing {}".format(self.name), 'fail')

 def run(self):
     _develop.run(self)
     install_nbextension(
         extension_dir,
         symlink=True,
         overwrite=True,
         user=False,
         sys_prefix=True,  # to install it inside virtualenv
         destination="robomission")
     cm = ConfigManager()
     cm.update('notebook', {"load_extensions": {"robomission/index": True } })