예제 #1
0
def load_jupyter_server_extension(nb_app):
    global logger
    global widgets_dir

    logger = nb_app.log
    logger.info('Loading urth_import server extension.')

    web_app = nb_app.web_app
    widgets_dir = get_nbextension_path()

    # Write out a .bowerrc file to configure bower installs to
    # not be interactive and not to prompt for analytics
    bowerrc = os.path.join(widgets_dir, '.bowerrc')
    if os.access(bowerrc, os.F_OK) is not True:
        logger.debug('Writing .bowerrc at {0}'.format(bowerrc))
        with open(bowerrc, 'a') as f:
            f.write("""{
            "analytics": false,
            "interactive": false,
            "directory": "urth_components"
            }""")

    # The import handler serves from /urth_import and any requests
    # containing /urth_components/ will get served from the actual
    # urth_components directory.
    import_route_pattern = url_path_join(web_app.settings['base_url'], '/urth_import')
    components_route_pattern = url_path_join(web_app.settings['base_url'], '/urth_components/(.*)')
    components_path = os.path.join(widgets_dir, 'urth_components/')

    # Register the Urth import handler and static file handler.
    logger.debug('Adding handlers for {0} and {1}'.format(import_route_pattern, components_route_pattern))
    web_app.add_handlers('.*$', [
        (import_route_pattern, UrthImportHandler, dict(executor=ThreadPoolExecutor(max_workers=1))),
        (components_route_pattern, FileFindHandler, {'path': [components_path]})
    ])
예제 #2
0
 def create_request_handlers(self):
     """Create default Jupyter handlers and redefine them off of the
     base_url path. Assumes init_configurables() has already been called.
     """
     handlers = []
     # append the activity monitor for websocket mode
     handlers.append((
         url_path_join('/', self.parent.base_url, r'/_api/activity'),
         ActivityHandler,
         {}
     ))
     # append tuples for the standard kernel gateway endpoints
     for handler in (
         default_api_handlers +
         default_kernel_handlers +
         default_kernelspec_handlers +
         default_session_handlers +
         default_base_handlers
     ):
         # Create a new handler pattern rooted at the base_url
         pattern = url_path_join('/', self.parent.base_url, handler[0])
         # Some handlers take args, so retain those in addition to the
         # handler class ref
         new_handler = tuple([pattern] + list(handler[1:]))
         handlers.append(new_handler)
     return handlers
예제 #3
0
    def get(self):
        if not self.request.uri.startswith(EXTENSION_URL):
            raise_error("URI did not start with " + EXTENSION_URL)
        spark_request = self.spark_host + self.request.uri[len(EXTENSION_URL):]

        try:
            spark_response = requests.get(spark_request)

            content_type = spark_response.headers['content-type']
            self.set_header("Content-Type", content_type)

            if "text" in content_type:
                # Replace all the relative links with our proxy links
                soup = BeautifulSoup(spark_response.text, "html.parser")

                for has_href in ['a', 'link']:
                    for a in soup.find_all(has_href):
                        if "href" in a.attrs:
                            a['href'] = url_path_join(self.web_app, a['href'])

                for has_src in ['img', 'script']:
                    for a in soup.find_all(has_src):
                        if "src" in a.attrs:
                            a['src'] = url_path_join(self.web_app, a['src'])

                client_response = str(soup)
            else:
                # Probably binary response, send it directly.
                client_response = spark_response.content

        except requests.exceptions.RequestException:
            client_response = json.dumps({"error": "SPARK_NOT_RUNNING"})

        self.write(client_response)
        self.flush()
예제 #4
0
def load_jupyter_server_extension(nb_server_app):

    # Extract our gist client details from the config:
    cfg = nb_server_app.config["NotebookApp"]
    BaseHandler.client_id = cfg["oauth_client_id"]
    BaseHandler.client_secret = cfg["oauth_client_secret"]

    web_app = nb_server_app.web_app
    host_pattern = '.*$'

    route_pattern = url_path_join(web_app.settings['base_url'], '/create_gist')

    download_notebook_route_pattern = url_path_join(
                                        web_app.settings['base_url'],
                                        '/download_notebook')

    load_user_gists_route_pattern = url_path_join(
                                        web_app.settings['base_url'],
                                        'load_user_gists')

    web_app.add_handlers(host_pattern,
                         [(route_pattern,
                           GistHandler),
                          (download_notebook_route_pattern,
                           DownloadNotebookHandler),
                          (load_user_gists_route_pattern,
                           LoadGistHandler)])
예제 #5
0
    def test_old_files_redirect(self):
        """pre-2.0 'files/' prefixed links are properly redirected"""
        nbdir = self.notebook_dir
        
        os.mkdir(pjoin(nbdir, 'files'))
        os.makedirs(pjoin(nbdir, 'sub', 'files'))
        
        for prefix in ('', 'sub'):
            with open(pjoin(nbdir, prefix, 'files', 'f1.txt'), 'w') as f:
                f.write(prefix + '/files/f1')
            with open(pjoin(nbdir, prefix, 'files', 'f2.txt'), 'w') as f:
                f.write(prefix + '/files/f2')
            with open(pjoin(nbdir, prefix, 'f2.txt'), 'w') as f:
                f.write(prefix + '/f2')
            with open(pjoin(nbdir, prefix, 'f3.txt'), 'w') as f:
                f.write(prefix + '/f3')

            url = url_path_join('notebooks', prefix, 'files', 'f1.txt')
            r = self.request('GET', url)
            self.assertEqual(r.status_code, 200)
            self.assertEqual(r.text, prefix + '/files/f1')

            url = url_path_join('notebooks', prefix, 'files', 'f2.txt')
            r = self.request('GET', url)
            self.assertEqual(r.status_code, 200)
            self.assertEqual(r.text, prefix + '/files/f2')

            url = url_path_join('notebooks', prefix, 'files', 'f3.txt')
            r = self.request('GET', url)
            self.assertEqual(r.status_code, 200)
            self.assertEqual(r.text, prefix + '/f3')
