featrixsphere 0.2.4991__py3-none-any.whl → 0.2.5183__py3-none-any.whl

featrixsphere/__init__.py

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

featrixsphere/client.py

@@ -877,24 +877,30 @@ class FeatrixSphereClient:
                     # Other HTTP errors - re-raise
                     raise
     
-    def publish_session(self, session_id: str) -> Dict[str, Any]:
+    def publish_session(self, session_id: str, org_id: str, name: str) -> Dict[str, Any]:
         """
-        Publish a session by moving it to /sphere/published/<sessionId>.
+        Publish a session by moving it to /backplane/backplane1/sphere/PUBLISHED/<org_id>/<name>/<sessionId>.
         Moves both the session file and output directory.
         
         Args:
             session_id: Session ID to publish
+            org_id: Organization ID for subdirectory organization
+            name: Name for the published session (creates subdirectory under org_id)
             
         Returns:
             Response with published_path, output_path, and status
             
         Example:
             ```python
-            result = client.publish_session("abc123")
+            result = client.publish_session("abc123", org_id="org_123", name="production_model")
             print(f"Published to: {result['published_path']}")
             ```
         """
-        response_data = self._post_json(f"/compute/session/{session_id}/publish", {})
+        data = {
+            "org_id": org_id,
+            "name": name
+        }
+        response_data = self._post_json(f"/compute/session/{session_id}/publish", data)
         return response_data
 
     def deprecate_session(self, session_id: str, warning_message: str, expiration_date: str) -> Dict[str, Any]:
@@ -1241,7 +1247,18 @@ class FeatrixSphereClient:
             } if show_live_training_movie else None
             
             while time.time() - start_time < max_wait_time:
-                session_info = self.get_session_status(session_id)
+                try:
+                    session_info = self.get_session_status(session_id)
+                except KeyboardInterrupt:
+                    print("\n\n⚠️  Interrupted by user (Ctrl+C)")
+                    print(f"   Session {session_id} status check interrupted")
+                    print("   Returning current session status...")
+                    # Return last known status or get it one more time if possible
+                    try:
+                        return self.get_session_status(session_id)
+                    except:
+                        # If we can't get status, return a basic SessionInfo
+                        return SessionInfo(session_id=session_id, status="unknown", jobs={})
                 
                 # Clear previous output and show updated status
                 clear_output(wait=True)
@@ -1357,7 +1374,19 @@ class FeatrixSphereClient:
                 session_task = progress.add_task(f"[bold green]Session {session_id}", total=100)
                 
                 while time.time() - start_time < max_wait_time:
-                    session_info = self.get_session_status(session_id)
+                    try:
+                        session_info = self.get_session_status(session_id)
+                    except KeyboardInterrupt:
+                        progress.console.print("\n\n[bold yellow]⚠️  Interrupted by user (Ctrl+C)[/bold yellow]")
+                        progress.console.print(f"   Session {session_id} status check interrupted")
+                        progress.console.print("   Returning current session status...")
+                        # Return last known status or get it one more time if possible
+                        try:
+                            return self.get_session_status(session_id)
+                        except:
+                            # If we can't get status, return a basic SessionInfo
+                            from featrixsphere.client import SessionInfo
+                            return SessionInfo(session_id=session_id, status="unknown", jobs={})
                     
                     # Update session progress
                     elapsed = time.time() - start_time
@@ -1426,7 +1455,19 @@ class FeatrixSphereClient:
         jobs_appeared = False
         
         while time.time() - initial_wait_start < initial_wait_timeout:
-            session_info = self.get_session_status(session_id)
+            try:
+                session_info = self.get_session_status(session_id)
+            except KeyboardInterrupt:
+                logger.info("\n⚠️  Interrupted by user (Ctrl+C)")
+                logger.info(f"   Session {session_id} status check interrupted")
+                logger.info("   Returning current session status...")
+                # Return last known status or get it one more time if possible
+                try:
+                    return self.get_session_status(session_id)
+                except:
+                    # If we can't get status, return a basic SessionInfo
+                    return SessionInfo(session_id=session_id, status="unknown", jobs={})
+            
             if session_info.jobs:
                 jobs_appeared = True
                 break
