fps_lab 0.9.7__tar.gz

fps_lab-0.9.7/COPYING.md

@@ -0,0 +1,59 @@
+# Licensing terms
+
+This project is licensed under the terms of the Modified BSD License
+(also known as New or Revised or 3-Clause BSD), as follows:
+
+- Copyright (c) 2021-, Jupyter Development Team
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+Neither the name of the Jupyter Development Team nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+## About the Jupyter Development Team
+
+The Jupyter Development Team is the set of all contributors to the Jupyter project.
+This includes all of the Jupyter subprojects.
+
+The core team that coordinates development on GitHub can be found here:
+https://github.com/jupyter/.
+
+## Our Copyright Policy
+
+Jupyter uses a shared copyright model. Each contributor maintains copyright
+over their contributions to Jupyter. But, it is important to note that these
+contributions are typically only changes to the repositories. Thus, the Jupyter
+source code, in its entirety is not the copyright of any single person or
+institution. Instead, it is the collective copyright of the entire Jupyter
+Development Team. If individual contributors want to maintain a record of what
+changes/contributions they have specific copyright on, they should indicate
+their copyright in the commit message of the change, when they commit the
+change to one of the Jupyter repositories.
+
+With this in mind, the following banner should be used in any source code file
+to indicate the copyright and license terms:
+
+    # Copyright (c) Jupyter Development Team.
+    # Distributed under the terms of the Modified BSD License.

fps_lab-0.9.7/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: fps_lab
+Version: 0.9.7
+Summary: An FPS plugin for the JupyterLab/Notebook API
+Keywords: jupyter,server,fastapi,plugins
+Author: Jupyter Development Team
+Author-email: Jupyter Development Team <jupyter@googlegroups.com>
+License-Expression: BSD-3-Clause
+License-File: COPYING.md
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Dist: babel
+Requires-Dist: json5
+Requires-Dist: jupyverse-api>=0.12.2,<0.13.0
+Requires-Python: >=3.10
+Project-URL: Homepage, https://jupyter.org
+Description-Content-Type: text/markdown
+
+# fps-lab
+
+An FPS plugin for the JupyterLab/Notebook API.

fps_lab-0.9.7/README.md

@@ -0,0 +1,3 @@
+# fps-lab
+
+An FPS plugin for the JupyterLab/Notebook API.

fps_lab-0.9.7/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["uv_build"]
+build-backend = "uv_build"
+
+[project]
+name = "fps_lab"
+version = "0.9.7"
+description = "An FPS plugin for the JupyterLab/Notebook API"
+keywords = ["jupyter", "server", "fastapi", "plugins"]
+requires-python = ">=3.10"
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: BSD License",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = [
+  "babel",
+  "json5",
+  "jupyverse-api >=0.12.2,<0.13.0",
+]
+license = "BSD-3-Clause"
+license-files = ["COPYING.md"]
+
+[[project.authors]]
+name = "Jupyter Development Team"
+email = "jupyter@googlegroups.com"
+
+[project.readme]
+file = "README.md"
+content-type = "text/markdown"
+
+[project.urls]
+Homepage = "https://jupyter.org"
+
+[project.entry-points]
+"fps.modules" = {lab = "fps_lab.main:LabModule"}
+"jupyverse.modules" = {lab = "fps_lab.main:LabModule"}

fps_lab-0.9.7/src/fps_lab/__init__.py

@@ -0,0 +1,6 @@
+import importlib.metadata
+
+try:
+    __version__ = importlib.metadata.version("fps_lab")
+except importlib.metadata.PackageNotFoundError:
+    __version__ = "unknown"

fps_lab-0.9.7/src/fps_lab/main.py