예제 #6
0
 def test_hidden_files(self):
     not_hidden = [
         u'å b',
         u'å b/ç. d',
     ]
     hidden = [
         u'.å b',
         u'å b/.ç d',
     ]
     dirs = not_hidden + hidden
     
     nbdir = self.notebook_dir
     for d in dirs:
         path = pjoin(nbdir, d.replace('/', os.sep))
         if not os.path.exists(path):
             os.mkdir(path)
         with open(pjoin(path, 'foo'), 'w') as f:
             f.write('foo')
         with open(pjoin(path, '.foo'), 'w') as f:
             f.write('.foo')
     
     for d in not_hidden:
         path = pjoin(nbdir, d.replace('/', os.sep))
         r = self.request('GET', url_path_join('files', d, 'foo'))
         r.raise_for_status()
         self.assertEqual(r.text, 'foo')
         r = self.request('GET', url_path_join('files', d, '.foo'))
         self.assertEqual(r.status_code, 404)
         
     for d in hidden:
         path = pjoin(nbdir, d.replace('/', os.sep))
         for foo in ('foo', '.foo'):
             r = self.request('GET', url_path_join('files', d, foo))
             self.assertEqual(r.status_code, 404)
예제 #7
0
    def get(self):
        query_string = self.get_query_argument('qs')
        reindex = bool(self.get_query_argument('reindex', 'true') == 'true')

        if reindex:
            self.index.update_index()

        results, total = self.index.search(query_string)

        for result in results:
            rel_path = result['path'][self.work_dir_len:]
            if rel_path.endswith('.ipynb'):
                # take it at face value that the extension implies notebook
                url = url_path_join(self.base_url, 'notebooks', rel_path)
            else:
                url = url_path_join(self.base_url, 'edit', rel_path)
            # Add URLs
            result['url'] = url
            result['tree_url'] = url_path_join(self.base_url, 'tree', os.path.dirname(rel_path))
            # Add relative paths
            result['rel_dirname'] = os.path.dirname(rel_path)
            result['rel_path'] = rel_path
        
        self.write(dict(results=results, total=total))
        self.finish()
예제 #8
0
    def create_request_handlers(self):
        """Create handlers and redefine them off of the base_url path. Assumes
        init_configurables() has already been called, and that the seed source
        was available there.
        """
        handlers = []
        # Register the NotebookDownloadHandler if configuration allows
        if self.allow_notebook_download:
            path = url_path_join("/", self.parent.base_url, r"/_api/source")
            self.log.info("Registering resource: {}, methods: (GET)".format(path))
            handlers.append((path, NotebookDownloadHandler, {"path": self.parent.seed_uri}))

        # Register a static path handler if configuration allows
        if self.static_path is not None:
            path = url_path_join("/", self.parent.base_url, r"/public/(.*)")
            self.log.info("Registering resource: {}, methods: (GET)".format(path))
            handlers.append((path, tornado.web.StaticFileHandler, {"path": self.static_path}))

        # Discover the notebook endpoints and their implementations
        endpoints = self.api_parser.endpoints(self.parent.kernel_manager.seed_source)
        response_sources = self.api_parser.endpoint_responses(self.parent.kernel_manager.seed_source)
        if len(endpoints) == 0:
            raise RuntimeError(
                "No endpoints were discovered. Check your notebook to make sure your cells are annotated correctly."
            )

        # Cycle through the (endpoint_path, source) tuples and register their handlers
        for endpoint_path, verb_source_map in endpoints:
            parameterized_path = parameterize_path(endpoint_path)
            parameterized_path = url_path_join("/", self.parent.base_url, parameterized_path)
            self.log.info(
                "Registering resource: {}, methods: ({})".format(parameterized_path, list(verb_source_map.keys()))
            )
            response_source_map = response_sources[endpoint_path] if endpoint_path in response_sources else {}
            handler_args = {
                "sources": verb_source_map,
                "response_sources": response_source_map,
                "kernel_pool": self.kernel_pool,
                "kernel_name": self.parent.kernel_manager.seed_kernelspec,
            }
            handlers.append((parameterized_path, NotebookAPIHandler, handler_args))

        # Register the swagger API spec handler
        path = url_path_join("/", self.parent.base_url, r"/_api/spec/swagger.json")
        handlers.append(
            (
                path,
                SwaggerSpecHandler,
                {
                    "notebook_path": self.parent.seed_uri,
                    "source_cells": self.parent.seed_notebook.cells,
                    "cell_parser": self.api_parser,
                },
            )
        )
        self.log.info("Registering resource: {}, methods: (GET)".format(path))

        # Add the 404 catch-all last
        handlers.append(default_base_handlers[-1])
        return handlers
예제 #9
0
    def redirect_to_files(self, path):
        """make redirect logic a reusable static method
        
        so it can be called from other handlers.
        """
        cm = self.contents_manager
        if cm.dir_exists(path):
            # it's a *directory*, redirect to /tree
            url = url_path_join(self.base_url, 'tree', url_escape(path))
        else:
            orig_path = path
            # otherwise, redirect to /files
            parts = path.split('/')

            if not cm.file_exists(path=path) and 'files' in parts:
                # redirect without files/ iff it would 404
                # this preserves pre-2.0-style 'files/' links
                self.log.warning("Deprecated files/ URL: %s", orig_path)
                parts.remove('files')
                path = '/'.join(parts)

            if not cm.file_exists(path=path):
                raise web.HTTPError(404)

            url = url_path_join(self.base_url, 'files', url_escape(path))
        self.log.debug("Redirecting %s to %s", self.request.path, url)
        self.redirect(url)
예제 #10
0
def load_jupyter_server_extension(nb_app):
    """Load the nb anaconda client extension"""
    webapp = nb_app.web_app
    base_url = webapp.settings['base_url']
    webapp.add_handlers(".*$", [
        (url_path_join(base_url, r"/ac-publish"), PublishHandler),
        (url_path_join(base_url, r"/ac-login"), WhoAmIHandler)
    ])
    nb_app.log.info("Enabling nb_anacondanotebook")
예제 #11
0
def load_jupyter_server_extension(nb_app):
    """Load the nb_anacondacloud client extension"""
    webapp = nb_app.web_app
    base_url = webapp.settings['base_url']
    ns = r'anaconda-cloud'
    webapp.add_handlers(".*$", [
        (url_path_join(base_url, ns, r"publish"), PublishHandler),
        (url_path_join(base_url, ns, r"login"), WhoAmIHandler)
    ])
    nb_app.log.info("[nb_anacondacloud] enabled")
