SURE-tools 2.4.22__py3-none-any.whl → 2.4.32__py3-none-any.whl

SURE/PerturbationAwareDecoder.py

@@ -12,30 +12,20 @@ warnings.filterwarnings('ignore')
 class PerturbationAwareDecoder:
     """
     Advanced transcriptome decoder with perturbation awareness
-    Supports single hidden layer configurations
+    Fixed version with proper handling of single hidden layer configurations
     """
     
     def __init__(self, 
                  latent_dim: int = 100,
                  num_known_perturbations: int = 50,
                  gene_dim: int = 60000,
-                 hidden_dims: List[int] = [512],  # Now supports single element list
+                 hidden_dims: List[int] = [512],
                  perturbation_embedding_dim: int = 128,
                  biological_prior_dim: int = 256,
                  dropout_rate: float = 0.1,
                  device: str = None):
         """
-        Multi-modal decoder supporting single hidden layer configurations
-        
-        Args:
-            latent_dim: Latent variable dimension
-            num_known_perturbations: Number of known perturbation types
-            gene_dim: Number of genes
-            hidden_dims: Hidden layer dimensions (can be single element list)
-            perturbation_embedding_dim: Embedding dimension for perturbations
-            biological_prior_dim: Dimension for biological prior knowledge
-            dropout_rate: Dropout rate
-            device: Computation device
+        Multi-modal decoder with fixed single layer support
         """
         self.latent_dim = latent_dim
         self.num_known_perturbations = num_known_perturbations
@@ -50,7 +40,7 @@ class PerturbationAwareDecoder:
         self._validate_hidden_dims()
         
         # Initialize multi-modal model
-        self.model = self._build_single_layer_compatible_model()
+        self.model = self._build_fixed_model()
         self.model.to(self.device)
         
         # Training state
@@ -77,8 +67,8 @@ class PerturbationAwareDecoder:
         else:
             print(f"🔧 Multi-layer configuration: {len(self.hidden_dims)} hidden layers")
     
-    class SingleLayerCompatiblePerturbationEncoder(nn.Module):
-        """Perturbation encoder compatible with single hidden layer"""
+    class FixedPerturbationEncoder(nn.Module):
+        """Fixed perturbation encoder"""
         
         def __init__(self, num_perturbations: int, embedding_dim: int, hidden_dim: int):
             super().__init__()
@@ -87,7 +77,7 @@ class PerturbationAwareDecoder:
             # Embedding for perturbation types
             self.perturbation_embedding = nn.Embedding(num_perturbations, embedding_dim)
             
-            # Single projection layer (compatible with single hidden layer)
+            # Projection to hidden space
             self.projection = nn.Sequential(
                 nn.Linear(embedding_dim, hidden_dim),
                 nn.ReLU(),
@@ -95,28 +85,26 @@ class PerturbationAwareDecoder:
             )
             
         def forward(self, one_hot_perturbations):
-            batch_size = one_hot_perturbations.shape[0]
-            
             # Convert one-hot to indices
             perturbation_indices = torch.argmax(one_hot_perturbations, dim=1)
             
             # Get perturbation embeddings
             perturbation_embeds = self.perturbation_embedding(perturbation_indices)
             
-            # Single projection
+            # Project to hidden space
             hidden_repr = self.projection(perturbation_embeds)
             
             return hidden_repr
     
-    class SingleLayerCrossModalFusion(nn.Module):
-        """Cross-modal fusion compatible with single hidden layer"""
+    class FixedCrossModalFusion(nn.Module):
+        """Fixed cross-modal fusion"""
         
         def __init__(self, latent_dim: int, perturbation_dim: int, fusion_dim: int):
             super().__init__()
             self.latent_projection = nn.Linear(latent_dim, fusion_dim)
             self.perturbation_projection = nn.Linear(perturbation_dim, fusion_dim)
             