@@ -1434,7 +1475,20 @@ class FeatrixSphereClient:
         
         # Main monitoring loop
         while time.time() - start_time < max_wait_time:
-            session_info = self.get_session_status(session_id)
+            try:
+                session_info = self.get_session_status(session_id)
+            except KeyboardInterrupt:
+                logger.info("\n⚠️  Interrupted by user (Ctrl+C)")
+                logger.info(f"   Session {session_id} status check interrupted")
+                logger.info("   Returning current session status...")
+                # Return last known status or get it one more time if possible
+                try:
+                    return self.get_session_status(session_id)
+                except:
+                    # If we can't get status, return a basic SessionInfo
+                    from featrixsphere.client import SessionInfo
+                    return SessionInfo(session_id=session_id, status="unknown", jobs={})
+            
             elapsed = time.time() - start_time
             
             # Call the callback with current status
@@ -1471,7 +1525,19 @@ class FeatrixSphereClient:
         last_num_lines = 0
         
         while time.time() - start_time < max_wait_time:
-            session_info = self.get_session_status(session_id)
+            try:
+                session_info = self.get_session_status(session_id)
+            except KeyboardInterrupt:
+                print("\n\n⚠️  Interrupted by user (Ctrl+C)")
+                print(f"   Session {session_id} status check interrupted")
+                print("   Returning current session status...")
+                # Return last known status or get it one more time if possible
+                try:
+                    return self.get_session_status(session_id)
+                except:
+                    # If we can't get status, return a basic SessionInfo
+                    from featrixsphere.client import SessionInfo
+                    return SessionInfo(session_id=session_id, status="unknown", jobs={})
             
             # Clear previous lines if terminal supports it
             if sys.stdout.isatty() and last_num_lines > 0:
@@ -2866,6 +2932,110 @@ class FeatrixSphereClient:
         response_data = self._post_json(f"/session/{session_id}/predict", request_payload, max_retries=max_retries)
         return response_data
     