def send_file(file_path, dashboard_name, handler):
    '''
    Posts a file to the Jupyter Dashboards Server to be served as a dashboard
    :param file_path: The path of the file to send
    :param dashboard_name: The dashboard name under which it should be made
        available
    '''
    # Make information about the request Host header available for use in
    # constructing the urls
    segs = handler.request.host.split(':')
    hostname = segs[0]
    if len(segs) > 1:
        port = segs[1]
    else:
        port = ''
    protocol = handler.request.protocol

    # Treat empty as undefined
    dashboard_server = os.getenv('DASHBOARD_SERVER_URL')
    if dashboard_server:
        dashboard_server = dashboard_server.format(protocol=protocol,
            hostname=hostname, port=port)
        upload_url = url_path_join(dashboard_server, UPLOAD_ENDPOINT,
            escape.url_escape(dashboard_name, False))
        with open(file_path, 'rb') as file_content:
            headers = {}
            token = os.getenv('DASHBOARD_SERVER_AUTH_TOKEN')
            if token:
                headers['Authorization'] = 'token {}'.format(token)
            result = requests.post(upload_url, files={'file': file_content},
                headers=headers, timeout=60, 
                verify=not skip_ssl_verification())
            if result.status_code >= 400:
                raise web.HTTPError(result.status_code)

        # Redirect to link specified in response body
        res_body = result.json()
        if 'link' in res_body:
            redirect_link = res_body['link']
        else:
            # Compute redirect link using environment variables
            # First try redirect URL as it might be different from internal upload URL
            redirect_server = os.getenv('DASHBOARD_REDIRECT_URL')
            if redirect_server:
                redirect_root = redirect_server.format(hostname=hostname,
                    port=port, protocol=protocol)
            else:
                redirect_root = dashboard_server

            redirect_link = url_path_join(redirect_root, VIEW_ENDPOINT, escape.url_escape(dashboard_name, False))
        handler.redirect(redirect_link)
    else:
        access_log.debug('Can not deploy, DASHBOARD_SERVER_URL not set')
        raise web.HTTPError(500, log_message='No dashboard server configured')
예제 #13
0
def load_jupyter_server_extension(nbapp):
    web_app = nbapp.web_app
    host_pattern = '.*$'
    version_route_pattern = url_path_join(web_app.settings['base_url'], '/version')
    listfolder_route_pattern = url_path_join(web_app.settings['base_url'], '/listfolder')
    getfile_route_pattern = url_path_join(web_app.settings['base_url'], '/getfile')

    web_app.add_handlers(host_pattern, [(version_route_pattern, VersionHandler)])
    web_app.add_handlers(host_pattern, [(listfolder_route_pattern, ListFolderHandler)])
    web_app.add_handlers(host_pattern, [(getfile_route_pattern, GetFileHandler)])
    
    nbapp.log.info("[beakerx_databrowser] enabled")
예제 #14
0
def load_jupyter_server_extension(nb_server_app):
    # Extract our Spark server details from the config:
    cfg = nb_server_app.config["NotebookApp"]
    SparkHandler.spark_host = cfg.get("spark_host", "http://localhost:4040")

    web_app = nb_server_app.web_app
    host_pattern = ".*$"
    route_pattern = url_path_join(
        web_app.settings['base_url'], EXTENSION_URL) + ".*"
    web_app.add_handlers(host_pattern, [(route_pattern, SparkHandler)])

    SparkHandler.web_app = url_path_join(
        web_app.settings['base_url'], EXTENSION_URL)
예제 #15
0
    def test_default_kernel(self):
        # POST request
        r = self.kern_api._req('POST', '')
        kern1 = r.json()
        self.assertEqual(r.headers['location'], url_path_join(self.url_prefix, 'api/kernels', kern1['id']))
        self.assertEqual(r.status_code, 201)
        self.assertIsInstance(kern1, dict)

        report_uri = url_path_join(self.url_prefix, 'api/security/csp-report')
        expected_csp = '; '.join([
            "frame-ancestors 'self'",
            'report-uri ' + report_uri,
            "default-src 'none'"
        ])
        self.assertEqual(r.headers['Content-Security-Policy'], expected_csp)
예제 #16
0
 def _req(self, verb, path, body=None, params=None):
     response = self.request(verb,
             url_path_join('api/contents', path),
             data=body, params=params,
     )
     response.raise_for_status()
     return response
예제 #17
0
    def _get_bluemix_app(self, abs_nb_path):
        '''
        Creates a temporary git repository containing the application bundle.
        Redirects the user's browser to the Bluemix deploy URL with a pointer
        back to the git repository.

        :param abs_nb_path:
        '''
        md = self._create_app_bundle(abs_nb_path, '.git')
        converter.add_cf_manifest(
            md['bundle_dir'],
            md['kernel_server'],
            md['notebook_basename'],
            md['tmpnb_mode']
        )
        converter.to_git_repository(md['bundle_dir'])
        # The jupyter_server already includes the base_url
        bundle_url_path = url_path_join('bundle',
            md['bundle_id'],
            md['notebook_basename'] + '.git'
        )

        # Include repository URL as the argument to deployer
        repository = escape.url_escape(md['jupyter_server'] + bundle_url_path)
        self.redirect(BLUEMIX_DEPLOY+repository)
예제 #18
0
def nb_open(filename, profile='default', open_browser=True, fLOG=fLOG):
    """
    open a notebook with an existing server,
    if no server can be found, it starts a new one
    (and the function runs until the server is closed)

    @param      filename        notebook
    @param      profile         profile to use
    @param      open_browser    open browser or not
    @param      fLOG            logging function
    @return                     a running server or None if not found
    """
    filename = os.path.abspath(filename)
    server_inf = find_best_server(filename, profile)
    if server_inf is not None:
        from notebook.utils import url_path_join
        fLOG("Using existing server at", server_inf['notebook_dir'])
        path = os.path.relpath(filename, start=server_inf['notebook_dir'])
        url = url_path_join(server_inf['url'], 'notebooks', path)
        webbrowser.open(url, new=2)
        return server_inf
    else:
        fLOG("Starting new server")
        home_dir = os.path.dirname(filename)
        from notebook import notebookapp
        server = notebookapp.launch_new_instance(file_to_run=os.path.abspath(filename),
                                                 notebook_dir=home_dir,
                                                 open_browser=open_browser,
                                                 # Avoid it seeing our own argv
                                                 argv=[],
                                                 )
        return server
