mito-ai 0.1.1__tar.gz

mito-ai-0.1.1/LICENSE

@@ -0,0 +1,3 @@
+Copyright (c) 2020-2024 Saga Inc.
+
+See the LICENSE.txt file at the root of this monorepo for licensing information.

mito-ai-0.1.1/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.1
+Name: mito-ai
+Version: 0.1.1
+Summary: AI chat for JupyterLab
+Home-page: UNKNOWN
+Author: Aaron Diamond-Reivich
+Author-email: aaron@sagacollab.com
+License: GNU Affero General Public License v3
+Description: # mito_ai
+        
+        [![Github Actions Status](/workflows/Build/badge.svg)](/actions/workflows/build.yml)
+        
+        AI chat for JupyterLab. This codebase contains two main components:
+        1. A Jupyter server extension that handles the backend logic for the chat.
+        2. Several JupyterLab extensions that handle the frontend logic for interacting with the AI, including the chat sidebar and the error message rendermime.
+        
+        ## Requirements
+        
+        - JupyterLab >= 4.0.0
+        
+        ## Install
+        
+        To install the extension, execute:
+        
+        ```bash
+        pip install mito-ai
+        ```
+        
+        ## Uninstall
+        
+        To remove the extension, execute:
+        
+        ```bash
+        pip uninstall mito-ai
+        ```
+        
+        ## Contributing
+        
+        ### Development install
+        
+        To ensure consistent package management, please use `jlpm` instead of `npm` for this project.
+        
+        Note: You will need NodeJS to build the extension package.
+        
+        The `jlpm` command is JupyterLab's pinned version of
+        [yarn](https://yarnpkg.com/) that is installed with JupyterLab. 
+        
+        ```bash
+        # Clone the repo to your local environment
+        # Change directory to the mito-ai directory
+        
+        # Required to deal with Yarn 3 workspace rules
+        touch yarn.lock
+        
+        # Install package in development mode
+        pip install -e ".[test, deploy]"
+        
+        # Install the node modules
+        jlpm install
+        
+        # Link your development version of the extension with JupyterLab
+        jupyter labextension develop . --overwrite
+        
+        # Start the jupyter server extension for development
+        jupyter server extension enable --py mito-ai
+        
+        # Rebuild extension Typescript source after making changes
+        # In case of Error: If this command fails because the lib directory was not created (the error will say something like
+        # unable to find main entry point) then run `jlpm run clean:lib` first to get rid of the old buildcache 
+        # that might be preventing a new lib directory from getting created. 
+        jlpm build
+        ```
+        
+        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
+        ```
+        
+        ### Development uninstall
+        
+        ```bash
+        pip uninstall mito-ai
+        ```
+        
+        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 `mito-ai` within that folder.
+        
+        ### Testing the extension
+        
+        #### 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)
+        
+Keywords: AI,Jupyter,Mito
+Platform: UNKNOWN
+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.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: deploy

mito-ai-0.1.1/README.md

@@ -0,0 +1,115 @@
+# mito_ai
+
+[![Github Actions Status](/workflows/Build/badge.svg)](/actions/workflows/build.yml)
+
+AI chat for JupyterLab. This codebase contains two main components:
+1. A Jupyter server extension that handles the backend logic for the chat.
+2. Several JupyterLab extensions that handle the frontend logic for interacting with the AI, including the chat sidebar and the error message rendermime.
+
+## Requirements
+
+- JupyterLab >= 4.0.0
+
+## Install
+
+To install the extension, execute:
+
+```bash
+pip install mito-ai
+```
+
+## Uninstall
+
+To remove the extension, execute:
+
+```bash
+pip uninstall mito-ai
+```
+
+## Contributing
+
+### Development install
+
+To ensure consistent package management, please use `jlpm` instead of `npm` for this project.
+
+Note: You will need NodeJS to build the extension package.
+
+The `jlpm` command is JupyterLab's pinned version of
+[yarn](https://yarnpkg.com/) that is installed with JupyterLab. 
+
+```bash
+# Clone the repo to your local environment
+# Change directory to the mito-ai directory
+
+# Required to deal with Yarn 3 workspace rules
+touch yarn.lock
+
+# Install package in development mode
+pip install -e ".[test, deploy]"
+
+# Install the node modules
+jlpm install
+
+# Link your development version of the extension with JupyterLab
+jupyter labextension develop . --overwrite
+
+# Start the jupyter server extension for development
+jupyter server extension enable --py mito-ai
+
+# Rebuild extension Typescript source after making changes
+# In case of Error: If this command fails because the lib directory was not created (the error will say something like
+# unable to find main entry point) then run `jlpm run clean:lib` first to get rid of the old buildcache 
+# that might be preventing a new lib directory from getting created. 
+jlpm build
+```
+
+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
+```
+
+### Development uninstall
+
+```bash
+pip uninstall mito-ai
+```
+
+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 `mito-ai` within that folder.
+
+### Testing the extension
+
+#### 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)

mito-ai-0.1.1/jupyter-config/jupyter_server_config.d/mito-ai.json

@@ -0,0 +1,7 @@
+{
+    "ServerApp": {
+        "jpserver_extensions": {
+            "mito-ai": true
+        }
+    }
+}

mito-ai-0.1.1/mito-ai/OpenAICompletionHandler.py

@@ -0,0 +1,48 @@
+import os
+import openai
+from jupyter_server.base.handlers import APIHandler
+from tornado import web
+import json
+from openai import OpenAI
+
+
+# This handler is responsible for the mito_ai/completion endpoint. 
+# It takes a message from the user, sends it to the OpenAI API, and returns the response.
+# Important: Because this is a server extension, print statements are sent to the 
+# jupyter server terminal by default (ie: the terminal you ran `jupyter lab`)
+class OpenAICompletionHandler(APIHandler):
+    @web.authenticated
+    def post(self):
+        # Retrieve the message from the request
+        data = self.get_json_body()
+        messages = data.get('messages', '')
+
+        # Get the OpenAI API key from environment variables
+        openai_api_key = os.getenv('OPENAI_API_KEY')
+        if not openai_api_key:
+            # If the API key is not set, return a 401 unauthorized error
+            self.set_status(401)
+            self.finish(json.dumps({"response": "OPENAI_API_KEY not set"}))
+            return
+
+        # Set up the OpenAI client
+        openai.api_key = openai_api_key
+        client = OpenAI()
+
+        try:
+            # Query OpenAI API
+            response = client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=messages
+            )
+
+            response_dict = response.to_dict()
+
+            # Send the response back to the frontend
+            # TODO: In the future, instead of returning the raw response, 
+            # return a cleaned up version of the response so we can support
+            # multiple models 
+            self.finish(json.dumps(response_dict))
+        except Exception as e:
+            self.set_status(500)
+            self.finish(json.dumps({"response": f"Error: {str(e)}"}))