+    def explain(self, session_id: str, record, class_idx: int = None,
+                target_column: str = None, predictor_id: str = None,
+                record_b: Dict[str, Any] = None,
+                max_retries: int = None) -> Dict[str, Any]:
+        """
+        Explain a prediction using gradient attribution.
+        
+        Supports multiple modes:
+        - explain(record): Explain a single row
+        - explain(record, record_b=other_record): Compare two rows
+        - explain([record1, record2, ...]): Explain multiple rows
+        
+        Returns what matters to Featrix in the given row(s):
+        - Which features mattered for this prediction
+        - Which relationships mattered for this prediction
+        
+        Args:
+            session_id: ID of session with trained predictor
+            record: Record dictionary (without target column), or list of records
+            class_idx: Target class index for attribution (default: predicted class)
+            target_column: Specific target column predictor to use (optional)
+            predictor_id: Specific predictor ID to use (optional)
+            record_b: Optional second record for comparison
+            max_retries: Number of retries for errors (default: uses client default)
+            
+        Returns:
+            For single record:
+                Dictionary with:
+                    - feature_scores: {col_name: score} - gradient norm per feature
+                    - pair_scores: {(i, j): score} - gradient norm per relationship pair
+                    - target_class_idx: The class index used for attribution
+                    - logit: The prediction logit
+            
+            For two records (record_b provided):
+                Dictionary with:
+                    - record_a: Explanation for first record
+                    - record_b: Explanation for second record
+                    - difference: Difference in feature_scores and pair_scores
+            
+            For list of records:
+                Dictionary with:
+                    - explanations: List of explanation dictionaries, one per record
+        """
+        # Clean NaN/Inf values
+        if isinstance(record, list):
+            cleaned_record = [self.replace_nans_with_nulls(self._clean_numpy_values(r)) for r in record]
+        else:
+            cleaned_record = self.replace_nans_with_nulls(self._clean_numpy_values(record))
+        
+        cleaned_record_b = None
+        if record_b is not None:
+            cleaned_record_b = self.replace_nans_with_nulls(self._clean_numpy_values(record_b))
+        
+        # Build request payload
+        request_payload = {
+            "query_record": cleaned_record,
+        }
+        
+        if class_idx is not None:
+            request_payload["class_idx"] = class_idx
+        if target_column:
+            request_payload["target_column"] = target_column
+        if predictor_id:
+            request_payload["predictor_id"] = predictor_id
+        if cleaned_record_b is not None:
+            request_payload["query_record_b"] = cleaned_record_b
+        
+        response_data = self._post_json(f"/session/{session_id}/explain", request_payload, max_retries=max_retries)
+        
+        # Helper to convert pair_scores keys back to tuples
+        def convert_pair_scores(ps_dict):
+            if not isinstance(ps_dict, dict):
+                return ps_dict
+            result = {}
+            for key, score in ps_dict.items():
+                # Key format is "i_j"
+                parts = key.split("_")
+                if len(parts) == 2:
+                    try:
+                        i, j = int(parts[0]), int(parts[1])
+                        result[(i, j)] = score
+                    except ValueError:
+                        result[key] = score
+                else:
+                    result[key] = score
+            return result
+        
+        # Convert pair_scores keys back to tuples for easier use
+        if "pair_scores" in response_data:
+            response_data["pair_scores"] = convert_pair_scores(response_data["pair_scores"])
+        elif "explanations" in response_data:
+            for expl in response_data["explanations"]:
+                if "pair_scores" in expl:
+                    expl["pair_scores"] = convert_pair_scores(expl["pair_scores"])
+        elif "record_a" in response_data:
+            if "pair_scores" in response_data["record_a"]:
+                response_data["record_a"]["pair_scores"] = convert_pair_scores(response_data["record_a"]["pair_scores"])
+            if "pair_scores" in response_data["record_b"]:
+                response_data["record_b"]["pair_scores"] = convert_pair_scores(response_data["record_b"]["pair_scores"])
+            if "difference" in response_data and "pair_scores" in response_data["difference"]:
+                response_data["difference"]["pair_scores"] = convert_pair_scores(response_data["difference"]["pair_scores"])
+        
+        return response_data
+    
     def get_training_metrics(self, session_id: str, max_retries: int = None) -> Dict[str, Any]:
         """
         Get training metrics for a session's single predictor.
@@ -8117,6 +8287,55 @@ class FeatrixSphereClient:
         """
         return PredictionGrid(session_id, self, degrees_of_freedom, grid_shape, target_column)
 
