Metadata-Version: 2.4
Name: jupyter_rtc_core
Version: 0.1.0a2
Summary: A JupyterLab extension that provides RTC capabilities.
Project-URL: Homepage, https://github.com/ellisonbg/jupyter-rtc-core
Project-URL: Bug Tracker, https://github.com/ellisonbg/jupyter-rtc-core/issues
Project-URL: Repository, https://github.com/ellisonbg/jupyter-rtc-core.git
Author-email: Project Jupyter <jupyter@googlegroups.com>
License: BSD 3-Clause License
        
        Copyright (c) 2025, Project Jupyter
        All rights reserved.
        
        Redistribution and use in source and binary forms, with or without
        modification, are permitted provided that the following conditions are met:
        
        1. Redistributions of source code must retain the above copyright notice, this
           list of conditions and the following disclaimer.
        
        2. 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.
        
        3. Neither the name of the copyright holder 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 HOLDER 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.
License-File: LICENSE
Keywords: jupyter,jupyterlab,jupyterlab-extension
Classifier: Framework :: Jupyter
Classifier: Framework :: Jupyter :: JupyterLab
Classifier: Framework :: Jupyter :: JupyterLab :: 4
Classifier: Framework :: Jupyter :: JupyterLab :: Extensions
Classifier: Framework :: Jupyter :: JupyterLab :: Extensions :: Prebuilt
Classifier: License :: OSI Approved :: BSD License
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Requires-Python: >=3.9
Requires-Dist: jupyter-collaboration-ui<3,>=2.0.2
Requires-Dist: jupyter-server-fileid<0.10.0,>=0.9.0
Requires-Dist: jupyter-server<3,>=2.4.0
Requires-Dist: jupyter-ydoc<4.0.0,>=3.0.0
Requires-Dist: pycrdt<0.13.0,>=0.12.0
Provides-Extra: test
Requires-Dist: coverage; extra == 'test'
Requires-Dist: pytest; extra == 'test'
Requires-Dist: pytest-asyncio; extra == 'test'
Requires-Dist: pytest-cov; extra == 'test'
Requires-Dist: pytest-jupyter[server]>=0.6.0; extra == 'test'
Description-Content-Type: text/markdown

# jupyter_rtc_core

