jupyverse 0.0.50__tar.gz → 0.1.2__tar.gz

{jupyverse-0.0.50 → jupyverse-0.1.2}/.github/workflows/check-release.yml

@@ -44,7 +44,7 @@ jobs:
       - name: Install Dependencies
         run: |
           pip install -e . --no-deps
-          pip install -e plugins/auth_base
+          pip install -e jupyverse_api
           pip install -e plugins/frontend
           pip install -e plugins/jupyterlab
           pip install -e plugins/retrolab
@@ -54,6 +54,8 @@ jobs:
           pip install -e plugins/nbconvert
           pip install -e plugins/yjs
           pip install -e plugins/auth
+          pip install -e plugins/noauth
+          pip install -e plugins/auth_fief
           pip install -e plugins/login
       - name: Check Release
         if: ${{ matrix.group == 'check_release' }}

{jupyverse-0.0.50 → jupyverse-0.1.2}/.pre-commit-config.yaml

@@ -16,22 +16,12 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/psf/black
-    rev: 23.1.0
+    rev: 23.3.0
     hooks:
       - id: black
-        args: ["--line-length", "100"]
 
-  - repo: https://github.com/PyCQA/isort
-    rev: 5.12.0
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.0.260
     hooks:
-      - id: isort
-        files: \.py$
-        args: [--profile=black]
-
-  - repo: https://github.com/pycqa/flake8
-    rev: 6.0.0
-    hooks:
-      - id: flake8
-        exclude: binder
-        additional_dependencies:
-          ["flake8-implicit-str-concat==0.2.0", "flake8-pyproject"]
+      - id: ruff
+        args: ["--fix"]

{jupyverse-0.0.50 → jupyverse-0.1.2}/CHANGELOG.md

@@ -2,6 +2,51 @@
 
 <!-- <START NEW CHANGELOG ENTRY> -->
 