mito-ai-0.1.1/mito-ai/__init__.py

@@ -0,0 +1,49 @@
+from jupyter_server.utils import url_path_join
+from .OpenAICompletionHandler import OpenAICompletionHandler
+from pathlib import Path
+import json
+
+try:
+    from _version import __version__
+except ImportError:
+    # Fallback when using the package in dev mode without installing
+    # in editable mode with pip. It is highly recommended to install
+    # the package from a stable release or in editable mode: https://pip.pypa.io/en/stable/topics/local-project-installs/#editable-installs
+    import warnings
+    warnings.warn("Importing 'mito-ai' outside a proper installation.")
+    __version__ = "dev"
+
+
+HERE = Path(__file__).parent.resolve()
+
+
+with (HERE / "labextension" / "package.json").open() as fid:
+    data = json.load(fid)
+
+def _jupyter_labextension_paths():
+    return [{
+        "src": "labextension",
+        "dest": "mito-ai"
+    }]
+
+def _jupyter_server_extension_points():
+    """
+    Returns a list of dictionaries with metadata describing
+    where to find the `_load_jupyter_server_extension` function.
+    """
+    return [{"module": "mito-ai"}]
+
+# Jupyter Server is the backend used by JupyterLab. A sever extension lets 
+# us add new API's to the backend, so we can do some processing that we don't
+# want to exist in the users's javascript. 
+
+# For a further explanation of the Jupyter architecture watch the first 35 minutes
+# of this video: https://www.youtube.com/watch?v=9_-siU-_XoI
+def _load_jupyter_server_extension(server_app):
+    host_pattern = ".*$"
+    web_app = server_app.web_app
+    base_url = web_app.settings["base_url"]
+    route_pattern = url_path_join(base_url, "mito_ai", "completion")
+    handlers = [(route_pattern, OpenAICompletionHandler)]
+    web_app.add_handlers(host_pattern, handlers)
+    web_app.log.info("Loaded the mito_ai server extension")

mito-ai-0.1.1/mito-ai/_version.py

@@ -0,0 +1,25 @@
+#!/usr/bin/env python
+# coding: utf-8
+
+# Copyright (c) Saga Inc.
+import json
+import os
+from pathlib import Path
+
+"""
+This code is responsible for getting the package.json that is bundled
+with the javascript code bundle inside this Python package, so we can 
+get the version of the package. This means we can easily bump the package
+version in one place (package.json) and have it automatically update here too. 
+This is nice for the release process. 
+
+Since this is a Jupyter Lab 4 extension, themito-ai/labextension folder
+contains the package.json directly. So we can just read it there. 
+"""
+lab_extension_folder = os.path.join(Path(__file__).parent, 'labextension')
+
+package_json_path = os.path.join(lab_extension_folder, 'package.json')
+package_json = json.loads(open(package_json_path).read())
+
+__version__ = package_json['version']
+