+    def get_embedding_space_columns(self, session_id: str) -> Dict[str, Any]:
+        """
+        Get column names and types from the embedding space.
+        
+        Tries to get from model_card.json first (if training completed), 
+        otherwise falls back to loading the embedding space directly.
+        
+        Args:
+            session_id: Session ID with trained embedding space
+            
+        Returns:
+            Dictionary with:
+                - column_names: List of column names
+                - column_types: Dict mapping column names to types (scalar, set, free_string, etc.)
+                - num_columns: Total number of columns
+                
+        Example:
+            >>> columns = client.get_embedding_space_columns(session_id)
+            >>> print(f"Columns: {columns['column_names']}")
+            >>> print(f"Types: {columns['column_types']}")
+        """
+        # Try model_card first (if training completed)
+        try:
+            model_card = self.get_model_card(session_id)
+            
+            # Extract column names from training_dataset.feature_names
+            training_dataset = model_card.get('training_dataset', {})
+            column_names = training_dataset.get('feature_names', [])
+            
+            # Extract column types from feature_inventory
+            feature_inventory = model_card.get('feature_inventory', {})
+            column_types = {}
+            for feature_name, feature_info in feature_inventory.items():
+                if isinstance(feature_info, dict):
+                    column_types[feature_name] = feature_info.get('type', 'unknown')
+            
+            if column_names:
+                return {
+                    "column_names": column_names,
+                    "column_types": column_types,
+                    "num_columns": len(column_names)
+                }
+        except Exception:
+            # Model card doesn't exist yet, fall back to direct endpoint
+            pass
+        
+        # Fallback: load embedding space directly
+        return self._get_json(f"/compute/session/{session_id}/columns")
+
 
 class PredictionGrid:
     """
@@ -8862,55 +9081,6 @@ class PredictionGrid:
         else:
             return fig
     
-    def get_embedding_space_columns(self, session_id: str) -> Dict[str, Any]:
-        """
-        Get column names and types from the embedding space.
-        
-        Tries to get from model_card.json first (if training completed), 
-        otherwise falls back to loading the embedding space directly.
-        
-        Args:
-            session_id: Session ID with trained embedding space
-            
-        Returns:
-            Dictionary with:
-                - column_names: List of column names
-                - column_types: Dict mapping column names to types (scalar, set, free_string, etc.)
-                - num_columns: Total number of columns
-                
-        Example:
-            >>> columns = client.get_embedding_space_columns(session_id)
-            >>> print(f"Columns: {columns['column_names']}")
-            >>> print(f"Types: {columns['column_types']}")
-        """
-        # Try model_card first (if training completed)
-        try:
-            model_card = self.get_model_card(session_id)
-            
-            # Extract column names from training_dataset.feature_names
-            training_dataset = model_card.get('training_dataset', {})
-            column_names = training_dataset.get('feature_names', [])
-            
-            # Extract column types from feature_inventory
-            feature_inventory = model_card.get('feature_inventory', {})
-            column_types = {}
-            for feature_name, feature_info in feature_inventory.items():
-                if isinstance(feature_info, dict):
-                    column_types[feature_name] = feature_info.get('type', 'unknown')
-            
-            if column_names:
-                return {
-                    "column_names": column_names,
-                    "column_types": column_types,
-                    "num_columns": len(column_names)
-                }
-        except Exception:
-            # Model card doesn't exist yet, fall back to direct endpoint
-            pass
-        
-        # Fallback: load embedding space directly
-        return self._get_json(f"/compute/session/{session_id}/columns")
-    
     def get_predictor_schema(self, session_id: str, predictor_index: int = 0) -> Dict[str, Any]:
         """
         Get predictor schema/metadata for validating input data locally.

{featrixsphere-0.2.4991.dist-info → featrixsphere-0.2.5183.dist-info}/METADATA

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

@@ -0,0 +1,7 @@
+featrixsphere/__init__.py,sha256=tPVhFLHujHMC0bnsnjggdMIb2chNkYbbm0wUX-lwWYY,1888
+featrixsphere/client.py,sha256=YvOB2y8zh4iCMccXQ-4ZsQ8dgmUSQlkLh2zsxIiIoYM,435090
+featrixsphere-0.2.5183.dist-info/METADATA,sha256=BEVBhDxyQvjFfDWyzSSKTZLwybnQFyPYU6dk_cxB5CM,16232
+featrixsphere-0.2.5183.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+featrixsphere-0.2.5183.dist-info/entry_points.txt,sha256=QreJeYfD_VWvbEqPmMXZ3pqqlFlJ1qZb-NtqnyhEldc,51
+featrixsphere-0.2.5183.dist-info/top_level.txt,sha256=AyN4wjfzlD0hWnDieuEHX0KckphIk_aC73XCG4df5uU,14
+featrixsphere-0.2.5183.dist-info/RECORD,,

featrixsphere/test_client.py