예제 #19
0
 def _req(self, verb, section, body=None):
     response = requests.request(verb,
             url_path_join(self.base_url, 'api/config', section),
             data=body,
     )
     response.raise_for_status()
     return response
예제 #20
0
    def init_webapp(self):
        """
        Initialize tornado web application with kernel handlers. Put the kernel
        manager in settings to appease handlers that try to reference it there.
        Include additional options in settings as well.
        """
        # Redefine handlers off the base_url path
        handlers = []
        for handler in default_kernel_handlers + default_kernelspec_handlers + default_base_handlers:
            # Create a new handler pattern rooted at the base_url
            pattern = url_path_join(self.base_url, handler[0])
            # Some handlers take args, so retain those in addition to the
            # handler class ref
            new_handler = tuple([pattern] + list(handler[1:]))
            handlers.append(new_handler)

        self.web_app = web.Application(
            handlers=handlers,
            kernel_manager=self.kernel_manager,
            kernel_spec_manager=self.kernel_manager.kernel_spec_manager,
            kg_auth_token=self.auth_token,
            kg_allow_credentials=self.allow_credentials,
            kg_allow_headers=self.allow_headers,
            kg_allow_methods=self.allow_methods,
            kg_allow_origin=self.allow_origin,
            kg_expose_headers=self.expose_headers,
            kg_max_age=self.max_age,
            kg_max_kernels=self.max_kernels,
        )
예제 #21
0
 def _req(self, verb, path, body=None, params=None):
     response = requests.request(verb,
             url_path_join(self.base_url, 'nbconvert', path),
             data=body, params=params,
     )
     response.raise_for_status()
     return response
예제 #22
0
    def test_from_post_zip(self):
        nbmodel_url = url_path_join(self.base_url(), 'api/contents/foo/testnb.ipynb')
        nbmodel = requests.get(nbmodel_url).json()

        r = self.nbconvert_api.from_post(format='latex', nbmodel=nbmodel)
        self.assertIn(u'application/zip', r.headers['Content-Type'])
        self.assertIn(u'.zip', r.headers['Content-Disposition'])
예제 #23
0
 def get(self, path):
     self.log.warn("/api/notebooks is deprecated, use /api/contents")
     self.redirect(url_path_join(
         self.base_url,
         'api/contents',
         path
     ))
예제 #24
0
파일: test_files.py 프로젝트: ACGC/notebook
    def test_download(self):
        nbdir = self.notebook_dir.name
        base = self.base_url()
        
        text = 'hello'
        with open(pjoin(nbdir, 'test.txt'), 'w') as f:
            f.write(text)
        
        r = requests.get(url_path_join(base, 'files', 'test.txt'))
        disposition = r.headers.get('Content-Disposition', '')
        self.assertNotIn('attachment', disposition)

        r = requests.get(url_path_join(base, 'files', 'test.txt') + '?download=1')
        disposition = r.headers.get('Content-Disposition', '')
        self.assertIn('attachment', disposition)
        self.assertIn('filename="test.txt"', disposition)
예제 #25
0
def bundle(handler, abs_nb_path):
    '''
    Uploads a notebook to a Jupyter Dashboard Server
    '''
    # Get name of notebook from filename
    notebook_basename = os.path.basename(abs_nb_path)
    notebook_name = os.path.splitext(notebook_basename)[0]

    # Make information about the request Host header available for use in
    # constructing the urls
    segs = handler.request.host.split(':')
    hostname = segs[0]
    if len(segs) > 1:
        port = segs[1]
    else:
        port = ''
    protocol = handler.request.protocol

    # Treat empty as undefined
    dashboard_server = os.getenv('DASHBOARD_SERVER_URL')
    if dashboard_server:
        dashboard_server = dashboard_server.format(protocol=protocol,
            hostname=hostname, port=port)
        upload_url = url_path_join(dashboard_server, UPLOAD_ENDPOINT,
            escape.url_escape(notebook_name, False))
        with open(abs_nb_path, 'rb') as notebook:
            headers = {}
            token = os.getenv('DASHBOARD_SERVER_AUTH_TOKEN')
            if token:
                # TODO: server side should expect Authorization: token <value>
                headers['Authorization'] = token
            result = requests.post(upload_url, files={'file': notebook},
                headers=headers, timeout=60)
            if result.status_code >= 400:
                raise web.HTTPError(result.status_code)

        # Redirect for client might be different from internal upload URL
        redirect_server = os.getenv('DASHBOARD_REDIRECT_URL')
        if redirect_server:
            redirect_root = redirect_server.format(hostname=hostname,
                port=port, protocol=protocol)
        else:
            redirect_root = dashboard_server
        handler.redirect(url_path_join(redirect_root, VIEW_ENDPOINT, escape.url_escape(notebook_name, False)))
    else:
        access_log.debug('Can not deploy, DASHBOARD_SERVER_URL not set')
        raise web.HTTPError(500, log_message='No dashboard server configured')
예제 #26
0
    def _kernel_id_to_url(self, kernel_id):
        """Builds a url for the given kernel UUID.

        Parameters
        ----------
        kernel_id: kernel UUID
        """
        return url_path_join(self.kernels_endpoint, url_escape(str(kernel_id)))
예제 #27
0
def load_jupyter_server_extension(nb_server_app):
    """
    Called when the extension is loaded.

    Args:
        nb_server_app (NotebookWebApplication): handle to the Notebook webserver instance.
    """
    web_app = nb_server_app.web_app
    host_pattern = '.*$'
    route_pattern = url_path_join(web_app.settings['base_url'], r'(ws\.\d+\.obj\.\d+.*)')
    web_app.add_handlers(host_pattern, [(route_pattern, NarrativeMainHandler)])

    route_pattern = url_path_join(web_app.settings['base_url'], r'(ws\.\d+)$')
    web_app.add_handlers(host_pattern, [(route_pattern, NarrativeMainHandler)])

    route_pattern = url_path_join(web_app.settings['base_url'], r'(\d+)$')
    web_app.add_handlers(host_pattern, [(route_pattern, NarrativeMainHandler)])
