featrixsphere 0.2.1462__py3-none-any.whl → 0.2.1830__py3-none-any.whl

featrixsphere/__init__.py

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

featrixsphere/client.py

@@ -281,9 +281,20 @@ class FeatrixSphereClient:
             max_retries = self.default_max_retries
         
         # Special handling for session endpoints - longer retry window for 504 errors
-        is_session_endpoint = '/session/' in endpoint
-        if max_retry_time is None and is_session_endpoint:
-            max_retry_time = 120.0  # 120 seconds for session endpoints
+        # Session endpoints include /session/ and /upload_with_new_session/ (creates session)
+        is_session_endpoint = '/session/' in endpoint or '/upload_with_new_session' in endpoint
+        
+        # For upload endpoints, use a much longer timeout (10 minutes for large files)
+        # This MUST happen before setting max_retry_time to ensure uploads get proper timeout
+        if '/upload_with_new_session' in endpoint:
+            # Override timeout if not explicitly set in kwargs
+            if 'timeout' not in kwargs:
+                kwargs['timeout'] = 600  # 10 minutes for file uploads
+            # Also set a longer max_retry_time for upload endpoints (10 minutes)
+            if max_retry_time is None:
+                max_retry_time = 600.0  # 10 minutes for upload endpoints
+        elif max_retry_time is None and is_session_endpoint:
+            max_retry_time = 120.0  # 120 seconds for other session endpoints
             
         # Auto-add /compute prefix for session endpoints
         if endpoint.startswith('/session/') and not endpoint.startswith('/compute/session/'):
@@ -323,7 +334,8 @@ class FeatrixSphereClient:
                         else:
                             # Out of retry time
                             print(f"API request failed: {method} {url}")
-                            print(f"504 Gateway Timeout - exceeded max retry time ({max_retry_time}s)")
+                            max_retry_time_str = f"{max_retry_time}s" if max_retry_time else "None"
+                            print(f"504 Gateway Timeout - exceeded max retry time ({max_retry_time_str})")
                             raise
                     
                     # Check for server restart patterns in 500 errors