-            # Simplified fusion for single layer
+            # Fusion gate
             self.fusion_gate = nn.Sequential(
                 nn.Linear(fusion_dim * 2, fusion_dim),
                 nn.Sigmoid()
@@ -130,7 +118,7 @@ class PerturbationAwareDecoder:
             latent_proj = self.latent_projection(latent)
             perturbation_proj = self.perturbation_projection(perturbation_encoded)
             
-            # Simple gated fusion (no complex attention for single layer)
+            # Gated fusion
             concatenated = torch.cat([latent_proj, perturbation_proj], dim=-1)
             fusion_gate = self.fusion_gate(concatenated)
             
@@ -141,43 +129,32 @@ class PerturbationAwareDecoder:
             
             return fused
     
-    class SingleLayerPerturbationResponseNetwork(nn.Module):
-        """Response network compatible with single hidden layer"""
+    class FixedPerturbationResponseNetwork(nn.Module):
+        """Fixed response network with proper single layer handling"""
         
         def __init__(self, fusion_dim: int, gene_dim: int, hidden_dims: List[int]):
             super().__init__()
             
-            # Handle single layer case
-            if len(hidden_dims) == 1:
-                # Single hidden layer
-                self.base_network = nn.Sequential(
-                    nn.Linear(fusion_dim, hidden_dims[0]),
-                    nn.BatchNorm1d(hidden_dims[0]),
+            # Build network layers
+            layers = []
+            input_dim = fusion_dim
+            
+            # Handle both single and multi-layer cases
+            for i, hidden_dim in enumerate(hidden_dims):
+                layers.extend([
+                    nn.Linear(input_dim, hidden_dim),
+                    nn.BatchNorm1d(hidden_dim),
                     nn.ReLU(),
                     nn.Dropout(0.1)
-                )
-                final_input_dim = hidden_dims[0]
-            else:
-                # Multiple hidden layers
-                layers = []
-                input_dim = fusion_dim
-                
-                for hidden_dim in hidden_dims:
-                    layers.extend([
-                        nn.Linear(input_dim, hidden_dim),
-                        nn.BatchNorm1d(hidden_dim),
-                        nn.ReLU(),
-                        nn.Dropout(0.1)
-                    ])
-                    input_dim = hidden_dim
-                
-                self.base_network = nn.Sequential(*layers)
-                final_input_dim = hidden_dims[-1]
+                ])
+                input_dim = hidden_dim
+            
+            self.base_network = nn.Sequential(*layers)
             
-            # Final projection
-            self.final_projection = nn.Linear(final_input_dim, gene_dim)
+            # Final projection - FIXED: Use current input_dim instead of hidden_dims[-1]
+            self.final_projection = nn.Linear(input_dim, gene_dim)
             
-            # Perturbation-aware scaling (simplified for single layer)
+            # Perturbation-aware scaling
             self.scale = nn.Linear(fusion_dim, 1)
             self.bias = nn.Linear(fusion_dim, 1)
         
@@ -191,8 +168,8 @@ class PerturbationAwareDecoder:
             
             return F.softplus(expression * scale + bias)
     
-    class SingleLayerNovelPerturbationPredictor(nn.Module):
-        """Novel perturbation predictor compatible with single hidden layer"""
+    class FixedNovelPerturbationPredictor(nn.Module):
+        """Fixed novel perturbation predictor"""
         
         def __init__(self, num_known_perturbations: int, gene_dim: int, hidden_dim: int):
             super().__init__()
@@ -204,7 +181,7 @@ class PerturbationAwareDecoder:
                 torch.randn(num_known_perturbations, gene_dim) * 0.1
             )
             
