featrixsphere 0.2.1238__py3-none-any.whl → 0.2.1438__py3-none-any.whl

featrixsphere/__init__.py

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

featrixsphere/client.py

@@ -715,53 +715,101 @@ class FeatrixSphereClient:
         except Exception as e:
             return False, f"Error checking foundation model: {e}"
     
-    def get_model_card(self, session_id: str, max_retries: int = None, check_status_first: bool = True) -> Dict[str, Any]:
+    def get_model_card(self, session_id: str, max_retries: int = None) -> Dict[str, Any]:
         """
         Get the model card JSON for a given session.
         
+        Handles on-demand model card generation:
+        - If model card is being generated (202), waits and retries
+        - If model card doesn't exist (404) but session is DONE, retries (on-demand creation may be in progress)
+        
         Args:
             session_id: The session ID to get the model card for
             max_retries: Maximum number of retries (defaults to client default)
-            check_status_first: If True, check session status before fetching model card.
-                               Provides better error messages if session is still training.
             
         Returns:
             Dictionary containing the model card JSON data
             
         Raises:
-            requests.exceptions.HTTPError: If the request fails
-            FileNotFoundError: If the model card doesn't exist (404)
-            ValueError: If session is not ready and check_status_first is True
+            requests.exceptions.HTTPError: If the request fails after all retries
+            FileNotFoundError: If the model card doesn't exist (404) and can't be created
             
         Example:
             >>> client = FeatrixSphereClient()
             >>> model_card = client.get_model_card("session_123")
             >>> print(model_card["model_details"]["name"])
         """
-        # Check session status first to provide better error messages
-        if check_status_first:
+        if max_retries is None:
+            max_retries = self.default_max_retries
+        
+        # Use a longer retry window for model card requests (on-demand generation can take time)
+        max_retry_time = 60.0  # 60 seconds for model card generation
+        start_time = time.time()
+        attempt = 0
+        
+        while True:
+            attempt += 1
+            elapsed = time.time() - start_time
+            
             try:
-                session_status = self.get_session_status(session_id, max_retries=max_retries)
-                if session_status.status not in ["done", "DONE"]:
-                    raise ValueError(
-                        f"Session {session_id} is not ready (status: {session_status.status}). "
-                        f"Model card is only available after training completes. "
-                        f"Use wait_for_session_completion() to wait for training to finish."
-                    )
+                response = self._make_request(
+                    "GET",
+                    f"/session/{session_id}/model_card",
+                    max_retries=1,  # Don't use default retries, handle manually
+                    max_retry_time=None
+                )
+                
+                # Check for 202 Accepted (generation in progress)
+                if response.status_code == 202:
+                    response_data = response.json()
+                    message = response_data.get("message", "Model card generation in progress")
+                    
+                    # If we have time left, wait and retry
+                    if elapsed < max_retry_time and attempt <= max_retries:
+                        wait_time = min(5.0, max_retry_time - elapsed)  # Wait up to 5 seconds
+                        if wait_time > 0:
+                            print(f"⏳ Model card generation in progress (attempt {attempt}/{max_retries}), waiting {wait_time:.1f}s...")
+                            time.sleep(wait_time)
+                            continue
+                    else:
+                        # Out of time or retries
+                        raise requests.exceptions.HTTPError(
+                            f"Model card generation timed out after {elapsed:.1f}s. {message}",
+                            response=response
+                        )
+                
+                # Success - return the model card
+                return response.json()
+                
             except requests.exceptions.HTTPError as e:
-                # If we can't get status, continue and let the model_card request fail
-                # This handles cases where the session doesn't exist
-                if e.response.status_code == 404:
-                    raise FileNotFoundError(f"Session {session_id} not found") from e
-                # For other HTTP errors, continue to try model_card request
-                pass
-        
-        response = self._make_request(
-            "GET",
-            f"/session/{session_id}/model_card",
-            max_retries=max_retries
-        )
-        return response.json()
+                if e.response is not None and e.response.status_code == 404:
+                    # 404 - model card doesn't exist
+                    # Check if we should retry (on-demand generation might be starting)
+                    if elapsed < max_retry_time and attempt <= max_retries:
+                        # Check session status to see if it's DONE (model card should exist or be creatable)
+                        try:
+                            session_status = self.get_session_status(session_id, max_retries=1)
+                            if session_status.status in ["done", "DONE"]:
+                                # Session is done, model card should be creatable - retry after a short delay
+                                wait_time = min(3.0, max_retry_time - elapsed)
+                                if wait_time > 0:
+                                    print(f"⏳ Model card not found for DONE session (attempt {attempt}/{max_retries}), retrying in {wait_time:.1f}s (on-demand generation may be starting)...")
+                                    time.sleep(wait_time)
+                                    continue
+                        except Exception:
+                            # If we can't check session status, just retry once more
+                            if attempt <= 2:
+                                wait_time = min(2.0, max_retry_time - elapsed)
+                                if wait_time > 0:
+                                    print(f"⏳ Model card not found (attempt {attempt}/{max_retries}), retrying in {wait_time:.1f}s...")
+                                    time.sleep(wait_time)
+                                    continue
+                    
+                    # Out of retries or session not DONE - raise the 404
+                    raise FileNotFoundError(f"Model card not found for session {session_id}") from e
+                else:
+                    # Other HTTP errors - re-raise
+                    raise
     
     def publish_session(self, session_id: str) -> Dict[str, Any]:
         """
@@ -915,7 +963,7 @@ class FeatrixSphereClient:
     
     def wait_for_session_completion(self, session_id: str, max_wait_time: int = 3600, 
                                    check_interval: int = 10, show_live_training_movie: bool = None,
-                                   training_interval_movie: int = 3) -> SessionInfo:
+                                   training_interval_movie: int = 3, status_callback: callable = None) -> SessionInfo:
         """
         Wait for a session to complete, with smart progress display.
         
@@ -926,10 +974,16 @@ class FeatrixSphereClient:
             show_live_training_movie: If True, show live training visualization as epochs progress.
                                     If None, auto-enable in notebook environments (default: None)
             training_interval_movie: Show training movie updates every N epochs (default: 3)