@@ -1082,19 +1094,29 @@ class FeatrixSphereClient:
                 """
                 
                 if session_info.jobs:
+                    # Human-readable job type descriptions
+                    JOB_TYPE_NAMES = {
+                        'create_structured_data': 'Creating Structured Data',
+                        'train_es': 'Training Embedding Space',
+                        'train_knn': 'Training KNN Index',
+                        'run_clustering': 'Running Clustering',
+                        'train_single_predictor': 'Training Predictor',
+                    }
+                    
                     html_content += "<h4>Jobs:</h4><ul>"
                     for job_id, job in session_info.jobs.items():
                         job_status = job.get('status', 'unknown')
                         progress = job.get('progress')
                         job_type = job.get('type', job_id.split('_')[0])
+                        job_display_name = JOB_TYPE_NAMES.get(job_type, job_type)
                         
                         if progress is not None:
                             progress_pct = progress * 100
                             progress_bar = "▓" * int(progress_pct / 5) + "░" * (20 - int(progress_pct / 5))
-                            html_content += f"<li><strong>{job_type}:</strong> {job_status} [{progress_bar}] {progress_pct:.1f}%</li>"
+                            html_content += f"<li><strong>{job_display_name}:</strong> {job_status} [{progress_bar}] {progress_pct:.1f}%</li>"
                         else:
                             status_emoji = "✅" if job_status == "done" else "🔄" if job_status == "running" else "❌"
-                            html_content += f"<li>{status_emoji} <strong>{job_type}:</strong> {job_status}</li>"
+                            html_content += f"<li>{status_emoji} <strong>{job_display_name}:</strong> {job_status}</li>"
                     html_content += "</ul>"
                 
                 display(HTML(html_content))
@@ -1149,6 +1171,15 @@ class FeatrixSphereClient:
             from rich.text import Text
             import time
             
+            # Human-readable job type descriptions
+            JOB_TYPE_NAMES = {
+                'create_structured_data': 'Creating Structured Data',
+                'train_es': 'Training Embedding Space',
+                'train_knn': 'Training KNN Index',
+                'run_clustering': 'Running Clustering',
+                'train_single_predictor': 'Training Predictor',
+            }
+            
             start_time = time.time()
             job_tasks = {}  # Track progress tasks for each job
             
@@ -1180,15 +1211,18 @@ class FeatrixSphereClient:
                     for job_id, job in session_info.jobs.items():
                         if job_id not in job_tasks:
                             job_type = job.get('type', job_id.split('_')[0])
-                            job_tasks[job_id] = progress.add_task(f"[cyan]{job_type}", total=100)
+                            job_display_name = JOB_TYPE_NAMES.get(job_type, job_type)
+                            job_tasks[job_id] = progress.add_task(f"[cyan]{job_display_name}", total=100)
                         
                         # Update job progress
                         job_status = job.get('status', 'unknown')
                         raw_progress = job.get('progress', 0)
                         job_progress = 100 if job_status == 'done' else (raw_progress * 100 if raw_progress else 0)
                         
+                        job_type = job.get('type', job_id.split('_')[0])
+                        job_display_name = JOB_TYPE_NAMES.get(job_type, job_type)
                         progress.update(job_tasks[job_id], completed=job_progress,
-                                      description=f"[cyan]{job.get('type', job_id.split('_')[0])} ({job_status})")
+                                      description=f"[cyan]{job_display_name} ({job_status})")
                     
                     # Check completion
                     if session_info.status in ['done', 'failed', 'cancelled']:
@@ -1232,8 +1266,20 @@ class FeatrixSphereClient:
             status_callback(session_info, elapsed)
             
             # Check if completed
+            # CRITICAL: Only return done if we actually have jobs that completed
+            # If no jobs exist, session shouldn't be marked as done
             if session_info.status in ['completed', 'done', 'DONE']:
-                return session_info
+                # Verify that jobs actually exist and completed
+                if session_info.jobs:
+                    # Check if all jobs are in terminal states
+                    terminal_states = {'done', 'failed', 'cancelled'}
+                    all_terminal = all(job.get('status') in terminal_states for job in session_info.jobs.values())
+                    if all_terminal:
+                        return session_info
+                else:
+                    # No jobs but status is "done" - this is a bug, keep waiting
+                    logger.warning(f"⚠️  Session {session_id} status is 'done' but no jobs exist - this shouldn't happen, continuing to wait...")
+                    # Don't return - keep waiting for jobs to appear
             
             time.sleep(check_interval)
         
@@ -2145,8 +2191,38 @@ class FeatrixSphereClient:
             data['quick_run'] = 'true'
             data['epochs'] = str(epochs)
             print(f"Training epochs: {epochs} (quick_run mode enabled)")
-            
-        response = self._make_request("POST", "/compute/upload_with_new_session/", files=files, data=data)
+        
+        # Check file size - warn if very large
+        file_size_mb = len(file_content) / (1024 * 1024)
+        CHUNK_SIZE_MB = 512  # 512 MB chunk size
+        CHUNK_SIZE_BYTES = CHUNK_SIZE_MB * 1024 * 1024
+        
+        if file_size_mb > CHUNK_SIZE_MB:
+            print(f"⚠️  Warning: File size ({file_size_mb:.1f} MB) exceeds {CHUNK_SIZE_MB} MB threshold")
+            print(f"   Large uploads may timeout. Consider splitting the data or using smaller batches.")
+        
+        # Try upload with retry on 504
+        import time
+        upload_trace_id = f"UPLOAD-{int(time.time()*1000)}"
+        print(f"🔵 [CLIENT] {upload_trace_id} Starting upload request")
+        print(f"   Endpoint: /compute/upload_with_new_session/")
+        print(f"   File: {filename}, Size: {file_size_mb:.2f} MB")
+        print(f"   Form data keys: {list(data.keys())}")
+        try:
+            response = self._make_request("POST", "/compute/upload_with_new_session/", files=files, data=data)
+            print(f"🔵 [CLIENT] {upload_trace_id} Received response: HTTP {response.status_code}")
+        except requests.exceptions.HTTPError as e:
+            # If we get a 504 and file is large, suggest chunking
+            if e.response and e.response.status_code == 504 and file_size_mb > CHUNK_SIZE_MB:
+                print(f"\n❌ 504 Gateway Timeout on large file upload ({file_size_mb:.1f} MB)")
+                print(f"   File exceeds {CHUNK_SIZE_MB} MB - chunking not yet implemented for regular uploads")
+                print(f"   Consider:")
+                print(f"   1. Splitting your data into smaller files (< {CHUNK_SIZE_MB} MB each)")
+                print(f"   2. Using the chunked upload endpoint (if available)")
+                print(f"   3. Retrying the upload (server may have been temporarily busy)")
+                raise
+            else:
+                raise
         
         response_data = response.json()
         session_id = response_data.get('session_id')
@@ -5296,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.1462.dist-info → featrixsphere-0.2.1830.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: featrixsphere
-Version: 0.2.1462
+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.dist-info/RECORD

@@ -0,0 +1,8 @@
+featrixsphere/__init__.py,sha256=I27lMJL_tBPzKyo_79loiIS83AAC-vuoz1kA3ZY2fhc,1888
+featrixsphere/client.py,sha256=L97tRb-6pCvP7lKYOsK4iYHfsFt3V0URu4RO1mQzFoQ,401468
+featrixsphere/test_client.py,sha256=4SiRbib0ms3poK0UpnUv4G0HFQSzidF3Iswo_J2cjLk,11981
+featrixsphere-0.2.1830.dist-info/METADATA,sha256=IFITUpYkfYT2s7WXDX0-5Xl-iiUBt6bb69-Mr9_w6O8,16232
+featrixsphere-0.2.1830.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+featrixsphere-0.2.1830.dist-info/entry_points.txt,sha256=QreJeYfD_VWvbEqPmMXZ3pqqlFlJ1qZb-NtqnyhEldc,51
+featrixsphere-0.2.1830.dist-info/top_level.txt,sha256=AyN4wjfzlD0hWnDieuEHX0KckphIk_aC73XCG4df5uU,14
+featrixsphere-0.2.1830.dist-info/RECORD,,

featrixsphere/cli.py

@@ -1,338 +0,0 @@
-#!/usr/bin/env python3
-"""
-Featrix Sphere CLI
-
-Command-line interface for the Featrix Sphere API client.
-"""
-
-import argparse
-import sys
-from pathlib import Path
-from .client import FeatrixSphereClient
-
-
-def main():
-    """Main CLI entry point."""
-    parser = argparse.ArgumentParser(
-        description="Featrix Sphere API Client - Transform CSV to ML models",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Upload data and create session
-  featrix upload data.csv --server YOUR_SERVER_URL
-  
-  # Test predictions on CSV
-  featrix test SESSION_ID test.csv target_column --server YOUR_SERVER_URL
-  
-  # Make single prediction from JSON
-  featrix predict SESSION_ID '{"feature": "value"}' --server YOUR_SERVER_URL
-  
-  # Make predictions from CSV file
-  featrix predict SESSION_ID test.csv --server YOUR_SERVER_URL --sample-size 50
-        """
-    )
-    
-    parser.add_argument("--server", default="https://sphere-api.featrix.com",
-                       help="Featrix Sphere server URL")
-    parser.add_argument("--compute-cluster", type=str, default=None,
-                       help="Compute cluster port for X-Sphere-Compute header")
-    parser.add_argument("--version", action="version", 
-                       version=f"featrixsphere {__import__('featrixsphere').__version__}")
-    
-    subparsers = parser.add_subparsers(dest="command", help="Available commands")
-    
-    # Upload command
-    upload_parser = subparsers.add_parser("upload", help="Upload CSV and create session")
-    upload_parser.add_argument("csv_file", help="CSV file to upload")
-    upload_parser.add_argument("--wait", action="store_true", 
-                              help="Wait for training to complete")
-    
-    # Test command
-    test_parser = subparsers.add_parser("test", help="Test predictions on CSV")
-    test_parser.add_argument("session_id", help="Session ID")
-    test_parser.add_argument("csv_file", help="CSV file to test")
-    test_parser.add_argument("target_column", help="Target column name")
-    test_parser.add_argument("--sample-size", type=int, default=100,
-                            help="Number of records to test (default: 100)")
-    
-    # Predict command
-    predict_parser = subparsers.add_parser("predict", help="Make single prediction")
-    predict_parser.add_argument("session_id", help="Session ID")
-    predict_parser.add_argument("input", help="JSON record or CSV file to predict")
-    predict_parser.add_argument("--sample-size", type=int, default=1000,
-                               help="Number of records to predict from CSV (default: 1000)")
-    predict_parser.add_argument("-v", "--verbose", action="store_true",
-                               help="Print full results structure")
-    
-    # Status command
-    status_parser = subparsers.add_parser("status", help="Check session status")
-    status_parser.add_argument("session_id", help="Session ID")
-    
-    args = parser.parse_args()
-    
-    if not args.command:
-        parser.print_help()
-        return 1
-    
-    try:
-        client = FeatrixSphereClient(args.server, compute_cluster=args.compute_cluster)
-        
-        if args.command == "upload":
-            return cmd_upload(client, args)
-        elif args.command == "test":
-            return cmd_test(client, args)
-        elif args.command == "predict":
-            return cmd_predict(client, args)
-        elif args.command == "status":
-            return cmd_status(client, args)
-        else:
-            print(f"Unknown command: {args.command}")
-            return 1
-            
-    except Exception as e:
-        print(f"Error: {e}")
-        return 1
-
-
-def cmd_upload(client, args):
-    """Handle upload command."""
-    csv_file = Path(args.csv_file)
-    if not csv_file.exists():
-        print(f"File not found: {csv_file}")
-        return 1
-    
-    print(f"Uploading {csv_file} to {client.base_url}...")
-    session = client.upload_file_and_create_session(csv_file)
-    
-    print(f"✅ Session created: {session.session_id}")
-    print(f"Status: {session.status}")
-    
-    if args.wait:
-        print("Waiting for training to complete...")
-        final_session = client.wait_for_session_completion(session.session_id)
-        print(f"✅ Training completed with status: {final_session.status}")
-    
-    return 0
-
-
-def cmd_test(client, args):
-    """Handle test command."""
-    csv_file = Path(args.csv_file)
-    if not csv_file.exists():
-        print(f"File not found: {csv_file}")
-        return 1
-    
-    print(f"Testing predictions for session {args.session_id}...")
-    
-    results = client.test_csv_predictions(
-        session_id=args.session_id,
-        csv_file=str(csv_file),
-        target_column=args.target_column,
-        sample_size=args.sample_size
-    )
-    
-    if results.get('accuracy_metrics'):
-        metrics = results['accuracy_metrics']
-        print(f"\n🎯 Results:")
-        print(f"Accuracy: {metrics['accuracy']*100:.2f}%")
-        print(f"Confidence: {metrics['average_confidence']*100:.2f}%")
-        print(f"Correct: {metrics['correct_predictions']}/{metrics['total_predictions']}")
-    else:
-        print(f"✅ Predictions completed: {results['successful_predictions']} successful")
-    
-    return 0
-
-
-def cmd_predict(client, args):
-    """Handle predict command."""
-    import json
-    import pandas as pd
-    from pathlib import Path
-    
-    input_path = Path(args.input)
-    
-    # Check if input is a CSV file
-    if input_path.exists() and input_path.suffix.lower() == '.csv':
-        print(f"📊 Loading CSV file: {input_path}")
-        try:
-            df = pd.read_csv(input_path)
-            print(f"   Loaded {len(df)} records")
-            
-            # Sample records if requested (default is 1000, so only sample if explicitly set lower)
-            if args.sample_size < len(df):
-                df = df.sample(n=args.sample_size, random_state=42)
-                print(f"   Sampling {len(df)} records for prediction")
-            
-            # Remove target column to avoid warnings
-            target_column = 'Cancellation Non Renewal'
-            if target_column in df.columns:
-                df = df.drop(columns=[target_column])
-                print(f"   Removed target column '{target_column}' from prediction data")
-            
-            print(f"\n🎯 Making predictions for {len(df)} records...")
-            
-            # Make individual predictions (simpler and more reliable)
-            results = []
-            for i, (_, row) in enumerate(df.iterrows()):
-                record = row.to_dict()
-                print(f"   Predicting record {i+1}/{len(df)}...", end=" ")
-                
-                try:
-                    result = client.predict(args.session_id, record)
-                    
-                    # Extract prediction from response
-                    if 'results' in result:
-                        prediction = result['results']
-                        # Get top prediction
-                        predicted_class = max(prediction, key=prediction.get)
-                        confidence = prediction[predicted_class]
-                    elif 'metadata' in result:
-                        # Use metadata if available (server already computed highest probability)
-                        predicted_class = result['metadata'].get('predicted_class', 'Unknown')
-                        confidence = result['metadata'].get('confidence', 0.0)
-                        prediction = {predicted_class: confidence}
-                    else:
-                        raise ValueError("No prediction results found in response")
-                    
-                    results.append({
-                        'record': i+1,
-                        'prediction': predicted_class,
-                        'confidence': confidence*100
-                    })
-                    
-                    if args.verbose:
-                        print(f"→ {predicted_class} ({confidence*100:.6f}%)")
-                        print(f"   Full results: {prediction}")
-                    else:
-                        print(f"→ {predicted_class} ({confidence*100:.6f}%)")
-                    
-                except Exception as e:
-                    print(f"❌ Error: {e}")
-                    results.append({
-                        'record': i+1,
-                        'prediction': 'ERROR',
-                        'confidence': 0
-                    })
-            
-            # Summary
-            print(f"\n📈 Prediction Summary:")
-            successful = [r for r in results if r['prediction'] != 'ERROR']
-            if successful:
-                avg_confidence = sum(r['confidence'] for r in successful) / len(successful)
-                print(f"   ✅ {len(successful)}/{len(results)} successful predictions")
-                print(f"   📊 Average confidence: {avg_confidence:.6f}%")
-                
-                # Show prediction distribution
-                from collections import Counter
-                pred_counts = Counter(r['prediction'] for r in successful)
-                print(f"   📋 Prediction distribution:")
-                for pred, count in pred_counts.most_common():
-                    pct = (count / len(successful)) * 100
-                    print(f"      {pred}: {count} ({pct:.1f}%)")
-                
-                if args.verbose:
-                    print(f"\n🔍 Full Results Structure:")
-                    for result in successful:
-                        print(f"   Record {result['record']}: {result}")
-            
-            return 0
-            
-        except Exception as e:
-            print(f"❌ Error loading CSV: {e}")
-            return 1
-    
-    # Handle JSON record
-    try:
-        record = json.loads(args.input)
-    except json.JSONDecodeError as e:
-        print(f"❌ Invalid JSON record: {e}")
-        print("💡 Tip: Use quotes around JSON: '{\"feature\": \"value\"}'")
-        return 1
-    
-    print(f"🎯 Making prediction for session {args.session_id}...")
-    
-    try:
-        result = client.predict(args.session_id, record)
-        
-        # Extract prediction from response
-        if 'results' in result:
-            prediction = result['results']
-            
-            print(f"\n🎯 Prediction:")
-            for class_name, confidence in prediction.items():
-                print(f"  {class_name}: {confidence*100:.2f}%")
-            
-            # Show top prediction
-            predicted_class = max(prediction, key=prediction.get)
-            confidence = prediction[predicted_class]
-            print(f"\n→ Predicted: {predicted_class} ({confidence*100:.1f}% confidence)")
-            
-        elif 'metadata' in result:
-            # Use metadata if available (server already computed highest probability)
-            predicted_class = result['metadata'].get('predicted_class', 'Unknown')
-            confidence = result['metadata'].get('confidence', 0.0)
-            
-            print(f"\n🎯 Prediction:")
-            print(f"  {predicted_class}: {confidence*100:.2f}%")
-            print(f"\n→ Predicted: {predicted_class} ({confidence*100:.1f}% confidence)")
-            
-        else:
-            raise ValueError("No prediction results found in response")
-        
-        return 0
-        
-    except Exception as e:
-        print(f"❌ Prediction failed: {e}")
-        return 1
-
-
-def cmd_status(client, args):
-    """Handle status command."""
-    print(f"Checking status for session {args.session_id}...")
-    
-    session_info = client.get_session_status(args.session_id)
-    
-    print(f"\n📊 Session Status:")
-    print(f"ID: {session_info.session_id}")
-    print(f"Type: {session_info.session_type}")
-    print(f"Status: {session_info.status}")
-    
-    if session_info.jobs:
-        print(f"\n🔧 Jobs:")
-        for job_id, job in session_info.jobs.items():
-            status = job.get('status', 'unknown')
-            progress = job.get('progress')
-            job_type = job.get('type', job_id.split('_')[0])
-            
-            # Build status line with progress and loss info
-            status_line = f"  {job_type}: {status}"
-            
-            if progress is not None:
-                # Fix percentage issue: show 100% when job is done
-                progress_pct = 100.0 if status == 'done' else (progress * 100)
-                status_line += f" ({progress_pct:.1f}%)"
-            
-            # Add training metrics for ES and Single Predictor jobs
-            if job_type in ['train_es', 'train_single_predictor'] and status == 'running':
-                metrics = []
-                current_epoch = job.get('current_epoch')
-                current_loss = job.get('current_loss')
-                validation_loss = job.get('validation_loss')
-                
-                if current_epoch is not None:
-                    metrics.append(f"Epoch {current_epoch}")
-                if current_loss is not None:
-                    metrics.append(f"Loss: {current_loss:.4f}")
-                if validation_loss is not None:
-                    metrics.append(f"Val Loss: {validation_loss:.4f}")
-                
-                if metrics:
-                    status_line += f" - {', '.join(metrics)}"
-            
-            print(status_line)
-    
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main()) 

