featrixsphere 0.2.1314__py3-none-any.whl → 0.2.1439__py3-none-any.whl

featrixsphere/__init__.py

@@ -38,7 +38,7 @@ Example:
     ...                                labels=['Experiment A', 'Experiment B'])
 """
 
-__version__ = "0.2.1314"
+__version__ = "0.2.1439"
 __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

{featrixsphere-0.2.1314.dist-info → featrixsphere-0.2.1439.dist-info}/METADATA

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

@@ -0,0 +1,9 @@
+featrixsphere/__init__.py,sha256=7qEuBqtpDfJZYvEJQAVVrtdL-nZvI74oPx7tcVJN9Jo,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.1439.dist-info/METADATA,sha256=_KJ6nguFKv3xMG1kbWWS5_7hN2DjQEa-z3sloLIh5z4,16232
+featrixsphere-0.2.1439.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+featrixsphere-0.2.1439.dist-info/entry_points.txt,sha256=QreJeYfD_VWvbEqPmMXZ3pqqlFlJ1qZb-NtqnyhEldc,51
+featrixsphere-0.2.1439.dist-info/top_level.txt,sha256=AyN4wjfzlD0hWnDieuEHX0KckphIk_aC73XCG4df5uU,14
+featrixsphere-0.2.1439.dist-info/RECORD,,

featrixsphere-0.2.1314.dist-info/RECORD

@@ -1,9 +0,0 @@
-featrixsphere/__init__.py,sha256=S0XWndX6ycMk8j03X_Dt_GpMuCMG2k0uwzoVJ6EbbnA,1888
-featrixsphere/cli.py,sha256=AW9O3vCvCNJ2UxVGN66eRmeN7XLSiHJlvK6JLZ9UJXc,13358
-featrixsphere/client.py,sha256=c1axFTTB6Hvdu2cWngN0VnkBdU0W0neTDKwzIU-IFXc,380183
-featrixsphere/test_client.py,sha256=4SiRbib0ms3poK0UpnUv4G0HFQSzidF3Iswo_J2cjLk,11981
-featrixsphere-0.2.1314.dist-info/METADATA,sha256=gu4_0nXC3gk8GfKB-lDbgrZPhdvTQCRcUEIlIMtWy-I,16232
-featrixsphere-0.2.1314.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-featrixsphere-0.2.1314.dist-info/entry_points.txt,sha256=QreJeYfD_VWvbEqPmMXZ3pqqlFlJ1qZb-NtqnyhEldc,51
-featrixsphere-0.2.1314.dist-info/top_level.txt,sha256=AyN4wjfzlD0hWnDieuEHX0KckphIk_aC73XCG4df5uU,14
-featrixsphere-0.2.1314.dist-info/RECORD,,