@@ -0,0 +1,25 @@
+from anyio import Event, create_task_group
+from fps import Module
+from jupyverse_api.app import App
+from jupyverse_api.auth import Auth
+from jupyverse_api.frontend import FrontendConfig
+from jupyverse_api.jupyterlab import JupyterLabConfig
+from jupyverse_api.lab import Lab
+
+from .routes import _Lab
+
+
+class LabModule(Module):
+    async def prepare(self) -> None:
+        app = await self.get(App)
+        auth = await self.get(Auth)  # type: ignore[type-abstract]
+        frontend_config = await self.get(FrontendConfig)
+        jupyterlab_config = await self.get(JupyterLabConfig)
+
+        async with create_task_group() as tg:
+            lab = _Lab(app, auth, frontend_config, jupyterlab_config, self.exit_app, tg)
+            self.put(lab, Lab)
+            self.done()
+            shutdown = Event()
+            self.add_teardown_callback(shutdown.set)
+            await shutdown.wait()

fps_lab-0.9.7/src/fps_lab/routes.py

@@ -0,0 +1,222 @@
+import json
+import os
+from collections.abc import Callable
+from glob import glob
+from http import HTTPStatus
+from importlib.metadata import entry_points
+from pathlib import Path
+
+import json5  # type: ignore
+from anyio import sleep
+from anyio.abc import TaskGroup
+from babel import Locale
+from fastapi import Response, status
+from fastapi.responses import FileResponse, RedirectResponse
+from jupyverse_api.app import App
+from jupyverse_api.auth import Auth, User
+from jupyverse_api.frontend import FrontendConfig
+from jupyverse_api.jupyterlab import JupyterLabConfig
+from jupyverse_api.lab import Lab
+from starlette.requests import Request
+
+
+class _Lab(Lab):
+    def __init__(
+        self,
+        app: App,
+        auth: Auth,
+        frontend_config: FrontendConfig,
+        jupyterlab_config: JupyterLabConfig | None,
+        exit_app: Callable[[], None],
+        task_group: TaskGroup,
+    ) -> None:
+        super().__init__(app, auth, jupyterlab_config)
+
+        self.frontend_config = frontend_config
+        self.locale = "en"
+        self._exit_app = exit_app
+        self._task_group = task_group
+
+    async def get_root(
+        self,
+        response: Response,
+        user: User,
+    ):
+        # auto redirect
+        response.status_code = status.HTTP_302_FOUND
+        response.headers["Location"] = self.frontend_config.base_url + self.redirect_after_root
+
+    async def get_favicon(self):
+        return FileResponse(Path(__file__).parent / "static" / "favicon.ico")
+
+    async def get_mathjax(self, rest_of_path):
+        return RedirectResponse(
+            "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/" + rest_of_path
+        )
+
+    async def get_listings(self, user: User):
+        return {
+            "blocked_extensions_uris": [],
+            "allowed_extensions_uris": [],
+            "blocked_extensions": [],
+            "allowed_extensions": [],
+        }
+
+    async def get_extensions(self, user: User):
+        return self.federated_extensions
+
+    async def get_translations_(
+        self,
+        user: User,
+    ):
+        return RedirectResponse(f"{self.frontend_config.base_url}lab/api/translations")
+
+    async def get_translations(self, user: User):
+        locale = Locale.parse("en")
+        display_name = (locale.get_display_name(self.locale) or "").capitalize()
+        native_name = (locale.get_display_name() or "").capitalize()
+        data = {
+            "en": {
+                "displayName": display_name,
+                "nativeName": native_name,
+            }
+        }
+        for ep in entry_points(group="jupyterlab.languagepack"):
+            locale = Locale.parse(ep.name)
+            data[ep.name] = {
+                "displayName": display_name,
+                "nativeName": native_name,
+            }
+        return {"data": data, "message": ""}
+
+    async def get_translation(
+        self,
+        language,
+        user: User,
+    ):
+        if language == "en":
+            self.locale = language
+            return {}
+
+        for ep in entry_points(group="jupyterlab.languagepack"):
+            if ep.name == language:
+                break
+        else:
+            return {"data": {}, "message": f"Language pack '{language}' not installed!"}
+        self.locale = language
+        package = ep.load()
+        data = {}
+        for path in (Path(package.__file__).parent / "locale" / language / "LC_MESSAGES").glob(
+            "*.json"
+        ):
+            with open(path) as f:
+                data.update({path.stem: json.load(f)})
+        return {"data": data, "message": ""}
+
+    async def get_setting(
+        self,
+        name0,
+        name1,
+        name2,
+        user: User,
+    ):
+        with open(self.jlab_dir / "static" / "package.json") as f:
+            package = json.load(f)
+        if name0 in ["@jupyterlab", "@notebook"]:
+            schemas_parent = self.jlab_dir
+        else:
+            schemas_parent = self.extensions_dir / name0 / name1
+        with open(schemas_parent / "schemas" / name0 / name1 / f"{name2}.json") as f:
+            schema = json.load(f)
+        key = f"{name1}:{name2}"
+        setting = {
+            "id": f"@jupyterlab/{key}",
+            "schema": schema,
+            "version": package["version"],
+            "raw": "{}",
+            "settings": {},
+            "last_modified": None,
+            "created": None,
+        }
+        if user:
+            user_settings = json.loads(user.settings)
+            if key in user_settings:
+                setting.update(user_settings[key])
+                setting["settings"] = json5.loads(user_settings[key]["raw"])
+        return setting
+
+    async def change_setting(
+        self,
+        request: Request,
+        name0,
+        name1,
+        user: User,
+        user_update,
+    ):
+        settings = json.loads(user.settings)
+        settings[f"{name0}:{name1}"] = await request.json()
+        await user_update({"settings": json.dumps(settings)})
+        return Response(status_code=HTTPStatus.NO_CONTENT.value)
+
+    async def shutdown(self, user: User):
+        async def exit_app():
+            await sleep(0.1)
+            self._exit_app()
+
+        self._task_group.start_soon(exit_app)
+
+    async def get_settings(self, user: User):
+        if user:
+            user_settings = json.loads(user.settings)
+        else:
+            user_settings = {}
+        settings = []
+        schemas = [self.jlab_dir / "schemas"]
+        if self.labextensions_dir.is_dir():
+            for d1 in self.labextensions_dir.iterdir():
+                if (d1 / "schemas").exists():
+                    schemas.append(d1 / "schemas")
+                for d2 in d1.iterdir():
+                    if (d2 / "schemas").exists():
+                        schemas.append(d2 / "schemas")
+        for s in schemas:
+            for d1 in s.iterdir():
+                for d2 in d1.iterdir():
+                    package = json.loads((d2 / "package.json.orig").read_text())
+                    for path in [p for p in d2.iterdir() if p.suffix == ".json"]:
+                        schema = json.loads(path.read_text())
+                        key = f"{path.parent.name}:{path.stem}"
+                        setting = {
+                            "id": f"{d1.name}/{key}",
+                            "schema": schema,
+                            "version": package["version"],
+                            "raw": "{}",
+                            "settings": {},
+                            "warning": None,
+                            "last_modified": None,
+                            "created": None,
+                        }
+                        if key in user_settings:
+                            setting.update(user_settings[key])
+                            setting["settings"] = json5.loads(user_settings[key]["raw"])
+                        settings.append(setting)
+        return {"settings": settings}
+
+    def get_federated_extensions(self, extensions_dir: Path) -> tuple[list, list]:
+        federated_extensions = []
+        disabled_extensions = []
+
+        for path in glob(os.path.join(extensions_dir, "**", "package.json"), recursive=True):
+            with open(path) as f:
+                package = json.load(f)
+            if "jupyterlab" not in package:
+                continue
+            extension = package["jupyterlab"]["_build"]
+            extension["name"] = package["name"]
+            extension["description"] = package.get("description", "")
+            federated_extensions.append(extension)
+
+            for ext in package["jupyterlab"].get("disabledExtensions", []):
+                disabled_extensions.append(ext)
+
+        return federated_extensions, disabled_extensions