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

featrixsphere/test_client.py

@@ -0,0 +1,311 @@
+#!/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.1.583.dist-info → featrixsphere-0.2.1314.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: featrixsphere
-Version: 0.1.583
+Version: 0.2.1314
 Summary: Transform any CSV into a production-ready ML model in minutes, not months.
 Home-page: https://github.com/Featrix/sphere
 Author: Featrix
@@ -299,6 +299,47 @@ print(f"""
 
 ## 🔍 Advanced Features
 
+### Batch Encoding (NEW in v0.2.228! 🆕)
+```python
+# Encode single record
+embedding = client.encode_records(session_id, {
+    "text": "customer complaint about billing",
+    "category": "support"
+})
+
+# NEW: Batch encoding with intelligent adaptive sizing!
+# Handles any size - even 50,000+ records efficiently
+records = [
+    {"text": "happy customer", "category": "support"},
+    {"text": "billing issue", "category": "finance"},
+    # ... thousands more records
+]
+
+# Automatically batches, measures response time, and optimizes throughput
+embeddings = client.encode_records(session_id, records)
+# Output:
+# 📊 Encoding 50,000 records with adaptive batching...
+#   ✓ Batch: 100 records in 2.3s (43.5 rec/s) - Progress: 100/50,000 (0.2%)
+#   ⚡ Fast response, increasing batch size to 150
+#   ✓ Batch: 150 records in 3.1s (48.4 rec/s) - Progress: 250/50,000 (0.5%)
+#   ...
+# ✅ Completed encoding 50,000 records
+
+# Access both 3D and full-dimensional embeddings
+for result in embeddings:
+    short_3d = result['embedding_short']      # 3D for visualization
+    full_embedding = result['embedding_long']  # Full-dimensional for ML
+```
+
+**How Batch Encoding Works:**
+- Starts with batches of 100 records
+- Measures each batch response time
+- If < 3.5s → increases batch size by 1.5x
+- If < 5s → increases by 1.2x  
+- If > 6.5s → decreases by 0.7x
+- Targets ~5 seconds per batch for optimal throughput
+- Range: 10-5,000 records per batch
+
 ### Similarity Search
 ```python
 # Find similar records using neural embeddings
@@ -321,7 +362,8 @@ embedding = client.encode_records(session_id, {
     "priority": "high"
 })
 
-print(f"Embedding dimension: {len(embedding['embedding'])}")
+print(f"3D embedding: {embedding['embedding_short']}")
+print(f"Full embedding dimension: {len(embedding['embedding_long'])}")
 # Embedding dimension: 512  (rich 512-dimensional representation!)
 ```
 
@@ -386,14 +428,11 @@ print(f"""
 batch_results = client.predict_records(session_id, records_list)
 # 10x faster than individual predictions!
 
-# Adjust training parameters for your data size
+# Featrix will automatically tune your model for your data.
 client.train_single_predictor(
     session_id=session_id,
     target_column="target",
-    target_column_type="set",
-    epochs=100,      # More epochs for complex patterns
-    batch_size=512,  # Larger batches for big datasets
-    learning_rate=0.001  # Lower LR for stable training
+    target_column_type="set"
 )
 ```
 

featrixsphere-0.2.1314.dist-info/RECORD

@@ -0,0 +1,9 @@
+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,,