holoscript 6.0.4__tar.gz → 6.0.5__tar.gz

{holoscript-6.0.4 → holoscript-6.0.5}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: holoscript
-Version: 6.0.4
-Summary: Python bindings for HoloScript parsing and validation
+Version: 6.0.5
+Summary: Python bindings for HoloScript — parsing, validation, and domain bridges for scientific computing
 Author: Brian X Base Team
 License: MIT
 Classifier: Development Status :: 4 - Beta
@@ -19,6 +19,19 @@ Description-Content-Type: text/markdown
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
 Requires-Dist: mypy>=1.11.0; extra == "dev"
+Provides-Extra: medical
+Requires-Dist: pydicom>=2.4.0; extra == "medical"
+Requires-Dist: numpy>=1.24.0; extra == "medical"
+Provides-Extra: alphafold
+Requires-Dist: requests>=2.31.0; extra == "alphafold"
+Provides-Extra: astronomy
+Requires-Dist: numpy>=1.24.0; extra == "astronomy"
+Provides-Extra: robotics
+Requires-Dist: roslibpy>=1.6.0; extra == "robotics"
+Provides-Extra: scientific
+Requires-Dist: numpy>=1.24.0; extra == "scientific"
+Provides-Extra: all
+Requires-Dist: holoscript[alphafold,astronomy,medical,robotics,scientific]; extra == "all"
 
 # holoscript (Python bindings)
 

{holoscript-6.0.4 → holoscript-6.0.5}/holoscript/__init__.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass, field
 from typing import Dict, List
 
 # Release version injected by CI from git tag. Dev version for local use.
-__version__ = "6.0.4"
+__version__ = "6.0.5"
 
 
 @dataclass

holoscript-6.0.5/holoscript/bridges/__init__.py

@@ -0,0 +1,11 @@
+"""
+HoloScript Domain Bridges — Python integrations for scientific computing.
+
+Install domain extras:
+  pip install holoscript[medical]        # DICOM imaging
+  pip install holoscript[alphafold]      # Protein structure prediction
+  pip install holoscript[astronomy]      # Radio astronomy / synchrotron
+  pip install holoscript[robotics]       # ROS2 integration
+  pip install holoscript[scientific]     # AutoDock molecular docking
+  pip install holoscript[all]            # Everything
+"""

