jupyterlab-biolm 1.0.8__tar.gz → 1.2.0__tar.gz

jupyterlab_biolm-1.2.0/Dockerfile.visual-test

@@ -0,0 +1,16 @@
+FROM jupyter/scipy-notebook:latest
+
+USER root
+
+# Install build tools
+RUN pip install --no-cache-dir build wheel
+
+# Copy and install the latest wheel
+COPY dist/jupyterlab_biolm-1.1.0-py3-none-any.whl /tmp/
+RUN pip install --no-cache-dir /tmp/jupyterlab_biolm-1.1.0-py3-none-any.whl
+
+USER $NB_UID
+
+# Expose JupyterLab port
+EXPOSE 8888
+

{jupyterlab_biolm-1.0.8 → jupyterlab_biolm-1.2.0}/PKG-INFO

@@ -1,12 +1,19 @@
 Metadata-Version: 2.4
 Name: jupyterlab-biolm
-Version: 1.0.8
+Version: 1.2.0
+Summary: JupyterLab extension for BioLM API integration
+Project-URL: Homepage, https://github.com/BioLM/jupyterlab-biolm
+Project-URL: Repository, https://github.com/BioLM/jupyterlab-biolm
+Project-URL: Issues, https://github.com/BioLM/jupyterlab-biolm/issues
+Project-URL: Documentation, https://github.com/BioLM/jupyterlab-biolm
 Author: BioLM
 License: BSD-3-Clause
-Keywords: Jupyter,JupyterLab,JupyterLab Extension
+Keywords: BioLM,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
@@ -15,6 +22,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.8
+Requires-Dist: biolmai
 Requires-Dist: jupyter-server>=2.0.0
 Requires-Dist: jupyterlab<5,>=4.0.0
 Provides-Extra: dev

jupyterlab_biolm-1.2.0/VERSIONING.md