featrixsphere-0.2.1462.dist-info/RECORD

@@ -1,9 +0,0 @@
-featrixsphere/__init__.py,sha256=oJsLRgA3q8pSL3rPso0kfVmgPoKdivl2gt4Gj3OZW_M,1888
-featrixsphere/cli.py,sha256=AW9O3vCvCNJ2UxVGN66eRmeN7XLSiHJlvK6JLZ9UJXc,13358
-featrixsphere/client.py,sha256=HWbVkvvZ3MZae_hfa0ChurzrSHMnxTWDW59tOcLERag,386715
-featrixsphere/test_client.py,sha256=4SiRbib0ms3poK0UpnUv4G0HFQSzidF3Iswo_J2cjLk,11981
-featrixsphere-0.2.1462.dist-info/METADATA,sha256=odh92kvhANd28hRmWToVCsW8hv-jb2YLpBdFegOHNkM,16232
-featrixsphere-0.2.1462.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-featrixsphere-0.2.1462.dist-info/entry_points.txt,sha256=QreJeYfD_VWvbEqPmMXZ3pqqlFlJ1qZb-NtqnyhEldc,51
-featrixsphere-0.2.1462.dist-info/top_level.txt,sha256=AyN4wjfzlD0hWnDieuEHX0KckphIk_aC73XCG4df5uU,14
-featrixsphere-0.2.1462.dist-info/RECORD,,