+            status_callback: Optional callback function(session_info, elapsed_seconds) called on each status check.
+                           If provided, uses this instead of default display methods.
             
         Returns:
             Final SessionInfo when session completes or times out
         """
+        # If callback provided, use it instead of display methods
+        if status_callback is not None:
+            return self._wait_with_callback(session_id, max_wait_time, check_interval, status_callback)
+        
         # Auto-enable live training movie in notebooks if not explicitly set
         if show_live_training_movie is None:
             show_live_training_movie = self._is_notebook()
@@ -977,6 +1031,14 @@ class FeatrixSphereClient:
     def _wait_with_smart_display(self, session_id: str, max_wait_time: int, check_interval: int, show_live_training_movie: bool = False, training_interval_movie: int = 3) -> SessionInfo:
         """Smart progress display that adapts to environment."""
         
+        # Check if we're in a thread (not main thread) - Rich doesn't support multiple live displays
+        import threading
+        is_main_thread = threading.current_thread() is threading.main_thread()
+        
+        # If not in main thread, use simple display to avoid Rich LiveError
+        if not is_main_thread:
+            return self._wait_with_simple_display(session_id, max_wait_time, check_interval)
+        
         if self._is_notebook():
             return self._wait_with_notebook_display(session_id, max_wait_time, check_interval, show_live_training_movie, training_interval_movie)
         elif self._has_rich():
@@ -1156,6 +1218,28 @@ class FeatrixSphereClient:
             # Fallback if rich not available
             return self._wait_with_simple_display(session_id, max_wait_time, check_interval)
     
+    def _wait_with_callback(self, session_id: str, max_wait_time: int, check_interval: int, status_callback: callable) -> SessionInfo:
+        """Wait for session completion using a custom callback for status updates."""
+        import time
+        
+        start_time = time.time()
+        
+        while time.time() - start_time < max_wait_time:
+            session_info = self.get_session_status(session_id)
+            elapsed = time.time() - start_time
+            
+            # Call the callback with current status
+            status_callback(session_info, elapsed)
+            
+            # Check if completed
+            if session_info.status in ['completed', 'done', 'DONE']:
+                return session_info
+            
+            time.sleep(check_interval)
+        
+        # Timeout - return final status
+        return self.get_session_status(session_id)
+    
     def _wait_with_simple_display(self, session_id: str, max_wait_time: int, check_interval: int) -> SessionInfo:
         """Simple display with line overwriting for basic terminals."""
         import sys
@@ -4117,7 +4201,6 @@ class FeatrixSphereClient:
                                     epochs: int = 0, 
                                     rare_label_value: str = None,
                                     class_imbalance: dict = None,
-                                    optimize_for: str = "balanced",
                                     poll_interval: int = 30, max_poll_time: int = 3600,
                                     verbose: bool = True,
                                     webhooks: Dict[str, str] = None) -> SessionInfo:
@@ -4140,7 +4223,6 @@ class FeatrixSphereClient:
             epochs: Number of training epochs (default: 0; automatic)
             rare_label_value: For binary classification, which class is the rare/minority class for metrics (default: None)
             class_imbalance: Expected class ratios/counts from real world for sampled data (default: None)
-            optimize_for: Optimization target - "balanced" (F1 score), "precision", or "recall" (default: "balanced")
             poll_interval: Seconds between status checks when job is already running (default: 30)
             max_poll_time: Maximum time to poll in seconds (default: 3600 = 1 hour)
             verbose: Whether to print status updates during polling (default: True)
@@ -4178,7 +4260,6 @@ class FeatrixSphereClient:
                 "target_column": target_column,
                 "target_column_type": target_column_type,
                 "epochs": str(epochs),
-                "optimize_for": optimize_for,
             }
             
             # Handle file upload - send file directly in multipart form
@@ -4297,7 +4378,6 @@ class FeatrixSphereClient:
                               validation_ignore_columns: List[str] = None,
                               rare_label_value: str = None,
                               class_imbalance: dict = None,
-                              optimize_for: str = "balanced",
                               cost_false_positive: float = None,
                               cost_false_negative: float = None,
                               poll_interval: int = 30, max_poll_time: int = 3600,
@@ -4477,24 +4557,6 @@ class FeatrixSphereClient:
         This happens automatically - no configuration needed. The system invests a few seconds
         in analysis to deliver significantly better models.
         
-        Understanding optimize_for:
-        ---------------------------
-        The optimize_for parameter controls which loss function and training strategy is used,
-        optimizing for different aspects of model performance:
-        
-        - "balanced" (default): Optimizes for F1 score (harmonic mean of precision and recall).
-          Uses FocalLoss with class weights. Best for general-purpose classification where you
-          want balanced performance across all classes.
-          
-        - "precision": Optimizes for precision (minimizing false positives). Uses FocalLoss with
-          class weights, which focuses training on hard-to-classify examples. Best when false
-          positives are costly (e.g., fraud detection where flagging legitimate transactions
-          as fraud is expensive).
-          
-        - "recall": Optimizes for recall (minimizing false negatives). Uses CrossEntropyLoss
-          with class weights that strongly boost the minority class. Best when false negatives
-          are costly (e.g., medical diagnosis where missing a disease is dangerous).
-        
         Understanding class_imbalance:
         ------------------------------
         For imbalanced datasets where your training data doesn't reflect real-world class
@@ -4615,7 +4677,6 @@ class FeatrixSphereClient:
             target_column='approved',
             target_column_type='set',
             class_imbalance={'approved': 0.97, 'rejected': 0.03},
-            optimize_for='recall',  # Don't miss rejections
             rare_label_value='rejected'
         )
         
@@ -4636,7 +4697,6 @@ class FeatrixSphereClient:
             target_column='is_fraud',
             target_column_type='set',
             rare_label_value='fraud',
-            optimize_for='precision',  # Minimize false alarms
             class_imbalance={'legitimate': 0.999, 'fraud': 0.001}
         )
         ```
@@ -4650,8 +4710,7 @@ class FeatrixSphereClient:
             session_id=session.session_id,
             target_column='has_disease',
             target_column_type='set',
-            rare_label_value='positive',
-            optimize_for='recall'  # Don't miss any cases
+            rare_label_value='positive'
         )
         ```
         
@@ -4693,14 +4752,6 @@ class FeatrixSphereClient:
             validation_ignore_columns: List of column names to exclude from validation queries (default: None)
             rare_label_value: For binary classification, which class is the rare/minority class for metrics (default: None)
             class_imbalance: Expected class ratios/counts from real world for sampled data (default: None)
-            optimize_for: Optimization target - "balanced" (F1 score), "precision", or "recall" (default: "balanced").
-                Ignored if cost_false_positive and cost_false_negative are provided.
-            cost_false_positive: Cost of a false positive (predicting positive when actually negative). 
-                Must be specified together with cost_false_negative. Only valid for target_column_type="set".
-                When provided, overrides optimize_for and uses cost-based optimization.
-            cost_false_negative: Cost of a false negative (predicting negative when actually positive).
-                Must be specified together with cost_false_positive. Only valid for target_column_type="set".
-                When provided, overrides optimize_for and uses cost-based optimization.
             poll_interval: Seconds between status checks when job is already running (default: 30)
             max_poll_time: Maximum time to poll in seconds (default: 3600 = 1 hour)
             verbose: Whether to print status updates during polling (default: True)
@@ -4727,7 +4778,6 @@ class FeatrixSphereClient:
                 raise ValueError("cost_false_positive and cost_false_negative must be positive numbers")
             if verbose:
                 print(f"💰 Cost-based optimization enabled: FP cost={cost_false_positive}, FN cost={cost_false_negative}")
-                print(f"   (optimize_for='{optimize_for}' will be ignored)")
         
         # If DataFrame provided, save to temp file and use file_path logic
         temp_file = None
@@ -4761,7 +4811,6 @@ class FeatrixSphereClient:
                     epochs=epochs,
                     rare_label_value=rare_label_value,
                     class_imbalance=class_imbalance,
-                    optimize_for=optimize_for,
                     cost_false_positive=cost_false_positive,
                     cost_false_negative=cost_false_negative,
                     verbose=verbose,
@@ -4775,8 +4824,7 @@ class FeatrixSphereClient:
                 "epochs": epochs,
                 "validation_ignore_columns": validation_ignore_columns or [],
                 "rare_label_value": rare_label_value,
-                "class_imbalance": class_imbalance,
-                "optimize_for": optimize_for
+                "class_imbalance": class_imbalance
             }
             if cost_false_positive is not None and cost_false_negative is not None:
                 data["cost_false_positive"] = cost_false_positive
@@ -5353,7 +5401,6 @@ class FeatrixSphereClient:
         epochs: int,
         rare_label_value: str,
         class_imbalance: dict,
-        optimize_for: str,
         cost_false_positive: float = None,
         cost_false_negative: float = None,
         verbose: bool = True,
@@ -5381,8 +5428,7 @@ class FeatrixSphereClient:
         data = {
             'target_column': target_column,
             'target_column_type': target_column_type,
-            'epochs': str(epochs),
-            'optimize_for': optimize_for,
+            'epochs': str(epochs)
         }
         
         if rare_label_value:

{featrixsphere-0.2.1238.dist-info → featrixsphere-0.2.1438.dist-info}/METADATA

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

@@ -0,0 +1,9 @@
+featrixsphere/__init__.py,sha256=0gIgPqNrcFK35jlMQqSLQg9TqBwaiNU_PhZ4dQ3JOsw,1888
+featrixsphere/cli.py,sha256=AW9O3vCvCNJ2UxVGN66eRmeN7XLSiHJlvK6JLZ9UJXc,13358
+featrixsphere/client.py,sha256=NM-dBRANvN0GpcLf0BPqUxpqwMhzHP6hJktD8FndyCM,384646
+featrixsphere/test_client.py,sha256=4SiRbib0ms3poK0UpnUv4G0HFQSzidF3Iswo_J2cjLk,11981
+featrixsphere-0.2.1438.dist-info/METADATA,sha256=tNsudbOj5N1zFcjNA2iHZf6WJa4jxz1_MfhctYs8-qI,16232
+featrixsphere-0.2.1438.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+featrixsphere-0.2.1438.dist-info/entry_points.txt,sha256=QreJeYfD_VWvbEqPmMXZ3pqqlFlJ1qZb-NtqnyhEldc,51
+featrixsphere-0.2.1438.dist-info/top_level.txt,sha256=AyN4wjfzlD0hWnDieuEHX0KckphIk_aC73XCG4df5uU,14
+featrixsphere-0.2.1438.dist-info/RECORD,,

featrixsphere-0.2.1238.dist-info/RECORD

@@ -1,9 +0,0 @@
-featrixsphere/__init__.py,sha256=-zD2ZilYZFjYDB5rwnqr0jYNDB9zkO-hRgiD0LiXUGM,1888
-featrixsphere/cli.py,sha256=AW9O3vCvCNJ2UxVGN66eRmeN7XLSiHJlvK6JLZ9UJXc,13358
-featrixsphere/client.py,sha256=9GmwNP8Z4-HCQWEBDIXp54rbymRtJqwmBeQZZu5g27E,382816
-featrixsphere/test_client.py,sha256=4SiRbib0ms3poK0UpnUv4G0HFQSzidF3Iswo_J2cjLk,11981
-featrixsphere-0.2.1238.dist-info/METADATA,sha256=ILxoFLdu7zaEt1RzGAoCX_QGKMRCzv9hcB1zGr6_9FM,16232
-featrixsphere-0.2.1238.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-featrixsphere-0.2.1238.dist-info/entry_points.txt,sha256=QreJeYfD_VWvbEqPmMXZ3pqqlFlJ1qZb-NtqnyhEldc,51
-featrixsphere-0.2.1238.dist-info/top_level.txt,sha256=AyN4wjfzlD0hWnDieuEHX0KckphIk_aC73XCG4df5uU,14
-featrixsphere-0.2.1238.dist-info/RECORD,,