[![Github Actions Status](https://github.com/ellisonbg/jupyter-rtc-core/workflows/Build/badge.svg)](https://github.com/ellisonbg/jupyter-rtc-core/actions/workflows/build.yml)

A JupyterLab extension that provides RTC capabilities.

This extension is composed of a Python package named `jupyter_rtc_core`
for the server extension and a NPM package named `@jupyter/rtc-core`
for the frontend extension.

## Try it out

Run with the proper configuration

```
jupyter lab --config jupyter_config.py
```

## Requirements

- JupyterLab >= 4.0.0

## Installation

To install the extension, run:

```bash
pip install jupyter_rtc_core
```

To remove the extension, run:

```bash
pip uninstall jupyter_rtc_core
```

## Contributing

### Setting up a development environment

We recommend using
[Micromamba](https://mamba.readthedocs.io/en/latest/user_guide/micromamba.html)
to create and manage a custom Python environment for developing this package.
Micromamba provides most of the same CLI as Conda, but works much faster.

First, set up a development environment by running this command from the root of
this repository:

```sh
micromamba env create -f dev-environment.yml
```

This creates a new Python environment named `rtccore` and automatically installs
this extension's build dependencies, required for local development. Then,
activate the environment:

```sh
micromamba activate rtccore
```

Activating an environment is required to access any Python packages installed in
that environment. You should activate the environment before developing any
changes to the `jupyter_rtc_core` package locally.

### Development install

After ensuring that the `rtccore` environment is activated, you can install an
editable copy of `jupyter_rtc_core` into your environment by running the script
below.

```bash
jlpm dev:install
```

Notes about the development installation:

- `jlpm` is JupyterLab's pinned version of [yarn](https://yarnpkg.com/) that is
  installed with JupyterLab. In other words, `jlpm` can be considered an alias of
  `yarn`.

- `jlpm dev:install` runs the `dev:install` NPM script defined in `package.json`.

- The `dev:install` step uses [`uv`](https://docs.astral.sh/uv/) as a faster,
  more modern replacement for `pip`.

After completing this, you should have a working, editable copy of
`jupyter_rtc_core` in your environment. Run `jupyter lab` and open JupyterLab in
a browser to verify that `jupyter_rtc_core` is installed.

### Development process

When making new changes to your local copy of `jupyter_rtc_core`, different
commands need to be run depending on the types of changes made. Without running
these commands, the new changes are not reflected in JupyterLab.

Here is a summary of the commands to run after making changes:

- After updating `package.json` or `yarn.lock`: run `jlpm install` to install
  the frontend dependencies.

- After updating any frontend (TS/TSX/JS/CSS): run `jlpm build` to build the lab
  extension (i.e. the frontend).

- After updating any backend (Python) file: restart the server to reload the
  server extension (i.e. the backend).

  - Note that there is no build process when updating a Python file, since
    Python is a scripting language.

- After updating entry points or other package metadata in `pyproject.toml`: run
  `jlpm dev:uninstall && jlpm dev:install` to re-do the development installation.
  The package metadata is not updated automatically after local changes, even when
  installing the package in editable mode.

- Finally, refresh the JupyterLab page in the browser to load the new
  frontend assets and use the new backend.

### Building on change (frontend only)

You can watch the source directory and run JupyterLab at the same time in
different terminals to watch for changes in the extension's source and
automatically rebuild the extension.

```bash
# Watch the source directory in one terminal, automatically rebuilding when needed
jlpm watch
# Run JupyterLab in another terminal
jupyter lab
```

With the watch command running, every saved change will immediately be built
locally and available in your running JupyterLab. Refresh JupyterLab to load the
change in your browser (you may need to wait several seconds for the extension
to be rebuilt).

By default, the `jlpm build` command generates the source maps for this
extension to make it easier to debug using the browser dev tools. To also
generate source maps for the JupyterLab core extensions, you can run the
following command:

```bash
jupyter lab build --minimize=False
```

Note that the steps described here only update the application in response to
changes to frontend (TypeScript) files. Changes to any backend (Python) files
still require restarting the Jupyter Server.

### Development uninstall

To undo the development installation, run this command:

```bash
jlpm dev:uninstall
```

In development mode, you will also need to remove the symlink created by
`jupyter labextension develop` command. To find its location, you can run
`jupyter labextension list` to figure out where the `labextensions` folder is
located. Then you can remove the symlink named `@jupyter/rtc-core` within that
folder.

### Testing the extension

#### Server tests

This extension is using [Pytest](https://docs.pytest.org/) for Python code testing.

Install test dependencies (needed only once):

```sh
pip install -e ".[test]"
# Each time you install the Python package, you need to restore the front-end extension link
jupyter labextension develop . --overwrite
```

To execute them, run:

```sh
pytest -vv -r ap --cov jupyter_rtc_core
```

#### Frontend tests

This extension is using [Jest](https://jestjs.io/) for JavaScript code testing.

To execute them, execute:

```sh
jlpm
jlpm test
```

#### Integration tests

This extension uses [Playwright](https://playwright.dev/docs/intro) for the integration tests (aka user level tests).
More precisely, the JupyterLab helper [Galata](https://github.com/jupyterlab/jupyterlab/tree/master/galata) is used to handle testing the extension in JupyterLab.

More information are provided within the [ui-tests](./ui-tests/README.md) README.

### Packaging the extension

See [RELEASE](RELEASE.md)

## Troubleshooting

If you are seeing the frontend extension, but it is not working, check
that the server extension is enabled:

```bash
jupyter server extension list
```

If the server extension is installed and enabled, but you are not seeing
the frontend extension, check the frontend extension is installed:

```bash
jupyter labextension list
```