@@ -0,0 +1,263 @@
+# Version Management Guide
+
+## Overview
+
+This project uses **semantic-release** to automatically manage versions based on [Conventional Commits](https://www.conventionalcommits.org/). 
+
+**Key principles:**
+- **Production versions**: Let semantic-release handle them automatically
+- **TestPyPI versions**: Use `-rc` (release candidate) suffixes (e.g., `1.0.9-rc.1`)
+- **Local testing**: Don't bump version, just test with current version
+
+## How It Works
+
+1. **Commit with conventional format** (e.g., `feat:`, `fix:`, `BREAKING:`)
+2. **Push to main branch**
+3. **CI runs semantic-release** which:
+   - Analyzes commit messages
+   - Determines version bump (major/minor/patch)
+   - Updates `package.json` version
+   - Creates git tag (e.g., `v1.0.12`)
+   - Pushes tag to GitHub
+4. **Python version syncs automatically** via `hatch-nodejs-version` from `package.json`
+
+## Commit Message Format
+
+| Commit Type | Version Bump | Example |
+|------------|--------------|---------|
+| `feat: ...` | **Minor** (1.0.11 → 1.1.0) | `feat: add new model browser` |
+| `fix: ...` | **Patch** (1.0.11 → 1.0.12) | `fix: resolve CORS issue` |
+| `BREAKING: ...` | **Major** (1.0.11 → 2.0.0) | `BREAKING: change API interface` |
+| No prefix | **None** | `docs: update README` |
+
+## ❌ What NOT to Do
+
+**NEVER manually edit the version in `package.json`** when using semantic-release. This causes mismatches:
+
+```bash
+# ❌ BAD - Don't do this!
+# Manually editing package.json version
+# This will cause semantic-release to create a different tag
+```
+
+## ✅ Correct Workflow
+
+### For Regular Releases
+
+1. **Make your changes**
+2. **Commit with conventional format:**
+   ```bash
+   git commit -m "fix: remove server extension dependency"
+   git push origin main
+   ```
+3. **Wait for CI to complete:**
+   - Tests run
+   - semantic-release analyzes commits
+   - Version bumped in `package.json` (if needed)
+   - Git tag created and pushed
+4. **Publish to TestPyPI/PyPI:**
+   - Use the version that semantic-release created
+   - Or wait for the publish workflow to run automatically
+
+### For Local Testing
+
+**You don't need to bump the version for local testing!** Just test with the current version:
+
+```bash
+# Make your changes
+vim src/api/client.ts
+
+# Build and test locally (version doesn't matter for local testing)
+python3 -m build
+# Test the built package
+
+# Commit your changes (without any version bump)
+git add src/api/client.ts
+git commit -m "fix: call BioLM API directly from client"
+git push origin main
+# semantic-release will handle the version bump
+```
+
+### For TestPyPI Publishing (Recommended: Use -rc suffixes)
+
+**Best Practice: Always use `-rc` (release candidate) suffixes for TestPyPI**
+
+This ensures TestPyPI versions don't conflict with semantic-release's production versions:
+
+```bash
+# 1. Make your changes and commit
+git commit -m "fix: some bug fix"
+
+# 2. Bump to release candidate version
+npm version 1.0.9-rc.1 --no-git-tag-version
+git add package.json
+git commit -m "chore: bump to 1.0.9-rc.1 for TestPyPI"
+
+# 3. Build and publish to TestPyPI
+python3 -m build
+python3 -m twine upload --repository testpypi dist/jupyterlab_biolm-1.0.9-rc.1*
+
+# 4. Push commits (semantic-release will create 1.0.9 when ready)
+git push origin main
+# When semantic-release runs, it will create v1.0.9 (which is > 1.0.9-rc.1)
+```
+
+**Why `-rc` suffixes?**
+- ✅ TestPyPI versions are clearly marked as pre-release
+- ✅ semantic-release can still create the final version (1.0.9 > 1.0.9-rc.1)
+- ✅ No version conflicts
+- ✅ Standard practice in the industry
+
+**Alternative: Wait for semantic-release**
+```bash
+# Just push your commit and wait
+git push origin main
+# Wait for CI/semantic-release to create the tag
+git fetch --tags
+# Use the version from the tag for publishing
+```
+
+## Current Version Status
+
+To check the current version:
+
+```bash
+# Check package.json
+cat package.json | grep '"version"'
+
+# Check latest git tag
+git describe --tags --abbrev=0
+
+# Check what semantic-release will do (dry run)
+npx semantic-release --dry-run
+```
+
+## Troubleshooting Version Mismatches
+
+If you see a mismatch between `package.json` and git tags:
+
+1. **Check what semantic-release created:**
+   ```bash
+   git fetch --tags
+   git tag --sort=-version:refname | head -5
+   ```
+
+2. **Align versions:**
+   - If `package.json` is ahead: Let semantic-release handle it on the next commit
+   - If tags are ahead: Pull the semantic-release commit that updated `package.json`
+
+3. **Reset if needed:**
+   ```bash
+   # Only if absolutely necessary - this is destructive!
+   # Pull the version from the latest tag
+   git checkout v1.0.8 -- package.json
+   ```
+
+## Best Practices
+
+1. ✅ **Always use conventional commits** (`feat:`, `fix:`, etc.)
+2. ✅ **Let semantic-release handle all production version bumps**
+3. ✅ **Publish to TestPyPI/PyPI after semantic-release creates the tag**
+4. ✅ **Don't bump version for local testing** (just test with current version)
+5. ✅ **Use `-rc` suffixes for TestPyPI** (e.g., `1.0.9-rc.1`) - this is the standard practice
+6. ❌ **Never manually edit `package.json` version for production releases** (let semantic-release do it)
+7. ❌ **Never create git tags manually** (let semantic-release do it)
+8. ❌ **Never bump version just to revert it** (that workflow doesn't make sense)
+
+## Example Workflows
+
+### Standard Release Workflow
+
+```bash
+# 1. Make changes
+vim src/api/client.ts
+
+# 2. Commit with conventional format
+git add src/api/client.ts
+git commit -m "fix: call BioLM API directly from client"
+
+# 3. Push
+git push origin main
+
+# 4. Wait for CI
+# - CI runs tests
+# - semantic-release creates v1.0.12 tag
+# - package.json updated to 1.0.12
+
+# 5. Publish (if needed)
+# Use the version from the tag: 1.0.12
+python3 -m build
+python3 -m twine upload --repository testpypi dist/jupyterlab_biolm-1.0.12*
+```
+
+### Local Testing Workflow
+
+```bash
+# 1. Make changes
+vim src/api/client.ts
+
+# 2. Build and test locally (no version bump needed!)
+python3 -m build
+# Test the built package locally
+
+# 3. Commit your changes (without any version bump)
+git add src/api/client.ts
+git commit -m "fix: call BioLM API directly from client"
+
+# 4. Push (semantic-release will create the version)
+git push origin main
+```
+
+### TestPyPI Publishing Workflow (using -rc suffixes)
+
+```bash
+# Recommended workflow for TestPyPI publishing:
+
+# 1. Make your changes and commit
+git add src/api/client.ts
+git commit -m "fix: call BioLM API directly from client"
+
+# 2. Bump to release candidate version
+npm version 1.0.9-rc.1 --no-git-tag-version
+git add package.json
+git commit -m "chore: bump to 1.0.9-rc.1 for TestPyPI"
+
+# 3. Build and publish to TestPyPI
+python3 -m build
+python3 -m twine upload --repository testpypi dist/jupyterlab_biolm-1.0.9-rc.1*
+
+# 4. Push commits
+git push origin main
+
+# 5. semantic-release will create 1.0.9 when it runs
+# (1.0.9 > 1.0.9-rc.1, so no conflict)
+```
+
+## Configuration
+
+The semantic-release configuration is in `package.json`:
+
+```json
+{
+  "release": {
+    "branches": ["main", "master"],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      ["@semantic-release/npm", { "npmPublish": false }],
+      ["@semantic-release/git", {
+        "assets": ["package.json"],
+        "message": "chore(release): ${nextRelease.version} [skip ci]"
+      }]
+    ]
+  }
+}
+```
+
+This configuration:
+- Analyzes commits for version bumps
+- Updates `package.json` with new version
+- Creates git tag
+- Commits the version bump back to the repo
+- Skips CI on the version bump commit (to avoid loops)
+

jupyterlab_biolm-1.2.0/docker-compose.visual-test.yml

@@ -0,0 +1,16 @@
+services:
+  jupyterlab:
+    build:
+      context: .
+      dockerfile: Dockerfile.visual-test
+    ports:
+      - "8888:8888"
+    volumes:
+      - test-notebooks:/home/jovyan/work
+    environment:
+      - JUPYTER_ENABLE_LAB=yes
+    command: jupyter lab --ip=0.0.0.0 --port=8888 --no-browser --allow-root --ServerApp.token='' --ServerApp.password='' --IdentityProvider.token=''
+
+volumes:
+  test-notebooks:
+

{jupyterlab_biolm-1.0.8 → jupyterlab_biolm-1.2.0}/jupyterlab_biolm/serverextension.py

@@ -81,6 +81,135 @@ class BioLMModelsHandler(APIHandler):
             self.finish(json.dumps(error_data))
 
 
+class BioLMModelDetailsHandler(APIHandler):
+    """Handler for fetching individual model details with code examples"""
+    
+    # Disable XSRF for API endpoints
+    def check_xsrf_cookie(self):
+        pass
+    
+    @tornado.web.authenticated
+    def get(self, model_slug):
+        """Fetch model details from BioLM API"""
+        try:
+            # Get API key from Authorization header or query parameter
+            api_key = None
+            auth_header = self.request.headers.get('Authorization', '')
+            if auth_header.startswith('Bearer '):
+                api_key = auth_header[7:]
+            else:
+                api_key = self.get_query_argument('api_key', None)
+            
+            # Build request to BioLM API with code_examples and exclude_docs_html
+            url = f'https://biolm.ai/api/ui/community-api-models/{model_slug}/?code_examples=true&exclude_docs_html=true'
+            headers = {
+                'Content-Type': 'application/json',
+                'User-Agent': 'JupyterLab-BioLM-Extension/0.1.0',
+            }
+            
+            if api_key:
+                headers['Authorization'] = f'Bearer {api_key}'
+            
+            # Make request
+            req = Request(url, headers=headers)
+            
+            try:
+                with urlopen(req, timeout=10) as response:
+                    data = json.loads(response.read().decode('utf-8'))
+                    
+                    # Transform example_payload fields into code_examples format
+                    code_examples = []
+                    model_slug_from_data = data.get('model_slug', model_slug)
+                    
+                    # Map action types to their example payload fields
+                    action_mapping = {
+                        'predict': 'predictor_example_payload',
+                        'encode': 'encoder_example_payload',
+                        'generate': 'generator_example_payload',
+                        'classify': 'classifier_example_payload',
+                        'similarity': 'similarity_example_payload',
+                        'explain': 'explainer_example_payload',
+                        'transform': 'transformer_example_payload',
+                    }
+                    
+                    for action, payload_key in action_mapping.items():
+                        payload = data.get(payload_key)
+                        if payload and payload.get('items'):
+                            items = payload['items']
+                            
+                            # Determine item type and format
+                            if isinstance(items, list) and len(items) > 0:
+                                # Check if items are objects with 'sequence' field
+                                if isinstance(items[0], dict) and 'sequence' in items[0]:
+                                    sequences = [item['sequence'] for item in items]
+                                    if len(sequences) == 1:
+                                        code = f'result = biolm(entity="{model_slug_from_data}", action="{action}", type="sequence", items="{sequences[0]}")\n\nprint(result)'
+                                    else:
+                                        seq_list = ', '.join([f'"{seq}"' for seq in sequences])
+                                        code = f'result = biolm(entity="{model_slug_from_data}", action="{action}", type="sequence", items=[{seq_list}])\n\nprint(result)'
+                                else:
+                                    # Handle other item formats
+                                    if len(items) == 1:
+                                        code = f'result = biolm(entity="{model_slug_from_data}", action="{action}", type="sequence", items={json.dumps(items[0])})\n\nprint(result)'
+                                    else:
+                                        code = f'result = biolm(entity="{model_slug_from_data}", action="{action}", type="sequence", items={json.dumps(items)})\n\nprint(result)'
+                                    
+                                code_examples.append({
+                                    'action': action,
+                                    'code': code
+                                })
+                    
+                    # Add setup example for environment variable (if API key is provided)
+                    api_key = None
+                    auth_header = self.request.headers.get('Authorization', '')
+                    if auth_header.startswith('Bearer '):
+                        api_key = auth_header[7:]
+                    else:
+                        api_key = self.get_query_argument('api_key', None)
+                    
+                    if api_key:
+                        # Add setup example as the first example
+                        setup_code = f"import os\nos.environ['BIOLMAI_TOKEN'] = 'YOUR_API_KEY_HERE'  # Replace with your actual API key"
+                        code_examples.insert(0, {
+                            'action': 'setup',
+                            'code': setup_code
+                        })
+                    
+                    # Add code_examples to the response
+                    if code_examples:
+                        data['code_examples'] = code_examples
+                    
+                    self.set_status(200)
+                    self.set_header('Content-Type', 'application/json')
+                    self.finish(json.dumps(data))
+            except HTTPError as e:
+                error_data = {
+                    'error': True,
+                    'message': f'API request failed: {e.code} {e.reason}',
+                    'status': e.code,
+                }
+                self.set_status(e.code)
+                self.set_header('Content-Type', 'application/json')
+                self.finish(json.dumps(error_data))
+            except URLError as e:
+                error_data = {
+                    'error': True,
+                    'message': f'Network error: {str(e)}',
+                }
+                self.set_status(500)
+                self.set_header('Content-Type', 'application/json')
+                self.finish(json.dumps(error_data))
+                
+        except Exception as e:
+            error_data = {
+                'error': True,
+                'message': f'Server error: {str(e)}',
+            }
+            self.set_status(500)
+            self.set_header('Content-Type', 'application/json')
+            self.finish(json.dumps(error_data))
+
+
 class BioLMTestConnectionHandler(APIHandler):
     """Handler for testing API connection"""
     
@@ -164,6 +293,7 @@ def _load_jupyter_server_extension(server_app):
     # Register handlers
     handlers = [
         (url_path_join(base_url, 'biolm', 'api', 'models'), BioLMModelsHandler),
+        (url_path_join(base_url, 'biolm', 'api', 'models', r'([^/]+)'), BioLMModelDetailsHandler),
         (url_path_join(base_url, 'biolm', 'api', 'test-connection'), BioLMTestConnectionHandler),
     ]
     

{jupyterlab_biolm-1.0.8 → jupyterlab_biolm-1.2.0}/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "jupyterlab-biolm",
-  "version": "1.0.8",
+  "version": "1.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "jupyterlab-biolm",
-      "version": "1.0.8",
+      "version": "1.2.0",
       "license": "BSD-3-Clause",
       "dependencies": {
         "@jupyterlab/application": "^4.0.0",

{jupyterlab_biolm-1.0.8 → jupyterlab_biolm-1.2.0}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jupyterlab-biolm",
-  "version": "1.0.8",
+  "version": "1.2.0",
   "description": "JupyterLab extension for BioLM API integration",
   "keywords": [
     "jupyter",

{jupyterlab_biolm-1.0.8 → jupyterlab_biolm-1.2.0}/pyproject.toml

@@ -6,12 +6,13 @@ build-backend = "hatchling.build"
 name = "jupyterlab-biolm"
 dynamic = ["version"]
 readme = "README.md"
+description = "JupyterLab extension for BioLM API integration"
 requires-python = ">=3.8"
 license = {text = "BSD-3-Clause"}
 authors = [
     {name = "BioLM"}
 ]
-keywords = ["Jupyter", "JupyterLab", "JupyterLab Extension"]
+keywords = ["Jupyter", "JupyterLab", "JupyterLab Extension", "BioLM"]
 classifiers = [
     "License :: OSI Approved :: BSD License",
     "Programming Language :: Python",
@@ -23,12 +24,21 @@ classifiers = [
     "Framework :: Jupyter",
     "Framework :: Jupyter :: JupyterLab",
     "Framework :: Jupyter :: JupyterLab :: 4",
+    "Framework :: Jupyter :: JupyterLab :: Extensions",
+    "Framework :: Jupyter :: JupyterLab :: Extensions :: Prebuilt",
 ]
 dependencies = [
     "jupyterlab>=4.0.0,<5",
     "jupyter-server>=2.0.0",
+    "biolmai",
 ]
 
+[project.urls]
+Homepage = "https://github.com/BioLM/jupyterlab-biolm"
+Repository = "https://github.com/BioLM/jupyterlab-biolm"
+Issues = "https://github.com/BioLM/jupyterlab-biolm/issues"
+Documentation = "https://github.com/BioLM/jupyterlab-biolm"
+
 
 [project.optional-dependencies]
 dev = [

{jupyterlab_biolm-1.0.8 → jupyterlab_biolm-1.2.0}/setup.py

@@ -61,6 +61,7 @@ setup_args = dict(
     install_requires=[
         "jupyterlab>=4.0.0,<5",
         "jupyter-server>=2.0.0",
+        "biolmai",
     ],
     extras_require={
         "dev": [