예제 #28
0
 def websocket(self, id):
     loop = IOLoop()
     req = HTTPRequest(
         url_path_join(self.base_url.replace('http', 'ws', 1), 'api/kernels', id, 'channels'),
         headers=self.headers,
     )
     f = websocket_connect(req, io_loop=loop)
     return loop.run_sync(lambda : f)
예제 #29
0
def load_jupyter_server_extension(nb_app):
    web_app = nb_app.web_app
    host_pattern = '.*$'
    route_pattern = url_path_join(web_app.settings['base_url'], '/search')
    handler_kwargs = dict(work_dir=nb_app.notebook_dir)
    web_app.add_handlers(host_pattern, [
        (route_pattern, SearchHandler, handler_kwargs)
    ])
예제 #30
0
def load_jupyter_server_extension(nb_app):
    web_app = nb_app.web_app
    host_pattern = '.*$'
    bundler_id_regex = r'(?P<bundler_id>[A-Za-z0-9_]+)'
    route_url = url_path_join(web_app.settings['base_url'], '/api/bundlers/%s' % bundler_id_regex)
    web_app.add_handlers(host_pattern, [
        (route_url, BundlerHandler, {'notebook_dir': nb_app.notebook_dir}),
    ])
 def proxy(self):
     request = self.request
     body = request.body
     hub_api_url = environ.get('JUPYTERHUB_API_URL')
     url = url_path_join(hub_api_url,
                         'notebooks/' + request.uri.split('contents/')[1])
     if request.method == "GET":
         response = yield maybe_future(
             self._api_request(method=request.method, url=url))
     else:
         response = yield maybe_future(
             self._api_request(method=request.method, url=url, data=body))
     self.set_status(response.status_code)
     self.finish(response.text)
예제 #32
0
파일: handlers.py 프로젝트: tripl-ai/docker
    def content_security_policy(self):
        """The default Content-Security-Policy header

        Can be overridden by defining Content-Security-Policy in settings['headers']
        """
        if 'Content-Security-Policy' in self.settings.get('headers', {}):
            # user-specified, don't override
            return self.settings['headers']['Content-Security-Policy']

        return '; '.join([
            "frame-ancestors 'self'",
            # Make sure the report-uri is relative to the base_url
            "report-uri " + self.settings.get('csp_report_uri', url_path_join(self.base_url, csp_report_uri)),
        ])
예제 #33
0
def load_jupyter_server_extension(nbapp):
    """
    Called during notebook start
    """
    resuseconfig = ResourceUseDisplay(parent=nbapp)
    nbapp.web_app.settings["nbresuse_display_config"] = resuseconfig
    base_url = nbapp.web_app.settings["base_url"]
    nbapp.web_app.add_handlers(
        ".*", [(url_path_join(base_url, "/api/kernels/metrics"), ApiHandler)]
    )
    callback = ioloop.PeriodicCallback(
        PrometheusHandler(PSUtilMetricsLoader(nbapp)), 1000
    )
    callback.start()
예제 #34
0
def load_jupyter_server_extension(nb_server_app):
    """
    Called when the extension is loaded.

    Args:
        nb_server_app (NotebookWebApplication): handle to the Notebook webserver instance.
    """
    web_app = nb_server_app.web_app
    host_pattern = '.*$'
    route_pattern = url_path_join(web_app.settings['base_url'],
                                  '/jupyter-text2code')
    web_app.add_handlers(host_pattern,
                         [(route_pattern, JupyterText2CodeHandler)])
    print("loaded_jupyter_server_extension: jupyter-text2code")
예제 #35
0
def setup_handlers(web_app, host_whitelist):
    host_pattern = '.*$'
    web_app.add_handlers('.*', [
        (url_path_join(web_app.settings['base_url'],
                       r'/proxy/(.*):(\d+)(.*)'), RemoteProxyHandler, {
                           'absolute_url': False,
                           'host_whitelist': host_whitelist
                       }),
        (url_path_join(
            web_app.settings['base_url'],
            r'/proxy/absolute/(.*):(\d+)(.*)'), RemoteProxyHandler, {
                'absolute_url': True,
                'host_whitelist': host_whitelist
            }),
        (url_path_join(web_app.settings['base_url'],
                       r'/proxy/(\d+)(.*)'), LocalProxyHandler, {
                           'absolute_url': False
                       }),
        (url_path_join(web_app.settings['base_url'],
                       r'/proxy/absolute/(\d+)(.*)'), LocalProxyHandler, {
                           'absolute_url': True
                       }),
    ])
예제 #36
0
def setup_handlers(web_app: "NotebookWebApplication", config: PRConfig):
    host_pattern = ".*$"
    base_url = url_path_join(web_app.settings["base_url"], NAMESPACE)

    logger = get_logger()

    manager_class = MANAGERS.get(config.provider)
    if manager_class is None:
        logger.error(f"No manager defined for provider '{config.provider}'.")
        raise NotImplementedError()
    manager = manager_class(config.api_base_url, config.access_token)

    web_app.add_handlers(
        host_pattern,
        [(
            url_path_join(base_url, pat),
            handler,
            {
                "logger": logger,
                "manager": manager
            },
        ) for pat, handler in default_handlers],
    )
예제 #37
0
def load_jupyter_server_extension(nb_server_app):
    """
    Called when the extension is loaded.

    Args:
        nb_server_app (NotebookWebApplication): handle to the Notebook webserver instance.
    """
    web_app = nb_server_app.web_app
    nb_server_app.log.info("Loading the AdHoc serverextension")
    
    host_pattern = '.*$'
    route_pattern = url_path_join(web_app.settings['base_url'], 'adhoc')
    nb_server_app.log.info(route_pattern)
    web_app.add_handlers(host_pattern, [(route_pattern, AdHocHandler)])
