featrixsphere 0.2.1637__tar.gz → 0.2.1830__tar.gz

{featrixsphere-0.2.1637 → featrixsphere-0.2.1830}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: featrixsphere
-Version: 0.2.1637
+Version: 0.2.1830
 Summary: Transform any CSV into a production-ready ML model in minutes, not months.
 Home-page: https://github.com/Featrix/sphere
 Author: Featrix

featrixsphere-0.2.1830/VERSION

@@ -0,0 +1 @@
+0.2.1830

{featrixsphere-0.2.1637 → featrixsphere-0.2.1830}/featrix-update.py

@@ -409,10 +409,24 @@ def main():
         newest_version = newest['version']
         newest_filename = newest['filename']
         newest_hash = newest.get('hash')
+        newest_date = newest.get('date_modified')
         newest_url = f"{FIRMWARE_SERVER}/{newest_filename}"
         
+        # Format date if available
+        date_str = ""
+        if newest_date:
+            try:
+                # Parse ISO format date and format nicely
+                date_obj = datetime.fromisoformat(newest_date.replace('Z', '+00:00'))
+                date_str = date_obj.strftime("%Y-%m-%d %H:%M:%S")
+            except Exception:
+                # Fallback to raw date if parsing fails
+                date_str = newest_date
+        
         print(f"\n📊 Available versions:")
         print(f"   Newest: {newest_version} ({newest_filename})")
+        if date_str:
+            print(f"   Date: {date_str}")
         if newest_hash:
             print(f"   Hash: {newest_hash[:16]}...")
         

{featrixsphere-0.2.1637 → featrixsphere-0.2.1830}/featrixsphere/__init__.py