+## 0.1.2
+
+No merged PRs
+
+<!-- <END NEW CHANGELOG ENTRY> -->
+
+## 0.1.1
+
+([Full Changelog](https://github.com/jupyter-server/jupyverse/compare/v0.0.50...254a3dfd5f6851e2e79406fab934c8361399ffb6))
+
+### Merged PRs
+
+- Fix jupyverse-api -> jupyverse_api [#286](https://github.com/jupyter-server/jupyverse/pull/286) ([@davidbrochart](https://github.com/davidbrochart))
+- Add jupyverse_api dependency to plugins [#285](https://github.com/jupyter-server/jupyverse/pull/285) ([@davidbrochart](https://github.com/davidbrochart))
+- Update documentation, add jupyverse CLI [#283](https://github.com/jupyter-server/jupyverse/pull/283) ([@davidbrochart](https://github.com/davidbrochart))
+- Update to FastAPI 0.95 [#281](https://github.com/jupyter-server/jupyverse/pull/281) ([@davidbrochart](https://github.com/davidbrochart))
+- Drop FPS in favor of Asphalt [#277](https://github.com/jupyter-server/jupyverse/pull/277) ([@davidbrochart](https://github.com/davidbrochart))
+- Add ruff pre-commit [#275](https://github.com/jupyter-server/jupyverse/pull/275) ([@davidbrochart](https://github.com/davidbrochart))
+- Add DELETE /api/kernels/{kernel_id} (shutdown kernel) [#274](https://github.com/jupyter-server/jupyverse/pull/274) ([@davidbrochart](https://github.com/davidbrochart))
+
+### Contributors to this release
+
+([GitHub contributors page for this release](https://github.com/jupyter-server/jupyverse/graphs/contributors?from=2023-02-23&to=2023-04-06&type=c))
+
+[@davidbrochart](https://github.com/search?q=repo%3Ajupyter-server%2Fjupyverse+involves%3Adavidbrochart+updated%3A2023-02-23..2023-04-06&type=Issues) | [@pre-commit-ci](https://github.com/search?q=repo%3Ajupyter-server%2Fjupyverse+involves%3Apre-commit-ci+updated%3A2023-02-23..2023-04-06&type=Issues)
+
+## 0.1.0
+
+([Full Changelog](https://github.com/jupyter-server/jupyverse/compare/v0.0.50...62b06f7a05b4ba536ce1ae0f40b3643dc4b4152d))
+
+### Merged PRs
+
+- Add jupyverse_api dependency to plugins [#285](https://github.com/jupyter-server/jupyverse/pull/285) ([@davidbrochart](https://github.com/davidbrochart))
+- Update documentation, add jupyverse CLI [#283](https://github.com/jupyter-server/jupyverse/pull/283) ([@davidbrochart](https://github.com/davidbrochart))
+- Update to FastAPI 0.95 [#281](https://github.com/jupyter-server/jupyverse/pull/281) ([@davidbrochart](https://github.com/davidbrochart))
+- Drop FPS in favor of Asphalt [#277](https://github.com/jupyter-server/jupyverse/pull/277) ([@davidbrochart](https://github.com/davidbrochart))
+- Add ruff pre-commit [#275](https://github.com/jupyter-server/jupyverse/pull/275) ([@davidbrochart](https://github.com/davidbrochart))
+- Add DELETE /api/kernels/{kernel_id} (shutdown kernel) [#274](https://github.com/jupyter-server/jupyverse/pull/274) ([@davidbrochart](https://github.com/davidbrochart))
+
+### Contributors to this release
+
+([GitHub contributors page for this release](https://github.com/jupyter-server/jupyverse/graphs/contributors?from=2023-02-23&to=2023-04-06&type=c))
+
+[@davidbrochart](https://github.com/search?q=repo%3Ajupyter-server%2Fjupyverse+involves%3Adavidbrochart+updated%3A2023-02-23..2023-04-06&type=Issues) | [@pre-commit-ci](https://github.com/search?q=repo%3Ajupyter-server%2Fjupyverse+involves%3Apre-commit-ci+updated%3A2023-02-23..2023-04-06&type=Issues)
+
 ## 0.0.50
 
 ([Full Changelog](https://github.com/jupyter-server/jupyverse/compare/v0.0.49...cf56682249dd5c7064d16b4a88f6f49aeb728ce1))
@@ -17,8 +62,6 @@
 
 [@davidbrochart](https://github.com/search?q=repo%3Ajupyter-server%2Fjupyverse+involves%3Adavidbrochart+updated%3A2023-01-24..2023-02-23&type=Issues) | [@pre-commit-ci](https://github.com/search?q=repo%3Ajupyter-server%2Fjupyverse+involves%3Apre-commit-ci+updated%3A2023-01-24..2023-02-23&type=Issues)
 
-<!-- <END NEW CHANGELOG ENTRY> -->
-
 ## 0.0.49
 
 ([Full Changelog](https://github.com/jupyter-server/jupyverse/compare/v0.0.48...c976ab4f7c7c8c416b19dc794f253ec0a2c87636))

{jupyverse-0.0.50 → jupyverse-0.1.2}/PKG-INFO

@@ -1,36 +1,39 @@
 Metadata-Version: 2.1
 Name: jupyverse
-Version: 0.0.50
+Version: 0.1.2
 Summary: A set of FPS plugins implementing a Jupyter server
 Project-URL: Homepage, https://jupyter.org
 Author-email: Jupyter Development Team <jupyter@googlegroups.com>
 License: BSD 3-Clause License
 License-File: COPYING.md
-Keywords: fastapi,jupyter,pluggy,plugins,server
+Keywords: fastapi,jupyter,plugins,server
 Requires-Python: >=3.8
-Requires-Dist: fastapi>=0.87.0
-Requires-Dist: fps-auth-base>=0.0.42
-Requires-Dist: fps-contents>=0.0.42
-Requires-Dist: fps-kernels>=0.0.42
-Requires-Dist: fps-nbconvert>=0.0.42
-Requires-Dist: fps-terminals>=0.0.42
-Requires-Dist: fps-uvicorn>=0.0.19
-Requires-Dist: fps-yjs>=0.0.42
-Requires-Dist: fps>=0.0.21
+Requires-Dist: asphalt-web[fastapi]<2,>=1.1.0
+Requires-Dist: asphalt<5,>=4.11.0
+Requires-Dist: fastapi<1,>=0.95.0
+Requires-Dist: fps-contents
+Requires-Dist: fps-kernels
+Requires-Dist: fps-nbconvert
+Requires-Dist: fps-terminals
+Requires-Dist: fps-yjs
+Requires-Dist: jupyverse-api
+Requires-Dist: rich-click<2,>=1.6.1
 Provides-Extra: auth
-Requires-Dist: fps-auth>=0.0.42; extra == 'auth'
+Requires-Dist: fps-auth; extra == 'auth'
 Provides-Extra: auth-fief
-Requires-Dist: fps-auth-fief>=0.0.42; extra == 'auth-fief'
+Requires-Dist: fps-auth-fief; extra == 'auth-fief'
 Provides-Extra: docs
 Requires-Dist: mkdocs; extra == 'docs'
 Requires-Dist: mkdocs-material; extra == 'docs'
 Provides-Extra: jupyterlab
-Requires-Dist: fps-jupyterlab>=0.0.42; extra == 'jupyterlab'
+Requires-Dist: fps-jupyterlab; extra == 'jupyterlab'
 Provides-Extra: noauth
-Requires-Dist: fps-noauth>=0.0.42; extra == 'noauth'
+Requires-Dist: fps-noauth; extra == 'noauth'
 Provides-Extra: retrolab
-Requires-Dist: fps-retrolab>=0.0.42; extra == 'retrolab'
+Requires-Dist: fps-retrolab; extra == 'retrolab'
 Provides-Extra: test
+Requires-Dist: httpx; extra == 'test'
+Requires-Dist: httpx-ws; extra == 'test'
 Requires-Dist: ipykernel; extra == 'test'
 Requires-Dist: mypy; extra == 'test'
 Requires-Dist: pytest; extra == 'test'

{jupyverse-0.0.50 → jupyverse-0.1.2}/binder/jupyter_notebook_config.py

@@ -1,11 +1,10 @@
 jupyverse_jlab_command = " ".join(
     [
         "jupyverse",
-        "--no-open-browser",
-        "--auth.mode=noauth",
-        "--lab.collaborative",
-        "--retrolab.enabled=false",
-        "--lab.base_url={base_url}jupyverse-jlab/",
+        "--set auth.mode=noauth",
+        "--set frontend.collaborative=true",
+        "--set frontend.base_url={base_url}jupyverse-jlab/",
+        "--disable retrolab",
         "--port={port}",
     ]
     + [">jupyverse_jlab.log 2>&1"]
@@ -15,11 +14,10 @@ jupyverse_jlab_command = " ".join(
 jupyverse_rlab_command = " ".join(
     [
         "jupyverse",
-        "--no-open-browser",
-        "--auth.mode=noauth",
-        "--lab.collaborative",
-        "--jupyterlab.enabled=false",
-        "--lab.base_url={base_url}jupyverse-rlab/",
+        "--set auth.mode=noauth",
+        "--set frontend.collaborative=true",
+        "--set frontend.base_url={base_url}jupyverse-rlab/",
+        "--disable jupyterlab",
         "--port={port}",
     ]
     + [">jupyverse_rlab.log 2>&1"]

{jupyverse-0.0.50 → jupyverse-0.1.2}/binder/postBuild

@@ -9,4 +9,5 @@ python -m pip install -e plugins/terminals
 python -m pip install -e plugins/nbconvert
 python -m pip install -e plugins/yjs
 python -m pip install -e plugins/auth
+python -m pip install -e jupyverse_api
 python -m pip install -e .

jupyverse-0.1.2/config.yaml

@@ -0,0 +1,52 @@
+---
+component:
+  type: jupyverse
+  components:
+    app:
+      type: app
+    auth:
+      type: auth
+    #auth:
+    #  type: auth_fief
+    #auth:
+    #  type: noauth
+    contents:
+        type: contents
+    frontend:
+      type: frontend
+    lab:
+      type: lab
+    jupyterlab:
+      type: jupyterlab
+    kernels:
+      type: kernels
+    login:
+      type: login
+    nbconvert:
+      type: nbconvert
+    resource_usage:
+      type: resource_usage
+      track_cpu_percent: true
+    #retrolab:
+    #  type: retrolab
+    terminals:
+      type: terminals
+    yjs:
+      type: yjs
+
+logging:
+  version: 1
+  disable_existing_loggers: false
+  formatters:
+    default:
+      format: '[%(asctime)s %(levelname)s] %(message)s'
+  handlers:
+    console:
+      class: logging.StreamHandler
+      formatter: default
+  root:
+    handlers: [console]
+    level: INFO
+  loggers:
+    webnotifier:
+      level: DEBUG

jupyverse-0.1.2/docs/install.md

@@ -0,0 +1,119 @@
+Jupyverse can be installed to run either [JupyterLab](https://jupyterlab.readthedocs.io) or [RetroLab](https://github.com/jupyterlab/retrolab).
+
+## With `pip`
+
+For the JupyterLab frontend:
+```bash
+pip install "jupyverse[jupyterlab,auth]"
+```
+Or for the RetroLab frontend:
+```bash
+pip install "jupyverse[retrolab,auth]"
+```
+
+## With `micromamba`
+
+We recommend using `micromamba` to manage [conda-forge](https://conda-forge.org) environments
+(see `micromamba`'s
+[installation instructions](https://mamba.readthedocs.io/en/latest/installation.html#micromamba)).
+First create an environment, here called `jupyverse`, and activate it:
+```bash
+micromamba create -n jupyverse
+micromamba activate jupyverse
+```
+Then install Jupyverse and the desired plugins.
+
+For the JupyterLab frontend:
+```bash
+micromamba install -c conda-forge jupyverse fps-jupyterlab fps-auth
+```
+Or for the RetroLab frontend:
+```bash
+micromamba install -c conda-forge jupyverse fps-retrolab fps-auth
+```
+
+## Development install
+
+You first need to clone the repository:
+```bash
+git clone https://github.com/jupyter-server/jupyverse.git
+cd jupyverse
+```
+Jupyverse uses [Hatch](https://github.com/pypa/hatch) for project management.
+Hatch can handle multiple environments in parallel, allowing for easy development
+and testing of different frontends, authentication methods, and incompatible
+plugins.
+
+We recommend working in an isolated conda environment, in which hatch will manage
+sub-environments:
+```bash
+micromamba create -n jupyverse-dev
+micromamba activate jupyverse-dev
+micromamba install -c conda-forge hatch
+```
+Entering `hatch env show` will show the available environments:
+```text
+                Standalone
+┏━━━━━━━━━┳━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━┓
+┃ Name    ┃ Type    ┃ Features ┃ Scripts ┃
+┡━━━━━━━━━╇━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━┩
+│ default │ virtual │          │         │
+├─────────┼─────────┼──────────┼─────────┤
+│ docs    │ virtual │ docs     │ build   │
+│         │         │          │ serve   │
+└─────────┴─────────┴──────────┴─────────┘
+                              Matrices
+┏━━━━━━┳━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━┳━━━━━━━━━━━┓
+┃ Name ┃ Type    ┃ Envs                     ┃ Features ┃ Scripts   ┃
+┡━━━━━━╇━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━╇━━━━━━━━━━━┩
+│ dev  │ virtual │ dev.jupyterlab-noauth    │ test     │ lint      │
+│      │         │ dev.jupyterlab-auth      │          │ test      │
+│      │         │ dev.jupyterlab-auth_fief │          │ typecheck │
+│      │         │ dev.retrolab-noauth      │          │           │
+│      │         │ dev.retrolab-auth        │          │           │
+│      │         │ dev.retrolab-auth_fief   │          │           │
+└──────┴─────────┴──────────────────────────┴──────────┴───────────┘
+```
+!!! note
+    The `default` environment will install all the plugins from PyPI, **not** from
+    your local repository. The `dev` environment installs all plugins in editable mode
+    from your local repository. So you want to use the `dev` environment.
+
+Currently, the `dev` environment matrix consists of all combinations of frontends
+(`jupyterlab`, `retrolab`) and authentication methods (`noauth`, `auth`, `auth_fief`),
+which leads to six environments.
+
+A number of scripts are available in the `dev` environments. They can be
+executed using `hatch run {env}:{script}`. You can also execute anything that you would
+execute in your shell. For instance, to run Jupyverse for the `jupyterlab` frontend and
+without authentication, enter:
+```bash
+hatch run dev.jupyterlab-noauth:jupyverse
+```
+
+Tests should be executed using the `dev.jupyterlab-auth` environment:
+```bash
+hatch run dev.jupyterlab-auth:test
+```
+Sometimes it is easier to directly be in the environment, without having to prefix everything
+with `hatch run {env}:`. To do so, just enter:
+```bash
+hatch -e dev.jupyterlab-auth shell
+```
+You can now directly enter shell commands, e.g. `jupyverse`.
+To exit the environment, just enter `exit`.
+
+As the plugins are all installed in editable mode, you could start an instance
+of Jupyverse in each environment and see how code changes interact with plugins at
+the same time.
+
+Finally, `hatch run docs:serve` can be used to view documentation changes.
+
+If you ever need to start from a fresh environment, you can remove them individually:
+```bash
+hatch env remove dev.jupyterlab-auth
+```
+Or globally:
+```bash
+hatch env prune
+```

{jupyverse-0.0.50 → jupyverse-0.1.2}/docs/plugins/auth.md

@@ -1,24 +1,12 @@
-The auth plugin has a special place because every other plugin depends on it for security reasons. One and only one auth plugin must be installed. It is possible to use any auth plugin as long as it follows a defined [API](./#api). Jupyverse comes with three auth plugins: [fps-noauth](./#fps-noauth), [fps-auth](./#fps-auth) and [fps-auth-fief](./#fps-auth-fief).
+The auth plugin has a special place because almost every other plugin depends on it for security reasons. It is possible to use any auth plugin as long as it follows a defined [API](./#api). Jupyverse comes with three auth plugins: [fps-noauth](./#fps-noauth), [fps-auth](./#fps-auth) and [fps-auth-fief](./#fps-auth-fief).
 
 ## API
 
-An auth plugin must register the following objects in the `jupyverse_auth` entry point group:
+An auth plugin must implement a class that inherits from the `jupyverse_api.Auth` abstract base class. This class must have the following methods:
 
-- `User`: a [Pydantic](https://pydantic-docs.helpmanual.io) model for a user. It must have at least the following fields:
+- `current_user`: a method that optionally takes in required permissions for the HTTP endpoint, and returns a FastAPI dependency for the currently logged in user after checking that they have permissions. The user must have all the required permissions (if any), otherwise a `403` HTTP code is returned.
 ```py
-class User(BaseModel):
-    username: str = ""
-    name: str = ""
-    display_name: str = ""
-    initials: Optional[str] = None
-    color: Optional[str] = None
-    avatar_url: Optional[str] = None
-    workspace: str = "{}"
-    settings: str = "{}"
-```
-- `current_user`: a callable that optionally takes in required permissions for the HTTP endpoint, and returns a FastAPI dependency for the currently logged in user after checking that they have permissions. The user must have all the required permissions (if any), otherwise a `403` HTTP code is returned.
-```py
-def current_user(permissions: Optional[Dict[str, List[str]]] = None):
+def current_user(self, permissions: Optional[Dict[str, List[str]]] = None) -> Callable:
     async def _current_user():
         if user_has_permissions(permissions):
             return User(**{"username": "John"})
@@ -26,9 +14,9 @@ def current_user(permissions: Optional[Dict[str, List[str]]] = None):
 
     return _current_user
 ```
-- `websocket_auth`: a callable that optionally takes in required permissions for the WebSocket endpoint, and returns a FastAPI dependency for a tuple consisting of the WebSocket object and the checked permissions, if the WebSocket is accepted, or `None` if the WebSocket is refused. If the WebSocket is refused, the dependency has to close it, otherwise it has to be accepted by the caller. The user must have at least one of the required permissions (if any) for the WebSocket to be accepted.
+- `websocket_auth`: a method that optionally takes in required permissions for the WebSocket endpoint, and returns a FastAPI dependency for a tuple consisting of the WebSocket object and the checked permissions, if the WebSocket is accepted, or `None` if the WebSocket is refused. If the WebSocket is refused, the dependency has to close the connection, otherwise it has to be accepted by the caller. The user must have at least one of the required permissions (if any) for the WebSocket to be accepted.
 ```py
-def websocket_auth(permissions: Optional[Dict[str, List[str]]] = None):
+def websocket_auth(self, permissions: Optional[Dict[str, List[str]]] = None) -> Callable[[], Optional[Tuple[Any, Dict[str, List[str]]]]]:
     async def _websocket_auth(websocket: WebSocket) -> Optional[Tuple[WebSocket, Optional[Dict[str, List[str]]]]]:
         accept_websocket = False
         checked_permissions: Optional[Dict[str, List[str]]] = None
@@ -54,7 +42,7 @@ def websocket_auth(permissions: Optional[Dict[str, List[str]]] = None):
 ```
 - `update_user`: a FastAPI dependency for a coroutine that takes in user data to update.
 ```py
-async def update_user():
+async def update_user(self) -> Callable:
     async def _update_user(data: Dict[str, Any]):
         await update_user_profile(data)
 
@@ -67,6 +55,7 @@ async def update_user():
 
 !!! note
     This can be a security risk! Use it only if you want all endpoints to be accessible by any user.
+    Typically, only do that on your personal computer.
 
 ## fps-auth
 

{jupyverse-0.0.50 → jupyverse-0.1.2}/docs/usage/multi_user.md

@@ -4,7 +4,7 @@ Jupyverse supports multiple users working collaboratively. Depending on the chos
 
 The first thing to do is to allow collaborative editing when launching Jupyverse:
 ```bash
-jupyverse --lab.collaborative
+jupyverse --set frontend.collaborative=true
 ```
 The collaborative mode will handle users through the [auth plugin](../../plugins/auth) you have installed, which will provide user identity.
 
@@ -18,7 +18,7 @@ The real power of collaborative editing comes with proper user authentication an
 
 It can be enabled by launching:
 ```bash
-jupyverse --lab.collaborative --auth.mode=token
+jupyverse --set frontend.collaborative=true --set auth.mode=token
 ```
 This uses the token authentication, the same as described in the [single user mode](../single_user/#token-authentication). This means that users don't get a "real" identity, since all they provide is the shared token. For this reason, we call them "anonymous users".
 
@@ -26,14 +26,14 @@ They can still be differenciated, and they will each get assigned a different na
 
 You can also disable token authentication in collaborative mode, just as in [single user mode](../single_user/#no-authentication):
 ```bash
-jupyverse --lab.collaborative --auth.mode=noauth
+jupyverse --set frontend.collaborative=true --set auth.mode=noauth
 ```
 
 #### User authentication
 
 It can be enabled by launching:
 ```bash
-jupyverse --lab.collaborative --auth.mode=user
+jupyverse --set frontend.collaborative=true --set auth.mode=user
 ```
 In this mode, users have to be registered in a database before logging in. User information includes a user name and a password, that will be asked at login. It can also include a "real" name, that will be displayed when editing documents, and permissions that will determine if they can see or edit a document, run some code, etc.
 
@@ -45,5 +45,5 @@ Fief allows to manage users using a dashboard. It supports permissions and Role-
 
 Just launch in a terminal:
 ```bash
-jupyverse --lab.collaborative
+jupyverse --set frontend.collaborative=true
 ```

{jupyverse-0.0.50 → jupyverse-0.1.2}/docs/usage/single_user.md

@@ -1,4 +1,4 @@
-The single user mode is usually meant to run e.g. JupyterLab as a desktop application. Under the hood, a server and a web front-end are launched, but it should be transparent to the user, who just interacts with a "web app".
+The single user mode is usually meant to run e.g. JupyterLab as a desktop application. Under the hood, a server and a web frontend are launched, but it should be transparent to the user, who just interacts with a "web app".
 
 Even though Jupyverse most often runs on a personal computer in this mode, it is not limited to this use case. For instance, if it runs on a network, it could be accessed by other people. It is thus important to limit access to the server, especially considering that Jupyter users can run potentially harmful code.
 
@@ -8,15 +8,15 @@ This is why Jupyverse comes with built-in authentication. Please refer to the [a
 
 This is the default mode when launching Jupyverse, just enter in a terminal:
 ```bash
-jupyverse
-# same as: jupyverse --auth.mode=token
+jupyverse --open-browser
+# same as: jupyverse --set auth.mode=token --open-browser
 ```
 This should open a new window in a browser, and load JupyterLab or RetroLab, depending on the front-end you chose to install (see [Install](../../install)).
 
 If you look at the terminal, you should see among other things:
 ```
-[I 2022-08-30 09:37:55 auth] To access the server, copy and paste this URL:
-[I 2022-08-30 09:37:55 auth] http://127.0.0.1:8000/?token=59665677-06c6-4530-ab67-d26cd8865d8b
+[2023-04-05 16:22:39,137 INFO] To access the server, copy and paste this URL:
+[2023-04-05 16:22:39,137 INFO] http://127.0.0.1:8000/?token=69ce8ccee10d4388b00b3df0d9849700
 ```
 This is the URL the browser window was opened with, and you can see that a `token` was passed as a query parameter. When the request is made to the server, the token is checked and a cookie is set in the browser. The user is now authenticated and doesn't need to pass the token again in other requests.
 
@@ -28,5 +28,5 @@ If you trust everybody who can access the server, you can launch Jupyverse with
 
 Enter in a terminal:
 ```bash
-jupyverse --auth.mode=noauth
+jupyverse --set auth.mode=noauth --open-browser
 ```

jupyverse-0.1.2/jupyverse/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

jupyverse-0.1.2/jupyverse/cli.py

@@ -0,0 +1,97 @@
+import pkg_resources
+from typing import List
+
+import rich_click as click
+from asphalt.core.cli import run
+
+
+@click.command()
+@click.option(
+    "--open-browser",
+    is_flag=True,
+    show_default=True,
+    default=False,
+    help="Open a browser window.",
+)
+@click.option(
+    "--host",
+    type=str,
+    default="127.0.0.1",
+    help="The host URL.",
+)
+@click.option(
+    "--port",
+    type=int,
+    default=8000,
+    help="The host port.",
+)
+@click.option(
+    "--set",
+    "set_",
+    multiple=True,
+    type=str,
+    help="Set configuration.",
+)
+@click.option(
+    "--disable",
+    multiple=True,
+    type=str,
+    help="Disable plugin.",
+)
+def main(
+    open_browser: bool,
+    host: str,
+    port: int,
+    set_: List[str],
+    disable: List[str],
+) -> None:
+    set_ = list(set_)
+    for i, s in enumerate(set_):
+        set_[i] = f"component.components.{s}"
+    set_.append(f"component.open_browser={open_browser}")
+    set_.append(f"component.host={host}")
+    set_.append(f"component.port={port}")
+    config = get_config(disable)
+    run.callback(
+        unsafe=False,
+        loop=None,
+        set_=set_,
+        service=None,
+        configfile=[config],
+    )  # type: ignore
+
+
+def get_config(disable: List[str]) -> str:
+    jupyverse_components = [
+        ep.name
+        for ep in pkg_resources.iter_entry_points(group="jupyverse.components")
+        if ep.name not in disable
+    ]
+
+    config = ["component:\n  type: jupyverse\n  components:\n"]
+    for component in jupyverse_components:
+        config.append(f"    {component}:\n      type: {component}\n")
+
+    config.append(
+        """
+logging:
+  version: 1
+  disable_existing_loggers: false
+  formatters:
+    default:
+      format: '[%(asctime)s %(levelname)s] %(message)s'
+  handlers:
+    console:
+      class: logging.StreamHandler
+      formatter: default
+  root:
+    handlers: [console]
+    level: INFO
+  loggers:
+    webnotifier:
+      level: DEBUG
+        """
+    )
+
+    config_str = "".join(config)
+    return config_str

jupyverse-0.1.2/jupyverse_api/README.md

@@ -0,0 +1,3 @@
+# Jupyverse API
+
+The public API for Jupyverse.

jupyverse-0.1.2/jupyverse_api/jupyverse_api/__init__.py

@@ -0,0 +1,42 @@
+from typing import Dict
+
+from pydantic import BaseModel, Extra
+
+from .app import App
+
+
+__version__ = "0.1.2"
+
+
+class Singleton(type):
+    _instances: Dict = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+class Config(BaseModel):
+    class Config:
+        extra = Extra.forbid
+
+
+class Router:
+    _app: App
+
+    def __init__(
+        self,
+        app: App,
+    ) -> None:
+        self._app = app
+
+    @property
+    def _type(self):
+        return self.__class__.__name__
+
+    def include_router(self, router, **kwargs):
+        self._app._include_router(router, self._type, **kwargs)
+
+    def mount(self, path: str, *args, **kwargs) -> None:
+        self._app._mount(path, self._type, *args, **kwargs)