예제 #38
0
def load_jupyter_server_extension(nb_server_app):
    """
    Called when the extension is loaded.

    Args:
        nb_server_app (NotebookWebApplication): handle to the Notebook webserver instance.
    """
    web_app = nb_server_app.web_app
    host_pattern = '.*$'

    #route patterns
    file_size_pattern = url_path_join(web_app.settings['base_url'],
                                      '/filesize/(.+$)')
    file_date_pattern = url_path_join(web_app.settings['base_url'],
                                      '/filedate/(.+$)')
    view_table_pattern = url_path_join(web_app.settings['base_url'],
                                       '/table_view/(.+$)')
    file_content_pattern = url_path_join(
        web_app.settings['base_url'],
        '/file_content/([^/]+)/(-?[0-9]+)/(-?[0-9]+$)')
    draw_chat_pattern = url_path_join(
        web_app.settings['base_url'],
        '/draw_chat/([^/]+)/([0-2])/([0-9]+)/([0-9]+)/([0-9]+)/([0-9]+$)')
    sort_content_pattern = url_path_join(web_app.settings['base_url'],
                                         '/sort_content/([^/]+)/([0-9]+$)')
    data_feature_pattern = url_path_join(
        web_app.settings['base_url'],
        '/data_feature/([^/]+)/([0-9])/([0-1])/([0-9]+$)')
    line_number_pattern = url_path_join(web_app.settings['base_url'],
                                        '/line_num/(.+$)')
    file_feature_pattern = url_path_join(web_app.settings['base_url'],
                                         '/file_feature/([^/]+)/([0-9]+$)')
    web_app.add_handlers(host_pattern,
                         [(file_size_pattern, FileSizeHandler),
                          (file_date_pattern, FileDateHandler),
                          (view_table_pattern, ViewTableHandler),
                          (file_content_pattern, FileContentHandler),
                          (draw_chat_pattern, DrawChatHandler),
                          (sort_content_pattern, SortContentHandler),
                          (data_feature_pattern, DataFeatureHandler),
                          (line_number_pattern, FileLineNumberHandler),
                          (file_feature_pattern, FileFeatureHandler)])
예제 #39
0
def setup_handlers(web_app: NotebookWebApplication) -> None:
    host_pattern = ".*$"
    web_app.add_handlers(
        host_pattern,
        [
            (
                url_path_join(
                    web_app.settings["base_url"],
                    "/jupyterlab_code_formatter/formatters",
                ),
                FormattersAPIHandler,
            )
        ],
    )

    web_app.add_handlers(
        host_pattern,
        [
            (
                url_path_join(
                    web_app.settings["base_url"], "/jupyterlab_code_formatter/format"
                ),
                FormatAPIHandler,
            )
        ],
    )
    web_app.add_handlers(
        host_pattern,
        [
            (
                url_path_join(
                    web_app.settings["base_url"], "/jupyterlab_code_formatter/version"
                ),
                VersionAPIHandler,
            )
        ],
    )
예제 #40
0
    async def post(self, path: str = ""):
        """Create a new file in the specified path.

        POST /jupyter-project/files/<parent-file-path>
            Creates a new file applying the parameters to the Jinja template.

        Request json body:
            Dictionary of parameters for the Jinja template.
        """
        if self.template is None:
            raise tornado.web.HTTPError(
                404, reason="File Jinja template not found.")

        cm = self.contents_manager
        params = self.get_json_body()

        try:
            default_name = self.default_name.render(**params)
        except TemplateError as error:
            self.log.warning(
                f"Fail to render the default name for template '{self.template.name}'"
            )
            default_name = cm.untitled_file

        ext = "".join(Path(self.template.name).suffixes)
        filename = default_name + ext
        filename = cm.increment_filename(filename, path)
        fullpath = url_path_join(path, filename)

        realpath = Path(cm.root_dir).absolute() / url2path(fullpath)
        if not realpath.parent.exists():
            realpath.parent.mkdir(parents=True)

        current_loop = tornado.ioloop.IOLoop.current()
        try:
            content = await current_loop.run_in_executor(
                None, functools.partial(self.template.render, **params))
            realpath.write_text(content)
        except (OSError, TemplateError) as error:
            raise tornado.web.HTTPError(
                500,
                log_message=
                f"Fail to generate the file from template {self.template.name}.",
                reason=repr(error),
            )

        model = cm.get(fullpath, content=False, type="file", format="text")
        self.set_status(201)
        self.finish(json.dumps(model, default=date_default))
예제 #41
0
    def get(self, relfpath, uri, **kwargs):
        def _handleErr(code, msg):
            extra = dict((
                ("relfpath", relfpath),
                ("uri", uri),
                *kwargs.items(),
            ))

            if isinstance(msg, dict):
                # encode msg as json
                msg["debugVars"] = {**msg.get("debugVars", {}), **extra}
                msg = simplejson.dumps(msg, ignore_nan=True)
            else:
                msg = "\n".join(
                    (msg, ", ".join(f"{key}: {val}"
                                    for key, val in extra.items())))

            self.log.error(msg)
            raise HTTPError(code, msg)

        if not relfpath:
            msg = f"The request was malformed; fpath should not be empty."
            _handleErr(400, msg)

        fpath = url_path_join(self.notebook_dir, relfpath)

        if not os.path.exists(fpath):
            msg = f"The request specified a file that does not exist."
            _handleErr(403, msg)
        else:
            try:
                # test opening the file with h5py
                with h5py.File(fpath, "r") as f:
                    pass
            except Exception as e:
                msg = f"The request did not specify a file that `h5py` could understand.\n" f"Error: {traceback.format_exc()}"
                _handleErr(401, msg)
            try:
                out = self._get(fpath, uri, **kwargs)
            except JhdfError as e:
                msg = e.args[0]
                msg["traceback"] = traceback.format_exc()
                msg["type"] = "JhdfError"
                _handleErr(400, msg)
            except Exception as e:
                msg = f"Found and opened file, error getting contents from object specified by the uri.\n" f"Error: {traceback.format_exc()}"
                _handleErr(500, msg)

            return out
예제 #42
0
def load_jupyter_server_extension(nb_server_app):
    """
    Called when the extension is loaded.

    Args:
        nb_server_app (NotebookWebApplication): handle to the Notebook webserver instance.
    """
    web_app = nb_server_app.web_app
    host_pattern = '.*$'
    route_pattern = url_path_join(web_app.settings['base_url'],
                                  'higlass/([0-9]+)/(.*)')
    sockets_dir = os.path.join('/tmp', getpass.getuser(), 'higlass')
    web_app.add_handlers(
        host_pattern,
        [(route_pattern, HiGlassProxyHandler, dict(sockets_dir=sockets_dir))])
