more-compute 0.4.2__tar.gz → 0.4.3__tar.gz

{more_compute-0.4.2/more_compute.egg-info → more_compute-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: more-compute
-Version: 0.4.2
+Version: 0.4.3
 Summary: An interactive notebook environment for local and GPU computing
 Home-page: https://github.com/DannyMang/MORECOMPUTE
 Author: MoreCompute Team

{more_compute-0.4.2 → more_compute-0.4.3/more_compute.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: more-compute
-Version: 0.4.2
+Version: 0.4.3
 Summary: An interactive notebook environment for local and GPU computing
 Home-page: https://github.com/DannyMang/MORECOMPUTE
 Author: MoreCompute Team

more_compute-0.4.3/morecompute/__version__.py

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

{more_compute-0.4.2 → more_compute-0.4.3}/morecompute/notebook.py

@@ -3,6 +3,7 @@ from pathlib import Path
 from typing import List, Dict, Any
 from uuid import uuid4
 from .utils.py_percent_parser import parse_py_percent, generate_py_percent
+from .utils.notebook_converter import detect_colab_format, parse_colab_py
 
 class Notebook:
     """Manages the state of a notebook's cells."""
@@ -92,11 +93,29 @@ class Notebook:
 
             # Check file extension
             if path.suffix == '.py':
-                # Load .py file with py:percent format
+                # Load .py file - auto-detect format
                 with open(file_path, 'r', encoding='utf-8') as f:
                     content = f.read()
 
-                data = parse_py_percent(content)
+                # Detect if it's Colab format (docstrings) or py:percent format (# %%)
+                if detect_colab_format(content):
+                    print(f" Detected Colab format - auto-converting to py:percent")
+                    # Parse Colab format (docstrings as markdown)
+                    loaded_cells = parse_colab_py(content)
+                    data = {
+                        'cells': loaded_cells,
+                        'metadata': {
+                            'kernelspec': {
+                                'display_name': 'Python 3',
+                                'language': 'python',
+                                'name': 'python3'
+                            }
+                        }
+                    }
+                else:
+                    # Parse py:percent format (# %% markers)
+                    data = parse_py_percent(content)
+
                 loaded_cells = data.get('cells', [])
 
                 # Ensure stable IDs for all cells

more_compute-0.4.3/morecompute/utils/notebook_converter.py

@@ -0,0 +1,297 @@
+"""Converter utilities for notebook formats."""
+
+import json
+import re
+from pathlib import Path
+from typing import List, Set, Dict
+from .py_percent_parser import generate_py_percent, parse_py_percent
+
+
+def extract_pip_dependencies(notebook_data: dict) -> Set[str]:
+    """
+    Extract package names from !pip install and %pip install commands.
+
+    Args:
+        notebook_data: Parsed notebook JSON
+
+    Returns:
+        Set of package names
+    """
+    packages = set()
+
+    for cell in notebook_data.get('cells', []):
+        if cell.get('cell_type') != 'code':
+            continue
+
+        source = cell.get('source', [])
+        if isinstance(source, list):
+            source = ''.join(source)
+
+        # Match: !pip install package1 package2
+        # Match: %pip install package1 package2
+        pip_pattern = r'[!%]pip\s+install\s+([^\n]+)'
+        matches = re.finditer(pip_pattern, source)
+
+        for match in matches:
+            install_line = match.group(1)
+            # Remove common flags
+            install_line = re.sub(r'--[^\s]+\s*', '', install_line)
+            install_line = re.sub(r'-[qU]\s*', '', install_line)
+
+            # Extract package names (handle package==version format)
+            parts = install_line.split()
+            for part in parts:
+                part = part.strip()
+                if part and not part.startswith('-'):
+                    packages.add(part)
+
+    return packages
+
+
+def convert_ipynb_to_py(ipynb_path: Path, output_path: Path, include_uv_deps: bool = True) -> None:
+    """
+    Convert .ipynb notebook to .py format with py:percent cell markers.
+
+    Args:
+        ipynb_path: Path to input .ipynb file
+        output_path: Path to output .py file
+        include_uv_deps: Whether to add UV inline script dependencies
+    """
+    # Read notebook
+    with open(ipynb_path, 'r', encoding='utf-8') as f:
+        notebook_data = json.load(f)
+
+    cells = notebook_data.get('cells', [])
+
+    # Generate UV dependencies header if requested
+    header_lines = []
+    if include_uv_deps:
+        dependencies = extract_pip_dependencies(notebook_data)
+        if dependencies:
+            header_lines.append('# /// script')
+            header_lines.append('# dependencies = [')
+            for dep in sorted(dependencies):
+                header_lines.append(f'#   "{dep}",')
+            header_lines.append('# ]')
+            header_lines.append('# ///')
+            header_lines.append('')
+
+    # Generate py:percent format
+    py_content = generate_py_percent(cells)
+
+    # Combine header and content
+    if header_lines:
+        final_content = '\n'.join(header_lines) + '\n' + py_content
+    else:
+        final_content = py_content
+
+    # Write output
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write(final_content)
+
+    print(f"✓ Converted {ipynb_path.name} → {output_path.name}")
+
+    # Show dependencies if found
+    if include_uv_deps and dependencies:
+        print(f"  Found dependencies: {', '.join(sorted(dependencies))}")
+        print(f"  Run with: more-compute {output_path.name}")
+
+
+def detect_colab_format(content: str) -> bool:
+    """
+    Detect if a .py file is in Colab export format (docstrings as markdown).
+
+    Args:
+        content: Raw .py file content
+
+    Returns:
+        True if appears to be Colab format, False otherwise
+    """
+    # Check for actual cell markers (# %% at start of line)
+    # Must be ONLY # %% optionally followed by [markdown] or whitespace
+    # NOT # %%capture, # %%time, etc. (IPython magics)
+    has_cell_markers = bool(re.search(r'^\s*# %%\s*(?:\[markdown\])?\s*$', content, re.MULTILINE))
+
+    # If it has # %% markers, it's NOT Colab format (it's py:percent)
+    # Even if it has a Colab header comment!
+    if has_cell_markers:
+        return False
+
+    # Check for multi-line docstrings (Colab's markdown format)
+    has_docstrings = '"""' in content
+
+    # Colab format: has docstrings and no cell markers
+    return has_docstrings
+
+
+def parse_colab_py(content: str) -> List[Dict]:
+    """
+    Parse Colab-exported .py file into cell structure.
+
+    Colab format uses:
+    - Multi-line docstrings ('''..''' or \"\"\"...\"\"\") for markdown cells
+    - Regular Python code for code cells
+
+    Args:
+        content: Raw .py file content from Colab export
+
+    Returns:
+        List of cell dicts with 'cell_type' and 'source'
+    """
+    cells = []
+
+    # Split on docstring boundaries
+    # Pattern matches both ''' and """ with optional content
+    pattern = r'("""[\s\S]*?"""|\'\'\'[\s\S]*?\'\'\')'
+    parts = re.split(pattern, content)
+
+    for part in parts:
+        part = part.strip()
+        if not part:
+            continue
+
+        # Check if this is a docstring (markdown)
+        if (part.startswith('"""') and part.endswith('"""')) or \
+           (part.startswith("'''") and part.endswith("'''")):
+            # It's a markdown cell
+            # Remove the triple quotes
+            markdown_content = part[3:-3].strip()
+
+            # Skip empty markdown cells
+            if markdown_content:
+                cells.append({
+                    'cell_type': 'markdown',
+                    'source': markdown_content,
+                    'metadata': {}
+                })
+        else:
+            # It's a code cell
+            # Skip commented out code and special markers
+            if part and not part.startswith('# Commented out IPython magic'):
+                cells.append({
+                    'cell_type': 'code',
+                    'source': part,
+                    'metadata': {},
+                    'execution_count': None,
+                    'outputs': []
+                })
+
+    return cells
+
+
+def convert_colab_py_to_py_percent(input_path: Path, output_path: Path, include_uv_deps: bool = True) -> None:
+    """
+    Convert Colab-exported .py file to py:percent format (# %% markers).
+
+    Args:
+        input_path: Path to Colab .py file
+        output_path: Path to output .py file with # %% markers
+        include_uv_deps: Whether to extract and add UV inline script dependencies
+    """
+    # Read Colab .py file
+    with open(input_path, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    # Detect format
+    if not detect_colab_format(content):
+        print(f"Warning: {input_path.name} doesn't appear to be in Colab format")
+        print(f"  (Already has # %% markers or missing docstrings)")
+        return
+
+    # Parse Colab format into cells
+    cells = parse_colab_py(content)
+
+    if not cells:
+        print(f"Error: No cells found in {input_path.name}")
+        return
+
+    # Extract dependencies if requested
+    header_lines = []
+    if include_uv_deps:
+        # Create a temporary notebook structure to extract dependencies
+        temp_notebook = {'cells': cells}
+        dependencies = extract_pip_dependencies(temp_notebook)
+
+        if dependencies:
+            header_lines.append('# /// script')
+            header_lines.append('# dependencies = [')
+            for dep in sorted(dependencies):
+                header_lines.append(f'#   "{dep}",')
+            header_lines.append('# ]')
+            header_lines.append('# ///')
+            header_lines.append('')
+
+    # Generate py:percent format
+    py_content = generate_py_percent(cells)
+
+    # Combine header and content
+    if header_lines:
+        final_content = '\n'.join(header_lines) + '\n' + py_content
+    else:
+        final_content = py_content
+
+    # Write output
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write(final_content)
+
+    print(f"✓ Converted Colab format {input_path.name} → {output_path.name}")
+    print(f"  Format: Colab docstrings → py:percent (# %%) markers")
+
+    if include_uv_deps and dependencies:
+        print(f"  Found dependencies: {', '.join(sorted(dependencies))}")
+        print(f"  Run with: more-compute {output_path.name}")
+
+
+def convert_py_to_ipynb(py_path: Path, output_path: Path) -> None:
+    """
+    Convert .py notebook to .ipynb format.
+
+    Automatically detects format (Colab, VSCode, JupyterLab).
+
+    Args:
+        py_path: Path to input .py file
+        output_path: Path to output .ipynb file
+    """
+    # Read .py file
+    with open(py_path, 'r', encoding='utf-8') as f:
+        py_content = f.read()
+
+    # Detect format and parse accordingly
+    if detect_colab_format(py_content):
+        # Parse Colab format (docstrings as markdown)
+        cells = parse_colab_py(py_content)
+        notebook_data = {
+            'cells': cells,
+            'metadata': {
+                'kernelspec': {
+                    'display_name': 'Python 3',
+                    'language': 'python',
+                    'name': 'python3'
+                },
+                'language_info': {
+                    'name': 'python',
+                    'version': '3.8.0'
+                }
+            },
+            'nbformat': 4,
+            'nbformat_minor': 4
+        }
+    else:
+        # Parse py:percent format (# %% or # In[N]:)
+        notebook_data = parse_py_percent(py_content)
+
+    # Ensure source is in list format (Jupyter notebook standard)
+    for cell in notebook_data.get('cells', []):
+        source = cell.get('source', '')
+        if isinstance(source, str):
+            # Split into lines and keep newlines (Jupyter format)
+            lines = source.split('\n')
+            # Add \n to each line except the last
+            cell['source'] = [line + '\n' for line in lines[:-1]] + ([lines[-1]] if lines[-1] else [])
+
+    # Write .ipynb file
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(notebook_data, f, indent=1, ensure_ascii=False)
+
+    print(f"Converted {py_path.name} -> {output_path.name}")
+    print(f"  Upload to Google Colab or open in Jupyter")

{more_compute-0.4.2 → more_compute-0.4.3}/morecompute/utils/py_percent_parser.py

@@ -8,6 +8,10 @@ def parse_py_percent(content: str) -> Dict:
     """
     Parse py:percent format Python file into notebook structure.
 
+    Supports multiple formats:
+        # %% - VSCode/PyCharm format
+        # In[N]: - JupyterLab export format
+
     Format:
         # %%
         code cell content
@@ -23,9 +27,15 @@ def parse_py_percent(content: str) -> Dict:
     """
     cells = []
 
-    # Split by cell markers (# %%)
-    # Keep the marker in the split to determine cell type
-    parts = re.split(r'(# %%.*?\n)', content)
+    # Check if using JupyterLab In[] format
+    has_in_markers = bool(re.search(r'# In\[\d+\]:', content))
+
+    if has_in_markers:
+        # Parse JupyterLab # In[N]: format
+        parts = re.split(r'(# In\[\d+\]:.*?\n)', content)
+    else:
+        # Parse VSCode # %% format
+        parts = re.split(r'(# %%.*?\n)', content)
 
     # First part before any cell marker (usually imports/metadata)
     if parts[0].strip():

more_compute-0.4.2/morecompute/__version__.py

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

more_compute-0.4.2/morecompute/utils/notebook_converter.py

@@ -1,129 +0,0 @@
-"""Converter utilities for notebook formats."""
-
-import json
-import re
-from pathlib import Path
-from typing import List, Set
-from .py_percent_parser import generate_py_percent, parse_py_percent
-
-
-def extract_pip_dependencies(notebook_data: dict) -> Set[str]:
-    """
-    Extract package names from !pip install and %pip install commands.
-
-    Args:
-        notebook_data: Parsed notebook JSON
-
-    Returns:
-        Set of package names
-    """
-    packages = set()
-
-    for cell in notebook_data.get('cells', []):
-        if cell.get('cell_type') != 'code':
-            continue
-
-        source = cell.get('source', [])
-        if isinstance(source, list):
-            source = ''.join(source)
-
-        # Match: !pip install package1 package2
-        # Match: %pip install package1 package2
-        pip_pattern = r'[!%]pip\s+install\s+([^\n]+)'
-        matches = re.finditer(pip_pattern, source)
-
-        for match in matches:
-            install_line = match.group(1)
-            # Remove common flags
-            install_line = re.sub(r'--[^\s]+\s*', '', install_line)
-            install_line = re.sub(r'-[qU]\s*', '', install_line)
-
-            # Extract package names (handle package==version format)
-            parts = install_line.split()
-            for part in parts:
-                part = part.strip()
-                if part and not part.startswith('-'):
-                    packages.add(part)
-
-    return packages
-
-
-def convert_ipynb_to_py(ipynb_path: Path, output_path: Path, include_uv_deps: bool = True) -> None:
-    """
-    Convert .ipynb notebook to .py format with py:percent cell markers.
-
-    Args:
-        ipynb_path: Path to input .ipynb file
-        output_path: Path to output .py file
-        include_uv_deps: Whether to add UV inline script dependencies
-    """
-    # Read notebook
-    with open(ipynb_path, 'r', encoding='utf-8') as f:
-        notebook_data = json.load(f)
-
-    cells = notebook_data.get('cells', [])
-
-    # Generate UV dependencies header if requested
-    header_lines = []
-    if include_uv_deps:
-        dependencies = extract_pip_dependencies(notebook_data)
-        if dependencies:
-            header_lines.append('# /// script')
-            header_lines.append('# dependencies = [')
-            for dep in sorted(dependencies):
-                header_lines.append(f'#   "{dep}",')
-            header_lines.append('# ]')
-            header_lines.append('# ///')
-            header_lines.append('')
-
-    # Generate py:percent format
-    py_content = generate_py_percent(cells)
-
-    # Combine header and content
-    if header_lines:
-        final_content = '\n'.join(header_lines) + '\n' + py_content
-    else:
-        final_content = py_content
-
-    # Write output
-    with open(output_path, 'w', encoding='utf-8') as f:
-        f.write(final_content)
-
-    print(f"✓ Converted {ipynb_path.name} → {output_path.name}")
-
-    # Show dependencies if found
-    if include_uv_deps and dependencies:
-        print(f"  Found dependencies: {', '.join(sorted(dependencies))}")
-        print(f"  Run with: more-compute {output_path.name}")
-
-
-def convert_py_to_ipynb(py_path: Path, output_path: Path) -> None:
-    """
-    Convert .py notebook to .ipynb format.
-
-    Args:
-        py_path: Path to input .py file
-        output_path: Path to output .ipynb file
-    """
-    # Read .py file
-    with open(py_path, 'r', encoding='utf-8') as f:
-        py_content = f.read()
-
-    # Parse py:percent format to notebook structure
-    notebook_data = parse_py_percent(py_content)
-
-    # Ensure source is in list format (Jupyter notebook standard)
-    for cell in notebook_data.get('cells', []):
-        source = cell.get('source', '')
-        if isinstance(source, str):
-            # Split into lines and keep newlines (Jupyter format)
-            lines = source.split('\n')
-            # Add \n to each line except the last
-            cell['source'] = [line + '\n' for line in lines[:-1]] + ([lines[-1]] if lines[-1] else [])
-
-    # Write .ipynb file
-    with open(output_path, 'w', encoding='utf-8') as f:
-        json.dump(notebook_data, f, indent=1, ensure_ascii=False)
-
-    print(f"Converted {py_path.name} -> {output_path.name}")
-    print(f"  Upload to Google Colab or open in Jupyter")