jupyverse 0.1.2__tar.gz → 0.1.4__tar.gz

{jupyverse-0.1.2 → jupyverse-0.1.4}/.github/workflows/main.yml

@@ -41,7 +41,12 @@ jobs:
 
     - name: Check types
       run: |
+        hatch run dev.jupyterlab-noauth:typecheck
+        hatch run dev.jupyterlab-noauth:typecheck
         hatch run dev.jupyterlab-auth:typecheck
+        hatch run dev.retrolab-auth_fief:typecheck
+        hatch run dev.retrolab-auth:typecheck
+        hatch run dev.retrolab-auth_fief:typecheck
 
     - name: Run tests
       run: |

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

@@ -21,7 +21,7 @@ repos:
       - id: black
 
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.0.260
+    rev: v0.0.261
     hooks:
       - id: ruff
         args: ["--fix"]

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

@@ -2,12 +2,43 @@
 
 <!-- <START NEW CHANGELOG ENTRY> -->
 
-## 0.1.2
+## 0.1.4
 
-No merged PRs
+([Full Changelog](https://github.com/jupyter-server/jupyverse/compare/v0.1.3...a42f7c4d0e951d620108afb4ca25e57da5bae2a1))
+
+### Merged PRs
+
+- Move routes to jupyverse_api [#293](https://github.com/jupyter-server/jupyverse/pull/293) ([@davidbrochart](https://github.com/davidbrochart))
+- Add microservices doc, move CLI to jupyverse_api [#292](https://github.com/jupyter-server/jupyverse/pull/292) ([@davidbrochart](https://github.com/davidbrochart))
+- Don't ignore types for fief_client [#290](https://github.com/jupyter-server/jupyverse/pull/290) ([@davidbrochart](https://github.com/davidbrochart))
+- Update README [#288](https://github.com/jupyter-server/jupyverse/pull/288) ([@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-04-06&to=2023-04-18&type=c))
+
+[@davidbrochart](https://github.com/search?q=repo%3Ajupyter-server%2Fjupyverse+involves%3Adavidbrochart+updated%3A2023-04-06..2023-04-18&type=Issues) | [@pre-commit-ci](https://github.com/search?q=repo%3Ajupyter-server%2Fjupyverse+involves%3Apre-commit-ci+updated%3A2023-04-06..2023-04-18&type=Issues)
 
 <!-- <END NEW CHANGELOG ENTRY> -->
 
+## 0.1.3
+
+([Full Changelog](https://github.com/jupyter-server/jupyverse/compare/v0.1.2...b5faf93e3296d855c7ebeda0c25e9861400ad469))
+
+### Merged PRs
+
+- Add fps-lab and fps-frontend dependencies to jupyverse [#287](https://github.com/jupyter-server/jupyverse/pull/287) ([@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-04-06&to=2023-04-06&type=c))
+
+[@davidbrochart](https://github.com/search?q=repo%3Ajupyter-server%2Fjupyverse+involves%3Adavidbrochart+updated%3A2023-04-06..2023-04-06&type=Issues)
+
+## 0.1.2
+
+No merged PRs
+
 ## 0.1.1
 
 ([Full Changelog](https://github.com/jupyter-server/jupyverse/compare/v0.0.50...254a3dfd5f6851e2e79406fab934c8361399ffb6))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jupyverse
-Version: 0.1.2
+Version: 0.1.4
 Summary: A set of FPS plugins implementing a Jupyter server
 Project-URL: Homepage, https://jupyter.org
 Author-email: Jupyter Development Team <jupyter@googlegroups.com>
@@ -8,29 +8,27 @@ License: BSD 3-Clause License
 License-File: COPYING.md
 Keywords: fastapi,jupyter,plugins,server
 Requires-Python: >=3.8
-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
+Requires-Dist: fps-contents<1,>=0.1.2
+Requires-Dist: fps-frontend<1,>=0.1.2
+Requires-Dist: fps-kernels<1,>=0.1.2
+Requires-Dist: fps-lab<1,>=0.1.2
+Requires-Dist: fps-nbconvert<1,>=0.1.2
+Requires-Dist: fps-terminals<1,>=0.1.2
+Requires-Dist: fps-yjs<1,>=0.1.2
+Requires-Dist: jupyverse-api<1,>=0.1.2
 Provides-Extra: auth
-Requires-Dist: fps-auth; extra == 'auth'
+Requires-Dist: fps-auth<1,>=0.1.2; extra == 'auth'
 Provides-Extra: auth-fief
-Requires-Dist: fps-auth-fief; extra == 'auth-fief'
+Requires-Dist: fps-auth-fief<1,>=0.1.2; extra == 'auth-fief'
 Provides-Extra: docs
 Requires-Dist: mkdocs; extra == 'docs'
 Requires-Dist: mkdocs-material; extra == 'docs'
 Provides-Extra: jupyterlab
-Requires-Dist: fps-jupyterlab; extra == 'jupyterlab'
+Requires-Dist: fps-jupyterlab<1,>=0.1.2; extra == 'jupyterlab'
 Provides-Extra: noauth
-Requires-Dist: fps-noauth; extra == 'noauth'
+Requires-Dist: fps-noauth<1,>=0.1.2; extra == 'noauth'
 Provides-Extra: retrolab
-Requires-Dist: fps-retrolab; extra == 'retrolab'
+Requires-Dist: fps-retrolab<1,>=0.1.2; extra == 'retrolab'
 Provides-Extra: test
 Requires-Dist: httpx; extra == 'test'
 Requires-Dist: httpx-ws; extra == 'test'
@@ -49,7 +47,7 @@ Description-Content-Type: text/markdown
 
 # jupyverse
 
-A set of [FPS](https://github.com/jupyter-server/fps) plugins implementing a Jupyter server.
+A set of [Asphalt](https://asphalt.readthedocs.io) components implementing a Jupyter server.
 
 Try it online:
 - JupyterLab frontend: [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/jupyter-server/jupyverse/HEAD?urlpath=jupyverse-jlab)

{jupyverse-0.1.2 → jupyverse-0.1.4}/README.md

@@ -3,7 +3,7 @@
 
 # jupyverse
 
-A set of [FPS](https://github.com/jupyter-server/fps) plugins implementing a Jupyter server.
+A set of [Asphalt](https://asphalt.readthedocs.io) components implementing a Jupyter server.
 
 Try it online:
 - JupyterLab frontend: [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/jupyter-server/jupyverse/HEAD?urlpath=jupyverse-jlab)

jupyverse-0.1.4/docs/usage/microservices.md

@@ -0,0 +1,100 @@
+Jupyverse's modularity allows to run services quite independently from each other, following a microservice architecture. This can be useful when resources are provided by separate systems, or just to have a clear separation of concerns. For instance, you may want to host the contents on AWS and the kernels on Google Cloud, or on different machines in your private network. One way to achieve this is to use a reverse proxy that will forward client requests to the corresponding Jupyverse server. We will show how to do that using [Nginx](https://en.wikipedia.org/wiki/Nginx) on a single computer with local servers. This can serve as a basis for more complicated architectures involving remote servers.
+
+## Nginx setup
+
+Nginx is a web server that can also be used as a reverse proxy. We will use it to forward client requests to separate Jupyverse servers, based on the request URL.
+
+First, install Nginx in its own environment:
+```bash
+micromamba create -n nginx
+micromamba activate nginx
+micromamba install -c conda-forge nginx
+```
+We will just edit the default configuration file at `~/micromamba/envs/nginx/etc/nginx/sites.d/default-site.conf` with the following:
+```
+server {
+    listen       8000;
+    server_name  localhost;
+
+    location / {
+        proxy_pass http://localhost:8001;
+    }
+
+    location /api/kernelspecs {
+        proxy_pass http://localhost:8002;
+    }
+    location /api/kernels {
+        proxy_pass http://localhost:8002;
+    }
+    location ~ \/api\/kernels\/.+\/channels {
+        proxy_pass http://localhost:8002;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "Upgrade";
+    }
+    location /api/sessions {
+        proxy_pass http://localhost:8002;
+    }
+}
+```
+Our Nginx server will listen at `http://localhost:8000`. This is the URL the client will see, i.e. the one we enter in the browser.
+
+Our Jupyverse servers will run on:
+
+- `http://localhost:8001` for everything except the kernels API. This means that this server doesn't have the ability to run user code, and thus cannot be used to execute a notebook.
+- `http://localhost:8002` for the kernels API. This server only deals with executing code in a kernel. It cannot serve JupyterLab's UI, for instance.
+
+Together, these Jupyverse servers can serve a full JupyterLab API. But because they run on different machines (not exactly in this case, since ports `8001` and `8002` are on the same machine, but let's pretend), we need to make them appear as a unique server. That is the role of the reverse proxy server.
+
+!!! note
+    WebSocket forwarding requires extra-configuration. Here, we use a `regex` to redirect `/api/kernels/{kernel_id}/channels`, which is the WebSocket endpoint for the kernel protocol. We also set the `Upgrade` and `Connection` headers used to upgrade the connection from HTTP to WebSocket.
+
+We can now run our reverse proxy server. Just enter:
+```bash
+nginx
+```
+
+## Jupyverse setup
+
+### Server 1: everything but kernels
+
+Let's create a new environment in a new terminal:
+```bash
+micromamba create -n jupyverse1
+micromamba activate jupyverse1
+micromamba install -c conda-forge python
+```
+Since we don't want to install the fully-fledged Jupyverse server, we will install the required plugins individually:
+```bash
+pip install fps-auth
+pip install fps-contents
+pip install fps-frontend
+pip install fps-lab
+pip install fps-jupyterlab
+pip install fps-login
+```
+Now just launch Jupyverse at port `8001`:
+```bash
+jupyverse --port=8001
+```
+If you open your browser at `http://127.0.0.1:8000` (the URL of the Nginx reverse proxy), you should see the JupyterLab UI you're used to. But if you look closer, you can see that there is no icon for kernels in the launcher tab. And in the terminal where you launched Jupyverse, you will see a bunch of `404` for requests at e.g. `GET /api/kernels`. This is expected, because we didn't install the kernels plugin. You can still use JupyterLab if you don't want to execute a notebook, for instance. But let's close it for now, and install the kernels plugin in another Jupyverse instance.
+
+### Server 2: the kernels API
+
+Let's create a new environment in a new terminal:
+```bash
+micromamba create -n jupyverse2
+micromamba activate jupyverse2
+micromamba install -c conda-forge python
+```
+This time, we only want to install the kernels plugin. It also requires an authentication system (for the sake of simplicity we will install `fps-noauth` which gives unrestricted access) and the frontend plugin. Let's not forget to install a kernel, such as `ipykernel`:
+```bash
+pip install fps-kernels
+pip install fps-noauth
+pip install fps-frontend
+pip install ipykernel
+```
+Launch Juyverse at port `8002`:
+```bash
+jupyverse --port=8002
+```
+Now if you re-open a browser at `http://127.0.0.1:8000`, you should be able to create or open a notebook, and execute it.

jupyverse-0.1.4/jupyverse/__init__.py

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

{jupyverse-0.1.2 → jupyverse-0.1.4}/jupyverse_api/jupyverse_api/__init__.py

@@ -5,7 +5,7 @@ from pydantic import BaseModel, Extra
 from .app import App
 
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 
 
 class Singleton(type):

jupyverse-0.1.4/jupyverse_api/jupyverse_api/contents/__init__.py

@@ -0,0 +1,185 @@
+import asyncio
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+from fastapi import APIRouter, Depends, Request, Response
+from jupyverse_api import Router
+
+from .models import Checkpoint, Content, SaveContent
+from ..auth import Auth, User
+from ..app import App
+
+
+class FileIdManager(ABC):
+    stop_watching_files: asyncio.Event
+    stopped_watching_files: asyncio.Event
+
+    @abstractmethod
+    async def get_path(self, file_id: str) -> str:
+        ...
+
+    @abstractmethod
+    async def get_id(self, file_path: str) -> str:
+        ...
+
+
+class Contents(Router, ABC):
+    def __init__(self, app: App, auth: Auth):
+        super().__init__(app=app)
+
+        router = APIRouter()
+
+        @router.post(
+            "/api/contents/{path:path}/checkpoints",
+            status_code=201,
+        )
+        async def create_checkpoint(
+            path, user: User = Depends(auth.current_user(permissions={"contents": ["write"]}))
+        ) -> Checkpoint:
+            return await self.create_checkpoint(path, user)
+
+        @router.post(
+            "/api/contents{path:path}",
+            status_code=201,
+        )
+        async def create_content(
+            path: Optional[str],
+            request: Request,
+            user: User = Depends(auth.current_user(permissions={"contents": ["write"]})),
+        ) -> Content:
+            return await self.create_content(path, request, user)
+
+        @router.get("/api/contents")
+        async def get_root_content(
+            content: int,
+            user: User = Depends(auth.current_user(permissions={"contents": ["read"]})),
+        ) -> Content:
+            return await self.get_root_content(content, user)
+
+        @router.get("/api/contents/{path:path}/checkpoints")
+        async def get_checkpoint(
+            path, user: User = Depends(auth.current_user(permissions={"contents": ["read"]}))
+        ) -> List[Checkpoint]:
+            return await self.get_checkpoint(path, user)
+
+        @router.get("/api/contents/{path:path}")
+        async def get_content(
+            path: str,
+            content: int = 0,
+            user: User = Depends(auth.current_user(permissions={"contents": ["read"]})),
+        ) -> Content:
+            return await self.get_content(path, content, user)
+
+        @router.put("/api/contents/{path:path}")
+        async def save_content(
+            path,
+            request: Request,
+            response: Response,
+            user: User = Depends(auth.current_user(permissions={"contents": ["write"]})),
+        ) -> Content:
+            return await self.save_content(path, request, response, user)
+
+        @router.delete(
+            "/api/contents/{path:path}",
+            status_code=204,
+        )
+        async def delete_content(
+            path,
+            user: User = Depends(auth.current_user(permissions={"contents": ["write"]})),
+        ):
+            return await self.delete_content(path, user)
+
+        @router.patch("/api/contents/{path:path}")
+        async def rename_content(
+            path,
+            request: Request,
+            user: User = Depends(auth.current_user(permissions={"contents": ["write"]})),
+        ) -> Content:
+            return await self.rename_content(path, request, user)
+
+        self.include_router(router)
+
+    @property
+    @abstractmethod
+    def file_id_manager(self) -> FileIdManager:
+        ...
+
+    @abstractmethod
+    async def read_content(
+        self, path: Union[str, Path], get_content: bool, as_json: bool = False
+    ) -> Content:
+        ...
+
+    @abstractmethod
+    async def write_content(self, content: Union[SaveContent, Dict]) -> None:
+        ...
+
+    @abstractmethod
+    async def create_checkpoint(
+        self,
+        path,
+        user: User,
+    ) -> Checkpoint:
+        ...
+
+    @abstractmethod
+    async def create_content(
+        self,
+        path: Optional[str],
+        request: Request,
+        user: User,
+    ) -> Content:
+        ...
+
+    @abstractmethod
+    async def get_root_content(
+        self,
+        content: int,
+        user: User,
+    ) -> Content:
+        return await self.get_root_content(content, user)
+
+    @abstractmethod
+    async def get_checkpoint(
+        self,
+        path,
+        user: User,
+    ) -> List[Checkpoint]:
+        ...
+
+    @abstractmethod
+    async def get_content(
+        self,
+        path: str,
+        content: int,
+        user: User,
+    ) -> Content:
+        ...
+
+    @abstractmethod
+    async def save_content(
+        self,
+        path,
+        request: Request,
+        response: Response,
+        user: User,
+    ) -> Content:
+        ...
+
+    @abstractmethod
+    async def delete_content(
+        self,
+        path,
+        user: User,
+    ):
+        ...
+
+    @abstractmethod
+    async def rename_content(
+        self,
+        path,
+        request: Request,
+        user: User,
+    ) -> Content:
+        ...

{jupyverse-0.1.2 → jupyverse-0.1.4}/jupyverse_api/jupyverse_api/contents/models.py

@@ -3,6 +3,11 @@ from typing import Dict, List, Optional, Union
 from pydantic import BaseModel
 
 
+class Checkpoint(BaseModel):
+    id: str
+    last_modified: str
+
+
 class Content(BaseModel):
     name: str
     path: str
@@ -16,8 +21,18 @@ class Content(BaseModel):
     type: str
 
 
+class CreateContent(BaseModel):
+    ext: Optional[str]
+    path: str
+    type: str
+
+
 class SaveContent(BaseModel):
     content: Optional[Union[str, Dict]]
     format: str
     path: str
     type: str
+
+
+class RenameContent(BaseModel):
+    path: str

jupyverse-0.1.4/jupyverse_api/jupyverse_api/jupyterlab/__init__.py

@@ -0,0 +1,90 @@
+from abc import ABC, abstractmethod
+
+from fastapi import APIRouter, Depends, Request
+from fastapi.responses import HTMLResponse
+from jupyverse_api import Config, Router
+
+from ..auth import Auth, User
+from ..app import App
+
+
+class JupyterLab(Router, ABC):
+    def __init__(self, app: App, auth: Auth):
+        super().__init__(app)
+
+        router = APIRouter()
+
+        @router.get("/lab")
+        async def get_lab(
+            user: User = Depends(auth.current_user()),
+        ):
+            return await self.get_lab(user)
+
+        @router.get("/lab/tree/{path:path}")
+        async def load_workspace(
+            path,
+        ):
+            return await self.load_workspace(path)
+
+        @router.get("/lab/api/workspaces/{name}")
+        async def get_workspace_data(user: User = Depends(auth.current_user())):
+            return await self.get_workspace_data(user)
+
+        @router.put(
+            "/lab/api/workspaces/{name}",
+            status_code=204,
+        )
+        async def set_workspace(
+            request: Request,
+            user: User = Depends(auth.current_user()),
+            user_update=Depends(auth.update_user),
+        ):
+            return await self.set_workspace(request, user, user_update)
+
+        @router.get("/lab/workspaces/{name}", response_class=HTMLResponse)
+        async def get_workspace(
+            name,
+            user: User = Depends(auth.current_user()),
+        ):
+            return await self.get_workspace(name, user)
+
+        self.include_router(router)
+
+    @abstractmethod
+    async def get_lab(
+        self,
+        user: User,
+    ):
+        ...
+
+    @abstractmethod
+    async def load_workspace(
+        self,
+        path,
+    ):
+        ...
+
+    @abstractmethod
+    async def get_workspace_data(self, user: User):
+        ...
+
+    @abstractmethod
+    async def set_workspace(
+        self,
+        request: Request,
+        user: User,
+        user_update,
+    ):
+        ...
+
+    @abstractmethod
+    async def get_workspace(
+        self,
+        name,
+        user: User,
+    ):
+        ...
+
+
+class JupyterLabConfig(Config):
+    dev_mode: bool = False