@@ -1,311 +0,0 @@
-#!/usr/bin/env python3
-"""
-Tests for FeatrixSphereClient
-
-These tests verify basic functionality without requiring a live API server.
-"""
-
-import unittest
-from unittest.mock import Mock, patch, MagicMock
-import json
-from pathlib import Path
-import sys
-
-# Mock optional dependencies before importing featrixsphere
-import sys
-
-# Mock numpy
-try:
-    import numpy as np
-except ImportError:
-    class MockNumpy:
-        class ndarray:
-            pass
-        def array(self, *args, **kwargs):
-            return []
-        def __getattr__(self, name):
-            return lambda *args, **kwargs: None
-    sys.modules['numpy'] = MockNumpy()
-
-# Mock matplotlib
-try:
-    import matplotlib.pyplot as plt
-except ImportError:
-    class MockMatplotlib:
-        class Figure:
-            pass
-        def __getattr__(self, name):
-            return lambda *args, **kwargs: None
-    sys.modules['matplotlib'] = MockMatplotlib()
-    sys.modules['matplotlib.pyplot'] = MockMatplotlib()
-    sys.modules['matplotlib.dates'] = MockMatplotlib()
-
-# Add parent directory to path to import featrixsphere
-sys.path.insert(0, str(Path(__file__).parent.parent))
-
-try:
-    from featrixsphere import FeatrixSphereClient, SessionInfo, PredictionBatch
-except (ImportError, AttributeError) as e:
-    # If import fails, create minimal mocks for basic structure tests
-    print(f"⚠️  Warning: Could not fully import featrixsphere: {e}")
-    print("   Running minimal structure tests only...")
-    
-    # Create minimal mocks for basic testing
-    class MockSession:
-        def __init__(self):
-            self.headers = {}
-            self.timeout = 30
-    
-    class MockFeatrixSphereClient:
-        def __init__(self, base_url="http://test.com", **kwargs):
-            self.base_url = base_url.rstrip('/')
-            self.compute_cluster = kwargs.get('compute_cluster')
-            self.session = MockSession()
-            self.default_max_retries = 5
-            # Set header if compute_cluster provided
-            if self.compute_cluster:
-                self.session.headers['X-Featrix-Node'] = self.compute_cluster
-        
-        def set_compute_cluster(self, cluster):
-            self.compute_cluster = cluster
-            if cluster:
-                self.session.headers['X-Featrix-Node'] = cluster
-            else:
-                self.session.headers.pop('X-Featrix-Node', None)
-        
-        def _make_request(self, method, endpoint, **kwargs):
-            from unittest.mock import Mock
-            response = Mock()
-            response.status_code = 200
-            response.json.return_value = {}
-            return response
-    
-    class MockSessionInfo:
-        def __init__(self, session_id, session_type, status, jobs, job_queue_positions, _client=None):
-            self.session_id = session_id
-            self.session_type = session_type
-            self.status = status
-    
-    class MockPredictionBatch:
-        def __init__(self, session_id, client, target_column=None):
-            self.session_id = session_id
-            self.client = client
-            self._cache = {}
-            self._stats = {'hits': 0, 'misses': 0, 'populated': 0}
-        
-        def _hash_record(self, record):
-            import hashlib
-            import json
-            sorted_items = sorted(record.items())
-            record_str = json.dumps(sorted_items, sort_keys=True)
-            return hashlib.md5(record_str.encode()).hexdigest()
-        
-        def predict(self, record):
-            record_hash = self._hash_record(record)
-            if record_hash in self._cache:
-                self._stats['hits'] += 1
-                return self._cache[record_hash]
-            else:
-                self._stats['misses'] += 1
-                return {
-                    'cache_miss': True,
-                    'record': record,
-                    'suggestion': 'Record not found in batch cache. Add to records list and recreate batch.'
-                }
-        
-        def get_stats(self):
-            total = self._stats['hits'] + self._stats['misses']
-            return {
-                'cache_hits': self._stats['hits'],
-                'cache_misses': self._stats['misses'],
-                'total_requests': total,
-                'hit_rate': self._stats['hits'] / total if total > 0 else 0.0
-            }
-    
-    FeatrixSphereClient = MockFeatrixSphereClient
-    SessionInfo = MockSessionInfo
-    PredictionBatch = MockPredictionBatch
-
-
-class TestFeatrixSphereClient(unittest.TestCase):
-    """Test cases for FeatrixSphereClient."""
-    
-    def setUp(self):
-        """Set up test fixtures."""
-        self.client = FeatrixSphereClient(base_url="http://test-server.com")
-    
-    def test_client_initialization(self):
-        """Test that client initializes correctly."""
-        self.assertEqual(self.client.base_url, "http://test-server.com")
-        self.assertIsNotNone(self.client.session)
-        self.assertEqual(self.client.default_max_retries, 5)
-    
-    def test_client_with_compute_cluster(self):
-        """Test client initialization with compute cluster."""
-        client = FeatrixSphereClient(
-            base_url="http://test-server.com",
-            compute_cluster="burrito"
-        )
-        self.assertEqual(client.compute_cluster, "burrito")
-        self.assertIn("X-Featrix-Node", client.session.headers)
-        self.assertEqual(client.session.headers["X-Featrix-Node"], "burrito")
-    
-    def test_set_compute_cluster(self):
-        """Test setting compute cluster after initialization."""
-        self.client.set_compute_cluster("churro")
-        self.assertEqual(self.client.compute_cluster, "churro")
-        self.assertEqual(self.client.session.headers.get("X-Featrix-Node"), "churro")
-        
-        # Test removing cluster
-        self.client.set_compute_cluster(None)
-        self.assertIsNone(self.client.compute_cluster)
-        self.assertNotIn("X-Featrix-Node", self.client.session.headers)
-    
-    def test_endpoint_auto_prefix(self):
-        """Test that session endpoints get /compute prefix automatically."""
-        # Skip if using mocks (client doesn't have full requests functionality)
-        if not hasattr(self.client.session, 'get'):
-            self.skipTest("Skipping - using mocks without full requests support")
-        
-        with patch.object(self.client.session, 'get') as mock_get:
-            mock_response = Mock()
-            mock_response.status_code = 200
-            mock_response.json.return_value = {}
-            mock_get.return_value = mock_response
-            
-            # Should auto-add /compute prefix
-            self.client._make_request('GET', '/session/test-123')
-            mock_get.assert_called_once()
-            call_url = mock_get.call_args[0][0]
-            self.assertIn('/compute/session/test-123', call_url)
-    
-    def test_session_info_initialization(self):
-        """Test SessionInfo dataclass initialization."""
-        session = SessionInfo(
-            session_id="test-123",
-            session_type="embedding_space",
-            status="complete",
-            jobs={},
-            job_queue_positions={}
-        )
-        self.assertEqual(session.session_id, "test-123")
-        self.assertEqual(session.session_type, "embedding_space")
-        self.assertEqual(session.status, "complete")
-    
-    def test_prediction_batch_hash_record(self):
-        """Test PredictionBatch record hashing."""
-        batch = PredictionBatch("test-123", self.client)
-        
-        record1 = {"a": 1, "b": 2}
-        record2 = {"b": 2, "a": 1}  # Same keys, different order
-        record3 = {"a": 1, "b": 3}  # Different value
-        
-        hash1 = batch._hash_record(record1)
-        hash2 = batch._hash_record(record2)
-        hash3 = batch._hash_record(record3)
-        
-        # Same records should hash to same value (order-independent)
-        self.assertEqual(hash1, hash2)
-        # Different records should hash to different values
-        self.assertNotEqual(hash1, hash3)
-    
-    def test_prediction_batch_cache_miss(self):
-        """Test PredictionBatch cache miss behavior."""
-        batch = PredictionBatch("test-123", self.client)
-        
-        record = {"feature": "value"}
-        result = batch.predict(record)
-        
-        self.assertTrue(result.get('cache_miss'))
-        self.assertEqual(result.get('record'), record)
-        self.assertIn('suggestion', result)
-    
-    def test_prediction_batch_stats(self):
-        """Test PredictionBatch statistics tracking."""
-        batch = PredictionBatch("test-123", self.client)
-        
-        # Make some predictions (cache misses)
-        batch.predict({"a": 1})
-        batch.predict({"b": 2})
-        
-        stats = batch.get_stats()
-        self.assertEqual(stats['cache_misses'], 2)
-        self.assertEqual(stats['cache_hits'], 0)
-        self.assertEqual(stats['total_requests'], 2)
-        self.assertEqual(stats['hit_rate'], 0.0)
-    
-    def test_prediction_batch_cache_hit(self):
-        """Test PredictionBatch cache hit behavior."""
-        batch = PredictionBatch("test-123", self.client)
-        
-        # Manually populate cache
-        record = {"feature": "value"}
-        record_hash = batch._hash_record(record)
-        batch._cache[record_hash] = {"prediction": "test_result"}
-        batch._stats['populated'] = 1
-        
-        # Now predict should hit cache
-        result = batch.predict(record)
-        self.assertFalse(result.get('cache_miss', False))
-        self.assertEqual(result.get('prediction'), "test_result")
-        
-        stats = batch.get_stats()
-        self.assertEqual(stats['cache_hits'], 1)
-        self.assertEqual(stats['cache_misses'], 0)
-        self.assertEqual(stats['hit_rate'], 1.0)
-
-
-class TestClientErrorHandling(unittest.TestCase):
-    """Test error handling in FeatrixSphereClient."""
-    
-    def setUp(self):
-        """Set up test fixtures."""
-        self.client = FeatrixSphereClient(base_url="http://test-server.com")
-    
-    def test_make_request_retry_on_500(self):
-        """Test that 500 errors trigger retries."""
-        # Skip if using mocks (client doesn't have full requests functionality)
-        if not hasattr(self.client.session, 'get'):
-            self.skipTest("Skipping - using mocks without full requests support")
-        
-        with patch.object(self.client.session, 'get') as mock_get:
-            # First call returns 500, second returns 200
-            mock_response_500 = Mock()
-            mock_response_500.status_code = 500
-            mock_response_200 = Mock()
-            mock_response_200.status_code = 200
-            mock_response_200.json.return_value = {}
-            mock_get.side_effect = [mock_response_500, mock_response_200]
-            
-            # Should retry and eventually succeed
-            response = self.client._make_request('GET', '/test', max_retries=2)
-            self.assertEqual(response.status_code, 200)
-            self.assertEqual(mock_get.call_count, 2)
-    
-    def test_make_request_timeout(self):
-        """Test timeout handling."""
-        # Skip if using mocks (client doesn't have full requests functionality)
-        if not hasattr(self.client.session, 'get'):
-            self.skipTest("Skipping - using mocks without full requests support")
-        
-        import requests
-        with patch.object(self.client.session, 'get') as mock_get:
-            mock_get.side_effect = requests.exceptions.Timeout("Request timed out")
-            
-            # Should raise after retries exhausted
-            with self.assertRaises(Exception):
-                self.client._make_request('GET', '/test', max_retries=1)
-
-
-def run_tests():
-    """Run all tests and return exit code."""
-    loader = unittest.TestLoader()
-    suite = loader.loadTestsFromModule(sys.modules[__name__])
-    runner = unittest.TextTestRunner(verbosity=2)
-    result = runner.run(suite)
-    return 0 if result.wasSuccessful() else 1
-
-
-if __name__ == '__main__':
-    sys.exit(run_tests())
-

featrixsphere-0.2.4991.dist-info/RECORD

@@ -1,8 +0,0 @@
-featrixsphere/__init__.py,sha256=UaVSYqUbFAR92BWYcQkfV7lVfnbogtZFbAJTgDdmUQo,1888
-featrixsphere/client.py,sha256=bqRRyumplQmeRDrxyyhYcj_VIOnl_svh-fJ8VUcxBv4,426243
-featrixsphere/test_client.py,sha256=4SiRbib0ms3poK0UpnUv4G0HFQSzidF3Iswo_J2cjLk,11981
-featrixsphere-0.2.4991.dist-info/METADATA,sha256=DOj--UmpmV2TsuBAtsn72NYFRwn6Nipqq71oGj_bAnc,16232
-featrixsphere-0.2.4991.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-featrixsphere-0.2.4991.dist-info/entry_points.txt,sha256=QreJeYfD_VWvbEqPmMXZ3pqqlFlJ1qZb-NtqnyhEldc,51
-featrixsphere-0.2.4991.dist-info/top_level.txt,sha256=AyN4wjfzlD0hWnDieuEHX0KckphIk_aC73XCG4df5uU,14
-featrixsphere-0.2.4991.dist-info/RECORD,,