예제 #43
0
def load_jupyter_server_extension(nb_server_app):
    """
    Called when the extension is loaded.

    Args:
        nb_server_app (NotebookWebApplication): handle to the Notebook webserver instance.
    """
    print("The jupyterlab-comments server extension has been loaded")
    web_app = nb_server_app.web_app
    host_pattern = '.*$'
    base_url = web_app.settings['base_url']
    detached_comments_route_pattern = url_path_join(base_url,
                                                    '/detachedComments')
    review_comments_route_pattern = url_path_join(base_url, '/reviewComments')
    refresh_interval_route_pattern = url_path_join(base_url,
                                                   '/refreshInterval')
    remote_pull_route_pattern = url_path_join(base_url, '/remotePull')

    web_app.add_handlers(host_pattern, [
        (detached_comments_route_pattern, DetachedCommentsHandler),
        (review_comments_route_pattern, ReviewCommentsHandler),
        (refresh_interval_route_pattern, RefreshIntervalHandler),
        (remote_pull_route_pattern, PullFromRemoteRepoHandler),
    ])
예제 #44
0
def load_jupyter_server_extension(nb_server_app):
    """
    Called when the extension is loaded.

    Args:
        nb_server_app (NotebookApp): handle to the Notebook webserver instance.
    """
    web_app = nb_server_app.web_app
    # Prepend the base_url so that it works in a jupyterhub setting
    base_url = web_app.settings['base_url']
    endpoint = url_path_join(base_url, 'latex')
    handlers = [(f'{endpoint}{path_regex}', LatexHandler, {
        "notebook_dir": nb_server_app.notebook_dir
    })]
    web_app.add_handlers('.*$', handlers)
예제 #45
0
def load_jupyter_server_extension(nb_server_app):
    """
    Called when the extension is loaded.

    Args:
        nb_server_app (NotebookWebApplication): handle to the Notebook webserver instance.
    """
    cluster_id_regex = r"(?P<cluster_id>\w+-\w+-\w+-\w+-\w+)"
    web_app = nb_server_app.web_app
    base_url = web_app.settings["base_url"]
    get_cluster_path = url_path_join(base_url,
                                     "dask/clusters/" + cluster_id_regex)
    list_clusters_path = url_path_join(base_url, "dask/clusters/" + "?")
    get_dashboard_path = url_path_join(
        base_url, f"dask/dashboard/{cluster_id_regex}/(?P<proxied_path>.+)")
    list_dashboards_path = url_path_join(
        base_url, f"dask/dashboard/{cluster_id_regex}/" + "?")
    handlers = [
        (get_cluster_path, DaskClusterHandler),
        (list_clusters_path, DaskClusterHandler),
        (get_dashboard_path, DaskDashboardHandler),
        (list_dashboards_path, DaskDashboardHandler),
    ]
    web_app.add_handlers(".*$", handlers)
예제 #46
0
파일: spark.py 프로젝트: klyr/jupyter-spark
    def get(self):
        if not self.request.uri.startswith(self.full_url):
            raise_error('Request URI did not start with %s' % self.full_url)

        spark_url = self.host + self.request.uri[len(self.full_url):]

        try:
            spark_response = requests.get(spark_url)

            content_type = spark_response.headers['content-type']
            self.set_header('Content-Type', content_type)

            if 'text/html' in content_type:
                # Replace all the relative links with our proxy links
                soup = BeautifulSoup(spark_response.text, 'html.parser')

                for has_href in ['a', 'link']:
                    for a in soup.find_all(has_href):
                        if 'href' in a.attrs:
                            a['href'] = url_path_join(self.full_url, a['href'])

                for has_src in ['img', 'script']:
                    for a in soup.find_all(has_src):
                        if 'src' in a.attrs:
                            a['src'] = url_path_join(self.full_url, a['src'])

                client_response = str(soup)
            else:
                # Probably binary response, send it directly.
                client_response = spark_response.content

        except requests.exceptions.RequestException:
            client_response = json.dumps({'error': 'SPARK_NOT_RUNNING'})

        self.write(client_response)
        self.flush()
예제 #47
0
def load_jupyter_server_extension(nb_server_app):
    """
    Called when the extension is loaded.

    :param nb_server_app:  NotebookWebApplication
    :return:
    """
    here = os.path.dirname(__file__)
    nb_server_app.log.info(
        "\n\n Megaclite Jupyter Extension loaded from %s \n\n" % here)
    jupyter_orbit = nb_server_app.web_app
    host_pattern = '.*$'
    route_pattern = url_path_join(jupyter_orbit.settings['base_url'],
                                  '/megaclite/(.*)')
    jupyter_orbit.add_handlers(host_pattern, [(route_pattern, Megaclite)])
예제 #48
0
    def __init__(self, model, cfg=None, height=600, backend='nengo'):
        self.height = height

        self._started = False

        if cfg is None:
            cfg = get_ipython().mktempfile()

        self.server = self.start_server(cfg, model)
        self.port = self.server.server.server_port
        self.server.server.settings.prefix = None
        self.server.server.page_settings.backend = backend

        self.resource = url_path_join('/nengo', str(self.port),
                                      str(self.server.server.get_resource()))
예제 #49
0
    def _req(self, verb: str, path: List[str], body=None, params=None):
        if body is not None:
            body = json.dumps(body)
        response = self.request(
            verb, url_path_join(self.url, *path), data=body, params=params
        )

        if 400 <= response.status_code < 600:
            try:
                response.reason = response.json()["message"]
            except Exception:
                pass
        response.raise_for_status()

        return response
예제 #50
0
def load_jupyter_server_extension(nb_app):
    '''Loads server extension.'''
    nb_app.log.info('Loaded nb2kg extension')
    # TODO: There is no clean way to override existing handlers that are already
    # registered with the Tornado application.  The first handler to match the
    # URL will handle the request, so we must prepend our handlers to override
    # the existing ones.
    web_app = nb_app.web_app
    pattern, handlers = web_app.handlers[0]
    base_url = web_app.settings['base_url']
    for handler in ext_handlers[::-1]:
        pattern = url_path_join(base_url, handler[0])
        new_handler = URLSpec(pattern, *handler[1:])
        nb_app.log.info('Overriding handler %s' % new_handler)
        handlers.insert(0, new_handler)
예제 #51
0
 async def __get_content(self, url: str, filename: str, sha: str) -> str:
     link = url_concat(
         url_path_join(url, "contents", filename),
         {"ref": sha},
     )
     try:
         return await self._call_github(
             link,
             media_type="application/vnd.github.v3.raw",
             load_json=False)
     except HTTPError as e:
         if e.status_code == 404:
             return ""
         else:
             raise e