-            # Simplified response generator for single layer
+            # Response generator - handle case where hidden_dim might be 0
             if hidden_dim > 0:
                 self.response_generator = nn.Sequential(
                     nn.Linear(num_known_perturbations, hidden_dim),
@@ -215,7 +192,7 @@ class PerturbationAwareDecoder:
                 # Direct projection if no hidden layer
                 self.response_generator = nn.Linear(num_known_perturbations, gene_dim)
             
-            # Simplified attention
+            # Attention mechanism
             self.similarity_attention = nn.Sequential(
                 nn.Linear(num_known_perturbations, num_known_perturbations),
                 nn.Softmax(dim=-1)
@@ -238,8 +215,8 @@ class PerturbationAwareDecoder:
             
             return final_response
     
-    class SingleLayerCompatibleDecoder(nn.Module):
-        """Main decoder compatible with single hidden layer configurations"""
+    class FixedMultimodalDecoder(nn.Module):
+        """Main decoder with fixed single layer handling"""
         
         def __init__(self, latent_dim: int, num_known_perturbations: int, gene_dim: int, 
                     hidden_dims: List[int], perturbation_embedding_dim: int, 
@@ -250,33 +227,26 @@ class PerturbationAwareDecoder:
             self.latent_dim = latent_dim
             self.gene_dim = gene_dim
             
-            # Handle single layer case for hidden_dims
-            if len(hidden_dims) == 1:
-                # Use the single dimension for all components
-                main_hidden_dim = hidden_dims[0]
-                response_hidden_dims = []  # No additional hidden layers for response
-            else:
-                # Multiple layers: first for fusion, rest for response
-                main_hidden_dim = hidden_dims[0]
-                response_hidden_dims = hidden_dims[1:]
+            # Use first hidden dimension for fusion
+            main_hidden_dim = hidden_dims[0]
             
             # Perturbation encoder
-            self.perturbation_encoder = PerturbationAwareDecoder.SingleLayerCompatiblePerturbationEncoder(
+            self.perturbation_encoder = PerturbationAwareDecoder.FixedPerturbationEncoder(
                 num_known_perturbations, perturbation_embedding_dim, main_hidden_dim
             )
             
             # Cross-modal fusion
-            self.cross_modal_fusion = PerturbationAwareDecoder.SingleLayerCrossModalFusion(
+            self.cross_modal_fusion = PerturbationAwareDecoder.FixedCrossModalFusion(
                 latent_dim, main_hidden_dim, main_hidden_dim
             )
             
-            # Response network
-            self.response_network = PerturbationAwareDecoder.SingleLayerPerturbationResponseNetwork(
-                main_hidden_dim, gene_dim, response_hidden_dims
+            # Response network - FIXED: Use all hidden_dims for response network
+            self.response_network = PerturbationAwareDecoder.FixedPerturbationResponseNetwork(
+                main_hidden_dim, gene_dim, hidden_dims  # Pass all hidden_dims
             )
             
             # Novel perturbation predictor
-            self.novel_predictor = PerturbationAwareDecoder.SingleLayerNovelPerturbationPredictor(
+            self.novel_predictor = PerturbationAwareDecoder.FixedNovelPerturbationPredictor(
                 num_known_perturbations, gene_dim, main_hidden_dim
             )
             
@@ -300,9 +270,9 @@ class PerturbationAwareDecoder:
             """Get learned perturbation response prototypes"""
             return self.novel_predictor.perturbation_prototypes.detach()
     
-    def _build_single_layer_compatible_model(self):
-        """Build model compatible with single hidden layer"""
-        return self.SingleLayerCompatibleDecoder(
+    def _build_fixed_model(self):
+        """Build the fixed model"""
+        return self.FixedMultimodalDecoder(
             self.latent_dim, self.num_known_perturbations, self.gene_dim,
             self.hidden_dims, self.perturbation_embedding_dim,
             self.biological_prior_dim, self.dropout_rate
@@ -318,11 +288,11 @@ class PerturbationAwareDecoder:
               batch_size: int = 32,
               num_epochs: int = 200,
               learning_rate: float = 1e-4,
-              checkpoint_path: str = 'single_layer_decoder.pth') -> Dict:
+              checkpoint_path: str = 'fixed_decoder.pth') -> Dict:
         """
-        Train the decoder with single layer compatibility
+        Train the fixed decoder
         """
-        print("🧬 Starting Training with Single Layer Support...")
+        print("🧬 Starting Training with Fixed Single Layer Support...")
         
         # Validate one-hot encoding
         self._validate_one_hot_perturbations(train_perturbations)
@@ -626,98 +596,142 @@ class PerturbationAwareDecoder:
         self.best_val_loss = checkpoint.get('best_val_loss', float('inf'))
         print(f"✅ Model loaded! Best val loss: {self.best_val_loss:.4f}")
 
-'''# Example usage with single hidden layer
-def example_single_layer_usage():
-    """Example demonstration with single hidden layer"""
+'''# Test the fixed implementation
+def test_single_layer_fix():
+    """Test the fixed single layer implementation"""
     
-    # Initialize decoder with single hidden layer
-    decoder = PerturbationAwareDecoder(
+    print("🧪 Testing single layer configuration...")
+    
+    # Test with single hidden layer
+    decoder_single = PerturbationAwareDecoder(
         latent_dim=100,
         num_known_perturbations=10,
-        gene_dim=2000,  # Reduced for example
-        hidden_dims=[512],  # Single hidden layer
+        gene_dim=2000,
+        hidden_dims=[512],  # Single element list
         perturbation_embedding_dim=128
     )
     
-    # Generate example data
-    n_samples = 1000
-    n_perturbations = 10
-    
-    # Latent variables
+    # Generate test data
+    n_samples = 100
     latent_data = np.random.randn(n_samples, 100).astype(np.float32)
-    
-    # One-hot encoded perturbations
-    perturbations = np.zeros((n_samples, n_perturbations))
-    for i in range(n_samples):
-        if i % 10 != 0:  # 90% perturbed, 10% control
-            perturb_id = np.random.randint(0, n_perturbations)
-            perturbations[i, perturb_id] = 1.0
-    
-    # Expression data
-    base_weights = np.random.randn(100, 2000) * 0.1
-    perturbation_effects = np.random.randn(n_perturbations, 2000) * 0.5
-    
-    expression_data = np.tanh(latent_data.dot(base_weights))
+    perturbations = np.zeros((n_samples, 10))
     for i in range(n_samples):
-        if perturbations[i].sum() > 0:
-            perturb_id = np.argmax(perturbations[i])
-            expression_data[i] += perturbation_effects[perturb_id]
+        if i % 10 != 0:
+            perturbations[i, np.random.randint(0, 10)] = 1.0
     
+    expression_data = np.random.randn(n_samples, 2000).astype(np.float32)
     expression_data = np.maximum(expression_data, 0)
     
-    print(f"📊 Data shapes: Latent {latent_data.shape}, Perturbations {perturbations.shape}, Expression {expression_data.shape}")
-    print(f"🔧 Hidden layers: {len(decoder.hidden_dims)}")
-    print(f"🔧 Hidden dimensions: {decoder.hidden_dims}")
-    
-    # Train with single hidden layer
-    history = decoder.train(
-        train_latent=latent_data,
-        train_perturbations=perturbations,
-        train_expression=expression_data,
-        batch_size=32,
-        num_epochs=50
-    )
+    # Test forward pass
+    decoder_single.model.eval()
+    with torch.no_grad():
+        latent_tensor = torch.FloatTensor(latent_data[:5]).to(decoder_single.device)
+        perturbations_tensor = torch.FloatTensor(perturbations[:5]).to(decoder_single.device)
+        
+        # Test known perturbation prediction
+        output = decoder_single.model(latent_tensor, perturbations_tensor, mode='one_hot')
+        print(f"✅ Known perturbation prediction shape: {output.shape}")
+        
+        # Test novel perturbation prediction
+        similarity_matrix = np.random.rand(5, 10).astype(np.float32)
+        similarity_tensor = torch.FloatTensor(similarity_matrix).to(decoder_single.device)
+        novel_output = decoder_single.model(latent_tensor, similarity_tensor, mode='similarity')
+        print(f"✅ Novel perturbation prediction shape: {novel_output.shape}")
     
-    # Test predictions
-    test_latent = np.random.randn(10, 100).astype(np.float32)
-    test_perturbations = np.zeros((10, n_perturbations))
-    for i in range(10):
-        test_perturbations[i, i % n_perturbations] = 1.0
+    print("🎉 Single layer test passed!")
+
+def test_multi_layer_fix():
+    """Test the multi-layer implementation"""
     
-    predictions = decoder.predict(test_latent, test_perturbations)
-    print(f"🔮 Known perturbation prediction shape: {predictions.shape}")
+    print("\n🧪 Testing multi-layer configuration...")
     
-    # Test novel perturbation prediction
-    test_latent_novel = np.random.randn(5, 100).astype(np.float32)
-    similarity_matrix = np.random.rand(5, n_perturbations)
-    similarity_matrix = similarity_matrix / similarity_matrix.sum(axis=1, keepdims=True)
+    # Test with multiple hidden layers
+    decoder_multi = PerturbationAwareDecoder(
+        latent_dim=100,
+        num_known_perturbations=10,
+        gene_dim=2000,
+        hidden_dims=[256, 512, 1024],  # Multiple layers
+        perturbation_embedding_dim=128
+    )
     
-    novel_predictions = decoder.predict_novel_perturbation(test_latent_novel, similarity_matrix)
-    print(f"🔮 Novel perturbation prediction shape: {novel_predictions.shape}")
+    print("🎉 Multi-layer test passed!")
+
+def test_edge_cases():
+    """Test edge cases"""
+    
+    print("\n🧪 Testing edge cases...")
+    
+    # Test with different hidden_dims configurations
+    configs = [
+        [512],           # Single layer
+        [256, 512],      # Two layers
+        [128, 256, 512], # Three layers
+        [1024],          # Wide single layer
+        [64, 128, 256, 512, 1024]  # Deep network
+    ]
+    
+    for i, hidden_dims in enumerate(configs):
+        try:
+            decoder = PerturbationAwareDecoder(
+                latent_dim=50,
+                num_known_perturbations=5,
+                gene_dim=1000,
+                hidden_dims=hidden_dims,
+                perturbation_embedding_dim=64
+            )
+            print(f"✅ Config {i+1}: {hidden_dims} - Success")
+        except Exception as e:
+            print(f"❌ Config {i+1}: {hidden_dims} - Failed: {e}")
     
-    return decoder
+    print("🎉 Edge case testing completed!")
 
-# Example usage with multiple hidden layers
-def example_multi_layer_usage():
-    """Example demonstration with multiple hidden layers"""
+if __name__ == "__main__":
+    # Run tests
+    test_single_layer_fix()
+    test_multi_layer_fix()
+    test_edge_cases()
     
-    # Initialize decoder with multiple hidden layers
+    # Example usage
+    print("\n🎯 Example Usage:")
+    
+    # Single hidden layer example
     decoder = PerturbationAwareDecoder(
         latent_dim=100,
         num_known_perturbations=10,
         gene_dim=2000,
-        hidden_dims=[256, 512, 1024],  # Multiple hidden layers
+        hidden_dims=[512],  # Single hidden layer
         perturbation_embedding_dim=128
     )
     
-    print(f"🔧 Hidden layers: {len(decoder.hidden_dims)}")
-    print(f"🔧 Hidden dimensions: {decoder.hidden_dims}")
+    # Generate example data
+    n_samples = 1000
+    latent_data = np.random.randn(n_samples, 100).astype(np.float32)
+    perturbations = np.zeros((n_samples, 10))
+    for i in range(n_samples):
+        if i % 10 != 0:
+            perturbations[i, np.random.randint(0, 10)] = 1.0
+    
+    # Simulate expression data
+    base_weights = np.random.randn(100, 2000) * 0.1
+    perturbation_effects = np.random.randn(10, 2000) * 0.5
     
-    return decoder
-
-if __name__ == "__main__":
-    print("=== Single Hidden Layer Example ===")
-    decoder_single = example_single_layer_usage()
+    expression_data = np.tanh(latent_data.dot(base_weights))
+    for i in range(n_samples):
+        if perturbations[i].sum() > 0:
+            perturb_id = np.argmax(perturbations[i])
+            expression_data[i] += perturbation_effects[perturb_id]
+    
+    expression_data = np.maximum(expression_data, 0)
+    
+    print(f"📊 Example data shapes: Latent {latent_data.shape}, Perturbations {perturbations.shape}")
+    
+    # Train (commented out for quick testing)
+    # history = decoder.train(
+    #     train_latent=latent_data,
+    #     train_perturbations=perturbations,
+    #     train_expression=expression_data,
+    #     batch_size=32,
+    #     num_epochs=10  # Short training for testing
+    # )
     
-    print("\n=== Multiple Hidden Layers Example ===")
-    decoder_multi = example_multi_layer_usage()'''
+    print("🎉 All tests completed successfully!")'''

SURE/__init__.py

@@ -1,5 +1,6 @@
 from .SURE import SURE
 from .DensityFlow import DensityFlow
+from .DensityFlowLinear import DensityFlowLinear
 from .PerturbE import PerturbE
 from .TranscriptomeDecoder import TranscriptomeDecoder
 from .SimpleTranscriptomeDecoder import SimpleTranscriptomeDecoder
@@ -11,6 +12,7 @@ from . import utils
 from . import codebook
 from . import SURE
 from . import DensityFlow
+from . import DensityFlowLinear
 from . import atac
 from . import flow 
 from . import perturb
@@ -21,6 +23,6 @@ from . import EfficientTranscriptomeDecoder
 from . import VirtualCellDecoder
 from . import PerturbationAwareDecoder
 
-__all__ = ['SURE', 'DensityFlow', 'PerturbE', 'TranscriptomeDecoder', 'SimpleTranscriptomeDecoder',
+__all__ = ['SURE', 'DensityFlow', 'DensityFlowLinear', 'PerturbE', 'TranscriptomeDecoder', 'SimpleTranscriptomeDecoder',
            'EfficientTranscriptomeDecoder', 'VirtualCellDecoder', 'PerturbationAwareDecoder', 
            'flow', 'perturb', 'atac', 'utils', 'codebook']

{sure_tools-2.4.22.dist-info → sure_tools-2.4.32.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SURE-tools
-Version: 2.4.22
+Version: 2.4.32
 Summary: Succinct Representation of Single Cells
 Home-page: https://github.com/ZengFLab/SURE
 Author: Feng Zeng

{sure_tools-2.4.22.dist-info → sure_tools-2.4.32.dist-info}/RECORD

@@ -1,12 +1,14 @@
-SURE/DensityFlow.py,sha256=mp2hVxqwg-wVlDEc2Q2flrtzowDVyMzjC7od3rZTm40,57044
+SURE/DensityFlow.py,sha256=M8yDMCzH-LSVjFB34pUaN2TNUqo0jnZMmaFcLLjtYBU,57218
+SURE/DensityFlow2.py,sha256=BBRCoA4NpU4EjghToOvowo17UtwYokTN75KxWYHTX1E,58404
+SURE/DensityFlowLinear.py,sha256=RfjIwXxO0gWQni7LHRy4DSDUkdz3HpDjlZbxJse65Ts,57515
 SURE/EfficientTranscriptomeDecoder.py,sha256=O_x-4edKBU5OJJbOOS-59u3TQElZqhAtOVJMPlpw8m0,21667
 SURE/PerturbE.py,sha256=DxEp-qef--x8-GMZdPfBf8ts8UDDc34h2P5AnpqZ-YM,52265
-SURE/PerturbationAwareDecoder.py,sha256=hhdGC9kIOlfFaWrO4hnaF91PEMSEMqVSovzDS-QWytk,30653
+SURE/PerturbationAwareDecoder.py,sha256=duhvBvZjOpAk7c2YTfmA2qKbrgVvwT7IW1pxaukq_iU,30231
 SURE/SURE.py,sha256=MXs7iuvcj-lU4dJ_MwKegpL2Rqk2HB4eFfAgHRA3RtA,47744
 SURE/SimpleTranscriptomeDecoder.py,sha256=mLgYYipfRrmuXlpoaxLPfJS009OVwyshdL3nXTJygIE,22285
 SURE/TranscriptomeDecoder.py,sha256=n2tVB8hNVLwSQ1G1Jpd6WzMl2Iw63eK0_Ujk9d48SJY,20982
 SURE/VirtualCellDecoder.py,sha256=z1Z7GRTYmTE3DaSKZueofv138R0J7kGFfnh0a_Lee38,27468
-SURE/__init__.py,sha256=7P8BRLq4sPXwQX5qEeafMPxAnRzxFbK2ZO_QTmQOlhk,1021
+SURE/__init__.py,sha256=ayUV9hNysHtZxbRK87nnC6cXs-7wAq6FUkllqotrx8E,1123
 SURE/assembly/__init__.py,sha256=jxZLURXKPzXe21LhrZ09LgZr33iqdjlQy4oSEj5gR2Q,172
 SURE/assembly/assembly.py,sha256=6IMdelPOiRO4mUb4dC7gVCoF1Uvfw86-Map8P_jnUag,21477
 SURE/assembly/atlas.py,sha256=ALjmVWutm_tOHTcT1aqOxmuCEQw-XzrtDoMCV_8oXLk,21794
@@ -23,9 +25,9 @@ SURE/utils/__init__.py,sha256=YF5jB-PAHJQ40OlcZ7BCZbsN2q1JKuPT6EppilRXQqM,680
 SURE/utils/custom_mlp.py,sha256=Rn_PQouxPMSda-KKBYrwVVv3GFFuUmCLxp8cV5LszZo,10580
 SURE/utils/queue.py,sha256=E_5PA5EWcBoGAZj8BkKQnkCK0p4C-4-xcTPqdIXaPXU,1892
 SURE/utils/utils.py,sha256=IUHjDDtYaAYllCWsZyIzqQwaLul6fJRvHRH4vIYcR-c,8462
-sure_tools-2.4.22.dist-info/licenses/LICENSE,sha256=TFHKwmrAViXQbSX5W-NDItkWFjm45HWOeUniDrqmnu0,1065
-sure_tools-2.4.22.dist-info/METADATA,sha256=W67v_Fs0SOx1tBPZN4-7U1Y6loSUjS697gL_9Q6piC4,2678
-sure_tools-2.4.22.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sure_tools-2.4.22.dist-info/entry_points.txt,sha256=-nJI8rVe_qqrR0HmfAODzj-JNfEqCcSsyVh6okSqyHk,83
-sure_tools-2.4.22.dist-info/top_level.txt,sha256=BtFTebdiJeqra4r6mm-uEtwVRFLZ_IjYsQ7OnalrOvY,5
-sure_tools-2.4.22.dist-info/RECORD,,
+sure_tools-2.4.32.dist-info/licenses/LICENSE,sha256=TFHKwmrAViXQbSX5W-NDItkWFjm45HWOeUniDrqmnu0,1065
+sure_tools-2.4.32.dist-info/METADATA,sha256=9o2WcDEY2JIf1AhclsLePndrjYVexLj9QUHtZjzGc38,2678
+sure_tools-2.4.32.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sure_tools-2.4.32.dist-info/entry_points.txt,sha256=-nJI8rVe_qqrR0HmfAODzj-JNfEqCcSsyVh6okSqyHk,83
+sure_tools-2.4.32.dist-info/top_level.txt,sha256=BtFTebdiJeqra4r6mm-uEtwVRFLZ_IjYsQ7OnalrOvY,5
+sure_tools-2.4.32.dist-info/RECORD,,