@@ -38,7 +38,7 @@ Example:
     ...                                labels=['Experiment A', 'Experiment B'])
 """
 
-__version__ = "0.2.1637"
+__version__ = "0.2.1830"
 __author__ = "Featrix"
 __email__ = "support@featrix.com"
 __license__ = "MIT"

{featrixsphere-0.2.1637 → featrixsphere-0.2.1830}/featrixsphere/client.py

@@ -5372,6 +5372,219 @@ class FeatrixSphereClient:
             if verbose:
                 print(f"❌ Error starting predictor continuation: {e}")
             raise
+    
+    def train_on_partial_foundation(
+        self,
+        foundation_session_id: str,
+        local_data_file: str,
+        target_column: str,
+        target_column_type: str,
+        checkpoint_epoch: int = None,
+        epochs: int = 0,
+        rare_label_value: str = None,
+        use_class_weights: bool = True,
+        class_imbalance: dict = None,
+        cost_false_positive: float = None,
+        cost_false_negative: float = None,
+        name: str = None,
+        session_name_prefix: str = None,
+        webhooks: Dict[str, str] = None,
+        poll_interval: int = 30,
+        max_poll_time: int = 3600,
+        verbose: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Train a predictor on a partial/in-progress foundation model.
+        
+        Designed for use while the foundation model is STILL TRAINING. Test predictor
+        performance on intermediate checkpoints without waiting for full ES training
+        to complete. Also works with completed foundation training.
+        
+        Creates a NEW session using:
+        - Checkpoint from foundation's ES training (specific epoch or best/latest)
+        - Your uploaded data file for predictor training
+        - Metadata about foundation training progress at checkpoint time
+        
+        Perfect for:
+        - Testing predictor performance while ES is still training
+        - Training on partially-trained foundation models
+        - Running parallel experiments on different checkpoint epochs
+        
+        Args:
+            foundation_session_id: Session ID with ES training (in-progress or completed)
+            local_data_file: Path to CSV file on YOUR MACHINE (will be uploaded)
+            target_column: Column to predict
+            target_column_type: "set" for classification, "scalar" for regression
+            checkpoint_epoch: Which epoch checkpoint to use (None = best/latest available)
+            epochs: Predictor training epochs (0 = auto-calculate based on data size)
+            rare_label_value: Minority class label for binary classification
+            use_class_weights: Enable class weighting for imbalanced data
+            class_imbalance: Expected class distribution from real world
+            cost_false_positive: Cost of false positive (classification only)
+            cost_false_negative: Cost of false negative (classification only)
+            name: Optional name for the new session
+            session_name_prefix: Optional prefix for session ID
+            webhooks: Webhook configuration dict
+            poll_interval: Seconds between status checks (default: 30)
+            max_poll_time: Maximum polling time in seconds (default: 3600 = 1 hour)
+            verbose: Print status updates
+            
+        Returns:
+            dict with:
+                - new_session_id: Created session ID
+                - foundation_session_id: Original foundation session
+                - checkpoint_epoch: Epoch used for checkpoint
+                - foundation_training_metadata: Progress info when checkpoint was created
+                - target_column: Column being predicted
+                - predictor_epochs: Training epochs
+                
+        Example:
+            ```python
+            # Train on epoch 50 checkpoint while ES is still training
+            result = client.train_on_partial_foundation(
+                foundation_session_id="abc-def-ghi",
+                local_data_file="my_data.csv",
+                target_column="price",
+                target_column_type="scalar",
+                checkpoint_epoch=50,
+                epochs=100
+            )
+            
+            print(f"New session: {result['new_session_id']}")
+            print(f"Foundation was {result['foundation_training_metadata']['training_progress_percent']}% trained")
+            ```
+        """
+        import os
+        from pathlib import Path
+        
+        # Validate inputs
+        if not os.path.exists(local_data_file):
+            raise FileNotFoundError(f"Local data file not found: {local_data_file}")
+        
+        if target_column_type not in ["set", "scalar"]:
+            raise ValueError("target_column_type must be 'set' or 'scalar'")
+        
+        # Prepare form data
+        form_data = {
+            'target_column': target_column,
+            'target_column_type': target_column_type,
+            'epochs': str(epochs),
+            'use_class_weights': str(use_class_weights).lower(),
+        }
+        
+        if checkpoint_epoch is not None:
+            form_data['checkpoint_epoch'] = str(checkpoint_epoch)
+        if rare_label_value:
+            form_data['rare_label_value'] = rare_label_value
+        if class_imbalance:
+            import json
+            form_data['class_imbalance'] = json.dumps(class_imbalance)
+        if cost_false_positive is not None:
+            form_data['cost_false_positive'] = str(cost_false_positive)
+        if cost_false_negative is not None:
+            form_data['cost_false_negative'] = str(cost_false_negative)
+        if name:
+            form_data['name'] = name
+        if session_name_prefix:
+            form_data['session_name_prefix'] = session_name_prefix
+        if webhooks:
+            import json
+            form_data['webhooks'] = json.dumps(webhooks)
+        
+        # Upload file
+        try:
+            with open(local_data_file, 'rb') as f:
+                files = {'file': (Path(local_data_file).name, f, 'text/csv')}
+                response_data = self._post_multipart(
+                    f"/compute/session/{foundation_session_id}/train_on_partial_foundation",
+                    data=form_data,
+                    files=files
+                )
+            
+            new_session_id = response_data.get('new_session_id')
+            checkpoint_epoch_used = response_data.get('checkpoint_epoch')
+            training_metadata = response_data.get('foundation_training_metadata', {})
+            
+            if verbose:
+                print(f"✅ {response_data.get('message')}")
+                print(f"   New session ID: {new_session_id}")
+                print(f"   Checkpoint epoch: {checkpoint_epoch_used}")
+                if training_metadata.get('training_progress_percent'):
+                    print(f"   Foundation training progress: {training_metadata['training_progress_percent']}%")
+                if training_metadata.get('validation_loss_at_checkpoint'):
+                    print(f"   Val loss at checkpoint: {training_metadata['validation_loss_at_checkpoint']:.4f}")
+            
+            # Poll for completion if requested
+            if poll_interval > 0 and max_poll_time > 0 and new_session_id:
+                import time
+                start_time = time.time()
+                last_message = ""
+                
+                while time.time() - start_time < max_poll_time:
+                    try:
+                        session_info = self.get_session_status(new_session_id)
+                        jobs = session_info.jobs if hasattr(session_info, 'jobs') else {}
+                        
+                        # Find predictor training jobs
+                        sp_jobs = {j_id: j for j_id, j in jobs.items() 
+                                 if 'train_single_predictor' in j.get('type', '')}
+                        
+                        if not sp_jobs:
+                            if verbose:
+                                print("⏳ Waiting for predictor job to start...")
+                            time.sleep(poll_interval)
+                            continue
+                        
+                        # Check statuses
+                        running = [j_id for j_id, j in sp_jobs.items() if j.get('status') == 'running']
+                        done = [j_id for j_id, j in sp_jobs.items() if j.get('status') == 'done']
+                        failed = [j_id for j_id, j in sp_jobs.items() if j.get('status') == 'failed']
+                        
+                        status_msg = f"Running: {len(running)}, Done: {len(done)}, Failed: {len(failed)}"
+                        if status_msg != last_message and verbose:
+                            print(f"📊 {status_msg}")
+                            last_message = status_msg
+                        
+                        if not running and (done or failed):
+                            if done:
+                                if verbose:
+                                    print(f"✅ Predictor training completed!")
+                                return {
+                                    **response_data,
+                                    "status": "completed",
+                                    "poll_time": int(time.time() - start_time)
+                                }
+                            elif failed:
+                                if verbose:
+                                    print(f"❌ Predictor training failed")
+                                return {
+                                    **response_data,
+                                    "status": "failed",
+                                    "failed_jobs": failed,
+                                    "poll_time": int(time.time() - start_time)
+                                }
+                        
+                        time.sleep(poll_interval)
+                    except Exception as poll_error:
+                        if verbose:
+                            print(f"⚠️  Polling error: {poll_error}")
+                        time.sleep(poll_interval)
+                
+                if verbose:
+                    print(f"⏰ Polling timeout ({max_poll_time}s). Training may still be in progress.")
+                
+                return {
+                    **response_data,
+                    "status": "timeout",
+                    "poll_time": max_poll_time
+                }
+            
+            return response_data
+            
+        except Exception as e:
+            if verbose:
+                print(f"❌ Error training on partial foundation: {e}")
+            raise
 
     def foundation_model_train_more(self, session_id: str, es_id: str = None, data_passes: int = None,
                                    epochs: int = None, poll_interval: int = 30, max_poll_time: int = 3600,

{featrixsphere-0.2.1637 → featrixsphere-0.2.1830}/featrixsphere.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: featrixsphere
-Version: 0.2.1637
+Version: 0.2.1830
 Summary: Transform any CSV into a production-ready ML model in minutes, not months.
 Home-page: https://github.com/Featrix/sphere
 Author: Featrix

{featrixsphere-0.2.1637 → featrixsphere-0.2.1830}/featrixsphere.egg-info/SOURCES.txt

@@ -71,6 +71,8 @@ src/version.py
 src/lib/api_event_retry.py
 src/lib/celery_job_recovery.py
 src/lib/convergence_monitor.py
+src/lib/crash_tracker.py
+src/lib/distribution_shift_detector.py
 src/lib/epoch_projections.py
 src/lib/es_projections.py
 src/lib/es_training.py
@@ -86,6 +88,7 @@ src/lib/single_predictor_cv.py
 src/lib/single_predictor_training.py
 src/lib/sphere_config.py
 src/lib/structureddata.py
+src/lib/system_health_monitor.py
 src/lib/training_monitor.py
 src/lib/utils.py
 src/lib/vector_db.py