holoscript-6.0.5/holoscript/bridges/alphafold.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+"""
+AlphaFold Bridge for HoloScript
+Protein structure prediction using AlphaFold3 API or ColabFold
+
+Requirements:
+  pip install requests
+
+Optional (for local prediction):
+  pip install colabfold
+
+Usage:
+  from alphafold_bridge import AlphaFoldBridge
+
+  bridge = AlphaFoldBridge(api_key='your_api_key')
+  result = bridge.predict_structure({
+      'sequence': 'MKTAYIAKQRQISFVKSHFSRQLEERLGLIEVQAPILSRVGDGTQDNLSGAEKAVQVKVK',
+      'job_name': 'my_protein',
+  })
+"""
+
+import sys
+import os
+import json
+import time
+from typing import Dict, List, Any, Optional
+import requests
+
+class AlphaFoldBridge:
+    """
+    AlphaFold bridge for protein structure prediction
+    """
+
+    def __init__(self, api_key: Optional[str] = None):
+        """
+        Initialize AlphaFold bridge
+
+        Args:
+            api_key: AlphaFold3 API key (optional, for API mode)
+        """
+        self.api_key = api_key or os.getenv('ALPHAFOLD_API_KEY')
+        self.api_base_url = 'https://api.alphafoldserver.com/v1'
+        self.colabfold_available = False
+        self._check_dependencies()
+
+    def _check_dependencies(self):
+        """Check if ColabFold is installed (for local prediction)"""
+        try:
+            import colabfold
+            self.colabfold_available = True
+            print("✓ ColabFold is available for local prediction", file=sys.stderr)
+        except ImportError:
+            self.colabfold_available = False
+            print("⚠ ColabFold not installed. API mode only.", file=sys.stderr)
+
+    def predict_structure(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Predict protein structure using AlphaFold
+
+        Args:
+            config: Prediction configuration
+              - sequence: str - Amino acid sequence (single-letter codes)
+              - job_name: str - Name for this prediction job
+              - mode: str - 'api' or 'local' (default: 'api')
+              - num_models: int - Number of models to generate (default: 5)
+              - use_templates: bool - Use template structures (default: False)
+
+        Returns:
+            Dictionary with prediction results:
+              - status: 'success' or 'failed'
+              - pdb_data: PDB file contents (if successful)
+              - confidence_scores: pLDDT scores per residue
+              - mean_plddt: Mean confidence score
+              - pae_data: Predicted Aligned Error matrix (optional)
+              - job_id: Job ID for tracking (API mode)
+        """
+        sequence = config['sequence']
+        job_name = config.get('job_name', 'holoscript_prediction')
+        mode = config.get('mode', 'api')
+        num_models = config.get('num_models', 5)
+        use_templates = config.get('use_templates', False)
+
+        if mode == 'api':
+            return self._predict_via_api(sequence, job_name, num_models, use_templates)
+        elif mode == 'local':
+            return self._predict_via_colabfold(sequence, job_name, num_models)
+        else:
+            return {
+                'error': f'Unknown prediction mode: {mode}',
+                'status': 'failed',
+            }
+
+    def _predict_via_api(
+        self,
+        sequence: str,
+        job_name: str,
+        num_models: int,
+        use_templates: bool
+    ) -> Dict[str, Any]:
+        """
+        Predict structure via AlphaFold3 API
+
+        Note: This is a stub - actual API integration requires:
+        1. AlphaFold3 API access (currently limited beta)
+        2. API authentication token
+        3. Polling for job completion
+        """
+        if not self.api_key:
+            return {
+                'error': 'AlphaFold API key not set. Set ALPHAFOLD_API_KEY environment variable.',
+                'status': 'failed',
+                'message': 'API mode requires authentication',
+            }
+
+        try:
+            # Submit prediction job
+            headers = {
+                'Authorization': f'Bearer {self.api_key}',
+                'Content-Type': 'application/json',
+            }
+
+            payload = {
+                'sequences': [{'sequence': sequence}],
+                'modelPreset': 'monomer' if num_models == 1 else 'multimer',
+                'numPredictions': num_models,
+                'useTemplates': use_templates,
+            }
+
+            # Note: This is a placeholder URL - actual API endpoint may differ
+            submit_url = f'{self.api_base_url}/predict'
+
+            print(f"Submitting prediction job: {job_name}", file=sys.stderr)
+            response = requests.post(submit_url, json=payload, headers=headers, timeout=30)
+
+            if response.status_code == 202:
+                # Job accepted, poll for results
+                job_data = response.json()
+                job_id = job_data.get('jobId')
+
+                print(f"Job ID: {job_id}. Polling for completion...", file=sys.stderr)
+                return self._poll_job_status(job_id, headers)
+            else:
+                return {
+                    'error': f'API request failed: {response.status_code}',
+                    'status': 'failed',
+                    'message': response.text,
+                }
+
+        except Exception as e:
+            return {
+                'error': str(e),
+                'status': 'failed',
+                'message': f'AlphaFold API prediction failed: {str(e)}',
+            }
+
+    def _poll_job_status(self, job_id: str, headers: Dict[str, str]) -> Dict[str, Any]:
+        """
+        Poll AlphaFold API job status until completion
+
+        Args:
+            job_id: Job ID from submission
+            headers: Request headers with auth
+
+        Returns:
+            Prediction results
+        """
+        status_url = f'{self.api_base_url}/jobs/{job_id}'
+        max_polls = 60  # Max 10 minutes (60 * 10 seconds)
+        poll_interval = 10  # seconds
+
+        for attempt in range(max_polls):
+            try:
+                response = requests.get(status_url, headers=headers, timeout=30)
+                if response.status_code == 200:
+                    job_data = response.json()
+                    status = job_data.get('status')
+
+                    if status == 'completed':
+                        # Download results
+                        pdb_url = job_data.get('pdbUrl')
+                        confidence_url = job_data.get('confidenceUrl')
+
+                        pdb_data = requests.get(pdb_url, timeout=30).text
+                        confidence_data = requests.get(confidence_url, timeout=30).json()
+
+                        return {
+                            'status': 'success',
+                            'job_id': job_id,
+                            'pdb_data': pdb_data,
+                            'confidence_scores': confidence_data.get('plddt', []),
+                            'mean_plddt': confidence_data.get('meanPlddt', 0.0),
+                            'pae_data': confidence_data.get('pae', None),
+                        }
+                    elif status == 'failed':
+                        return {
+                            'error': 'Prediction job failed',
+                            'status': 'failed',
+                            'job_id': job_id,
+                        }
+                    else:
+                        print(f"Job status: {status}. Waiting...", file=sys.stderr)
+                        time.sleep(poll_interval)
+
+            except Exception as e:
+                print(f"Polling error: {e}. Retrying...", file=sys.stderr)
+                time.sleep(poll_interval)
+
+        return {
+            'error': 'Job timeout after 10 minutes',
+            'status': 'failed',
+            'job_id': job_id,
+        }
+
+    def _predict_via_colabfold(
+        self,
+        sequence: str,
+        job_name: str,
+        num_models: int
+    ) -> Dict[str, Any]:
+        """
+        Predict structure via local ColabFold installation
+
+        Note: Requires ColabFold + GPU for reasonable performance
+        """
+        if not self.colabfold_available:
+            return {
+                'error': 'ColabFold not installed',
+                'status': 'failed',
+                'message': 'Install ColabFold: pip install colabfold',
+            }
+
+        try:
+            # Note: This is a simplified stub
+            # Full implementation requires:
+            # 1. Write sequence to FASTA file
+            # 2. Run colabfold_batch command
+            # 3. Parse output PDB and confidence JSON
+
+            return {
+                'error': 'Local ColabFold prediction not yet implemented',
+                'status': 'failed',
+                'message': 'Use API mode for now: mode="api"',
+            }
+
+        except Exception as e:
+            return {
+                'error': str(e),
+                'status': 'failed',
+                'message': f'ColabFold prediction failed: {str(e)}',
+            }
+
+    def predict_multimer(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Predict protein complex structure (AlphaFold-Multimer)
+
+        Args:
+            config: Multimer prediction configuration
+              - sequences: List[str] - Multiple protein sequences
+              - stoichiometry: List[int] - Copy numbers (e.g., [2, 1] for A2B)
+              - job_name: str - Name for this prediction
+
+        Returns:
+            Prediction results (same format as predict_structure)
+        """
+        sequences = config['sequences']
+        stoichiometry = config.get('stoichiometry', [1] * len(sequences))
+        job_name = config.get('job_name', 'multimer_prediction')
+
+        if not self.api_key:
+            return {
+                'error': 'Multimer prediction requires API access',
+                'status': 'failed',
+            }
+
+        try:
+            headers = {
+                'Authorization': f'Bearer {self.api_key}',
+                'Content-Type': 'application/json',
+            }
+
+            # Build multimer payload
+            chains = []
+            for i, seq in enumerate(sequences):
+                for _ in range(stoichiometry[i]):
+                    chains.append({'sequence': seq})
+
+            payload = {
+                'sequences': chains,
+                'modelPreset': 'multimer',
+                'numPredictions': 5,
+            }
+
+            submit_url = f'{self.api_base_url}/predict'
+            response = requests.post(submit_url, json=payload, headers=headers, timeout=30)
+
+            if response.status_code == 202:
+                job_data = response.json()
+                job_id = job_data.get('jobId')
+                return self._poll_job_status(job_id, headers)
+            else:
+                return {
+                    'error': f'Multimer API request failed: {response.status_code}',
+                    'status': 'failed',
+                }
+
+        except Exception as e:
+            return {
+                'error': str(e),
+                'status': 'failed',
+                'message': f'Multimer prediction failed: {str(e)}',
+            }
+
+    def get_status(self) -> Dict[str, Any]:
+        """
+        Get AlphaFold bridge status
+
+        Returns:
+            Status dictionary
+        """
+        return {
+            'api_available': bool(self.api_key),
+            'colabfold_available': self.colabfold_available,
+            'python_version': sys.version,
+            'module': 'alphafold_bridge',
+            'version': '1.0.0',
+        }
+
+
+# Test mode
+if __name__ == '__main__':
+    bridge = AlphaFoldBridge()
+
+    # Test status
+    status = bridge.get_status()
+    print("AlphaFold Bridge Status:")
+    print(f"  API Available: {status['api_available']}")
+    print(f"  ColabFold Available: {status['colabfold_available']}")
+    print(f"  Python: {status['python_version']}")
+
+    if not status['api_available']:
+        print("\n⚠ To use AlphaFold API, set environment variable:")
+        print("  export ALPHAFOLD_API_KEY=your_api_key")
+    if not status['colabfold_available']:
+        print("\n⚠ To use local prediction, install ColabFold:")
+        print("  pip install colabfold")

holoscript-6.0.5/holoscript/bridges/medical.py

@@ -0,0 +1,236 @@
+"""
+DICOM Medical Imaging Bridge for HoloScript
+Provides DICOM loading, windowing, and 3D volume extraction via JSON-RPC
+"""
+
+import json
+import sys
+from pathlib import Path
+from typing import Dict, Any, List, Tuple
+
+try:
+    import pydicom
+    import numpy as np
+except ImportError:
+    print("ERROR: Missing dependencies. Install: pip install pydicom numpy", file=sys.stderr)
+    sys.exit(1)
+
+
+class DICOMBridge:
+    """Python bridge for DICOM medical imaging operations"""
+
+    def __init__(self):
+        self.current_dataset = None
+
+    def load_dicom(self, file_path: str) -> Dict[str, Any]:
+        """
+        Load DICOM file and return metadata
+
+        Args:
+            file_path: Path to DICOM file (.dcm)
+
+        Returns:
+            DICOM metadata dictionary
+        """
+        try:
+            self.current_dataset = pydicom.dcmread(file_path)
+            ds = self.current_dataset
+
+            metadata = {
+                'success': True,
+                'patientName': str(ds.get('PatientName', 'Unknown')),
+                'patientID': str(ds.get('PatientID', 'Unknown')),
+                'studyDate': str(ds.get('StudyDate', '')),
+                'modality': str(ds.get('Modality', 'Unknown')),
+                'sliceThickness': float(ds.get('SliceThickness', 1.0)),
+                'pixelSpacing': [
+                    float(ds.PixelSpacing[0]) if hasattr(ds, 'PixelSpacing') else 1.0,
+                    float(ds.PixelSpacing[1]) if hasattr(ds, 'PixelSpacing') else 1.0,
+                ],
+                'rows': int(ds.Rows),
+                'columns': int(ds.Columns),
+                'windowCenter': float(ds.get('WindowCenter', 40)) if hasattr(ds, 'WindowCenter') else None,
+                'windowWidth': float(ds.get('WindowWidth', 400)) if hasattr(ds, 'WindowWidth') else None,
+            }
+
+            if hasattr(ds, 'NumberOfFrames'):
+                metadata['numberOfFrames'] = int(ds.NumberOfFrames)
+
+            return metadata
+
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+
+    def apply_window_level(self, center: float, width: float) -> Dict[str, Any]:
+        """
+        Apply window/level to current DICOM dataset
+
+        Args:
+            center: Window center (Hounsfield units)
+            width: Window width
+
+        Returns:
+            Windowed image data as base64-encoded PNG
+        """
+        if self.current_dataset is None:
+            return {'success': False, 'error': 'No DICOM loaded'}
+
+        try:
+            # Get pixel array
+            pixels = self.current_dataset.pixel_array
+
+            # Prevent division by zero for extreme contrast
+            width = max(1.0, float(width))
+
+            # Apply window/level transformation
+            lower = center - (width / 2)
+            upper = center + (width / 2)
+            windowed = np.clip(pixels, lower, upper)
+
+            # Normalize to 0-255 safely
+            window_range = upper - lower
+            windowed = ((windowed - lower) / window_range * 255.0)
+            
+            # Ensure it is properly clipped before casting to uint8
+            windowed = np.clip(windowed, 0, 255).astype(np.uint8)
+
+            # Convert to list for JSON serialization
+            return {
+                'success': True,
+                'width': int(self.current_dataset.Columns),
+                'height': int(self.current_dataset.Rows),
+                'data': windowed.flatten().tolist(),  # 1D array
+            }
+
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+
+    def extract_3d_volume(self, series_path: str) -> Dict[str, Any]:
+        """
+        Extract 3D volume from DICOM series (multiple slice files)
+
+        Args:
+            series_path: Directory containing DICOM series
+
+        Returns:
+            3D volume data with dimensions and spacing
+        """
+        try:
+            series_dir = Path(series_path)
+            if not series_dir.is_dir():
+                return {'success': False, 'error': f'Not a directory: {series_path}'}
+
+            # Load all DICOM files in directory
+            dicom_files = sorted(series_dir.glob('*.dcm'))
+            if not dicom_files:
+                return {'success': False, 'error': 'No DICOM files found'}
+
+            # Read first file for metadata
+            first_ds = pydicom.dcmread(dicom_files[0])
+            rows = first_ds.Rows
+            columns = first_ds.Columns
+            num_slices = len(dicom_files)
+
+            # Get spacing
+            pixel_spacing = [float(x) for x in first_ds.PixelSpacing]
+            slice_thickness = float(first_ds.get('SliceThickness', 1.0))
+
+            # Allocate volume
+            volume = np.zeros((num_slices, rows, columns), dtype=np.int16)
+
+            # Load all slices
+            for i, file_path in enumerate(dicom_files):
+                ds = pydicom.dcmread(file_path)
+                volume[i] = ds.pixel_array
+
+            return {
+                'success': True,
+                'dimensions': [num_slices, rows, columns],
+                'spacing': [slice_thickness, pixel_spacing[0], pixel_spacing[1]],
+                'origin': [0, 0, 0],  # Can extract from ImagePositionPatient if available
+                'min': int(volume.min()),
+                'max': int(volume.max()),
+                # Note: Returning full volume data would be too large for JSON
+                # In production, save to file or stream binary data
+            }
+
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+
+    def dicom_to_mesh(self, threshold: float, smoothing: bool = True) -> Dict[str, Any]:
+        """
+        Convert current DICOM to 3D mesh using marching cubes
+
+        Args:
+            threshold: Hounsfield threshold for surface extraction
+            smoothing: Apply mesh smoothing
+
+        Returns:
+            Mesh vertices and faces
+
+        Note: Requires scikit-image for marching cubes algorithm
+        """
+        try:
+            from skimage import measure
+        except ImportError:
+            return {
+                'success': False,
+                'error': 'scikit-image required: pip install scikit-image'
+            }
+
+        if self.current_dataset is None:
+            return {'success': False, 'error': 'No DICOM loaded'}
+
+        try:
+            # For single-slice DICOM, this would need 3D volume
+            # Simplified example for demo
+            pixels = self.current_dataset.pixel_array
+
+            # Marching cubes requires 3D volume
+            # In practice, use extract_3d_volume first
+            return {
+                'success': False,
+                'error': 'Mesh extraction requires 3D volume (DICOM series)'
+            }
+
+        except Exception as e:
+            return {'success': False, 'error': str(e)}
+
+
+# JSON-RPC server (simple stdin/stdout protocol)
+def main():
+    bridge = DICOMBridge()
+
+    print("DICOM Bridge Ready", file=sys.stderr)
+
+    for line in sys.stdin:
+        try:
+            request = json.loads(line.strip())
+            method = request.get('method')
+            params = request.get('params', {})
+
+            if method == 'loadDICOM':
+                result = bridge.load_dicom(params['filePath'])
+            elif method == 'applyWindowLevel':
+                result = bridge.apply_window_level(params['center'], params['width'])
+            elif method == 'extract3DVolume':
+                result = bridge.extract3d_volume(params['seriesPath'])
+            elif method == 'dicomToMesh':
+                result = bridge.dicom_to_mesh(
+                    params['threshold'],
+                    params.get('smoothing', True)
+                )
+            else:
+                result = {'success': False, 'error': f'Unknown method: {method}'}
+
+            print(json.dumps(result))
+            sys.stdout.flush()
+
+        except Exception as e:
+            error_result = {'success': False, 'error': str(e)}
+            print(json.dumps(error_result))
+            sys.stdout.flush()
+
+
+if __name__ == '__main__':
+    main()