예제 #52
0
def load_jupyter_server_extension(nb_server_app):
  """Called by Jupyter when starting the notebook manager."""
  nb_server_app.log.addFilter(_ColabLoggingFilter())
  app = nb_server_app.web_app

  url_maker = lambda path: utils.url_path_join(app.settings['base_url'], path)
  monitor_relative_path = '/api/colab/resources'

  app.add_handlers('.*$', [
      (url_maker(monitor_relative_path), _handlers.ResourceUsageHandler, {
          'kernel_manager': app.settings['kernel_manager']
      }),
      (url_maker('/api/colab/drive'), _handlers.DriveHandler),
  ])
  nb_server_app.log.info('google.colab serverextension initialized.')
예제 #53
0
    def test_modify_kernel_name(self):
        before = self.sess_api.create('foo/nb1.ipynb').json()
        sid = before['id']

        after = self.sess_api.modify_kernel_name(
            sid, before['kernel']['name']).json()
        self.assertEqual(after['id'], sid)
        self.assertEqual(after['notebook'], before['notebook'])
        self.assertNotEqual(after['kernel']['id'], before['kernel']['id'])

        # check kernel list, to be sure previous kernel was cleaned up
        r = requests.get(url_path_join(self.base_url(), 'api/kernels'))
        r.raise_for_status()
        kernel_list = r.json()
        self.assertEqual(kernel_list, [after['kernel']])
예제 #54
0
def load_jupyter_server_extension(nb_server_app):
    """Called by Jupyter when starting the notebook manager."""
    app = nb_server_app.web_app

    url_maker = lambda path: utils.url_path_join(app.settings['base_url'], path
                                                 )
    chunked_relative_path = '/api/chunked-contents' + handlers.path_regex
    monitor_relative_path = '/api/colab/resources'

    app.add_handlers('.*$', [
        (url_maker(chunked_relative_path),
         _handlers.ChunkedFileDownloadHandler),
        (url_maker(monitor_relative_path), _handlers.ResourceUsageHandler),
    ])
    nb_server_app.log.info('google.colab serverextension initialized.')
예제 #55
0
def load_jupyter_server_extension(nb_server_app):
    """ Called when the extension is loaded

    - Adds API to server

    :param nb_server_app: handle to the Notebook webserver instance.
    :type nb_server_app: NotebookWebApplication
    """
    _init_sub_folders()

    web_app = nb_server_app.web_app
    host_pattern = '.*$'
    route_pattern = url_path_join(web_app.settings['base_url'], '/retrieve')

    web_app.add_handlers(host_pattern, [(route_pattern, RetrieveHandler)])
예제 #56
0
파일: __init__.py 프로젝트: kayceesrk/egal
def load_jupyter_server_extension(nb_server_app):
    """
    Called when the extension is loaded.

    Args:
        nb_server_app (NotebookWebApplication): handle to the Notebook webserver instance.
    """
    web_app = nb_server_app.web_app
    # web_app.log.info('My Extension Loaded')
    nb_server_app.log.info("egal enabled!")
    host_pattern = '.*$'
    download_pattern = url_path_join(web_app.settings['base_url'],
                                     '/draw/(.+)')
    web_app.add_handlers(host_pattern, [(download_pattern, DrawHandler)])
    print("Called")
예제 #57
0
def load_jupyter_server_extension(nb_server_app):
    """
    Called when the extension is loaded.
    Args:
        nb_server_app (NotebookApp): handle to the Notebook webserver instance.
    """
    web_app = nb_server_app.web_app
    # Prepend the base_url so that it works in a jupyterhub setting
    base_url = web_app.settings['base_url']
    doc_url = url_path_join(base_url, 'my_doc')

    doc_dir = os.path.join(os.path.dirname(__file__), 'static', 'doc', 'html')

    handlers = [(f'{doc_url}/(.*)', StaticFileHandler, {'path': doc_dir})]
    web_app.add_handlers('.*$', handlers)
예제 #58
0
def load_jupyter_server_extension(nbapp):
    from notebook.utils import url_path_join
    from .handlers import TestHandler, PublishS3Handler
    from .config import PublishSettings

    settings = PublishSettings(
        # add access to NotebookApp config, too
        parent=nbapp,
        # for convenient access to frontend settings
        config_manager=nbapp.config_manager,
    )
    config_s3 = settings.config['PublishSettings']
    notebook_dir = settings.config['NotebookApp']['notebook_dir']
    if type(notebook_dir) is not str:
        notebook_dir = ''
    nbapp.log.info("notebook_dir " + notebook_dir)


    url = nbapp.web_app.settings['base_url']
    params = dict(
            nbapp=nbapp,
            access_key=config_s3['s3_access_key_id'],
            secret_key=config_s3['s3_secret_access_key'],
            endpoint_url=config_s3['s3_endpoint_url'],
            region_name=config_s3['s3_region_name'],
            bucket=config_s3['s3_bucket'],
            notebook_dir=notebook_dir
            )
    nbapp.web_app.add_handlers(
        r'.*',  # match any host
        [
            (url_path_join(url, '/hello'), TestHandler),
            (url_path_join(url, '/publish_notebook'), PublishS3Handler, params),
        ]
    )
    nbapp.log.info("jupyter_extention_publish enabled!")
예제 #59
0
    def post(self):
        km = self.kernel_manager
        model = self.get_json_body()
        if model is None:
            model = {'name': km.default_kernel_name}
        else:
            model.setdefault('name', km.default_kernel_name)

        kernel_id = km.start_kernel(kernel_name=model['name'])
        model = km.kernel_model(kernel_id)
        location = url_path_join(self.base_url, 'api', 'kernels',
                                 url_escape(kernel_id))
        self.set_header('Location', location)
        self.set_status(201)
        self.finish(json.dumps(model))
예제 #60
0
    def list_files(self, pr_id):

        git_url = url_path_join(pr_id, "/files")
        results = yield self.call_github(git_url)

        data = []
        for result in results:
            data.append({
                'name': result["filename"],
                'status': result["status"],
                'additions': result["additions"],
                'deletions': result["deletions"]
            })

        return data