SURE-tools 2.1.34__py3-none-any.whl → 2.2.24__py3-none-any.whl

SURE/{PerturbFlow.py → DensityFlow.py}

@@ -54,26 +54,27 @@ def set_random_seed(seed):
     # Set seed for Pyro
     pyro.set_rng_seed(seed)
 
-class PerturbFlow(nn.Module):
+class DensityFlow(nn.Module):
     def __init__(self,
                  input_size: int,
                  codebook_size: int = 200,
                  cell_factor_size: int = 0,
+                 turn_off_cell_specific: bool = False,
                  supervised_mode: bool = False,
                  z_dim: int = 10,
-                 z_dist: Literal['normal','studentt','laplacian','cauchy','gumbel'] = 'normal',
-                 loss_func: Literal['negbinomial','poisson','multinomial','bernoulli'] = 'negbinomial',
+                 z_dist: Literal['normal','studentt','laplacian','cauchy','gumbel'] = 'gumbel',
+                 loss_func: Literal['negbinomial','poisson','multinomial','bernoulli'] = 'multinomial',
                  inverse_dispersion: float = 10.0,
-                 use_zeroinflate: bool = True,
-                 hidden_layers: list = [300],
+                 use_zeroinflate: bool = False,
+                 hidden_layers: list = [500],
                  hidden_layer_activation: Literal['relu','softplus','leakyrelu','linear'] = 'relu',
                  nn_dropout: float = 0.1,
                  post_layer_fct: list = ['layernorm'],
                  post_act_fct: list = None,
                  config_enum: str = 'parallel',
-                 use_cuda: bool = False,
+                 use_cuda: bool = True,
                  seed: int = 42,
-                 zero_bias: bool = True,
+                 zero_bias: bool|list = True,
                  dtype = torch.float32, # type: ignore
                  ):
         super().__init__()
@@ -97,7 +98,12 @@ class PerturbFlow(nn.Module):
         self.post_layer_fct = post_layer_fct
         self.post_act_fct = post_act_fct
         self.hidden_layer_activation = hidden_layer_activation
-        self.use_bias = not zero_bias
+        if type(zero_bias) == list:
+            self.use_bias = [not x for x in zero_bias]
+        else:
+            self.use_bias = [not zero_bias] * self.cell_factor_size
+        #self.use_bias = not zero_bias
+        self.turn_off_cell_specific = turn_off_cell_specific
         
         self.codebook_weights = None
 
@@ -198,38 +204,62 @@ class PerturbFlow(nn.Module):
         if self.cell_factor_size>0:
             self.cell_factor_effect = nn.ModuleList()
             for i in np.arange(self.cell_factor_size):
-                if self.use_bias:
-                    self.cell_factor_effect.append(MLP(
-                        [self.latent_dim+1] + self.decoder_hidden_layers + [self.latent_dim],
-                        activation=activate_fct,
-                        output_activation=None,
-                        post_layer_fct=post_layer_fct,
-                        post_act_fct=post_act_fct,
-                        allow_broadcast=self.allow_broadcast,
-                        use_cuda=self.use_cuda,
+                if self.use_bias[i]:
+                    if self.turn_off_cell_specific:
+                        self.cell_factor_effect.append(MLP(
+                            [1] + self.decoder_hidden_layers + [self.latent_dim],
+                            activation=activate_fct,
+                            output_activation=None,
+                            post_layer_fct=post_layer_fct,
+                            post_act_fct=post_act_fct,
+                            allow_broadcast=self.allow_broadcast,
+                            use_cuda=self.use_cuda,
+                            )
+                        )
+                    else:
+                        self.cell_factor_effect.append(MLP(
+                            [self.latent_dim+1] + self.decoder_hidden_layers + [self.latent_dim],
+                            activation=activate_fct,
+                            output_activation=None,
+                            post_layer_fct=post_layer_fct,
+                            post_act_fct=post_act_fct,
+                            allow_broadcast=self.allow_broadcast,
+                            use_cuda=self.use_cuda,
+                            )
                         )
-                    )
                 else:
-                    self.cell_factor_effect.append(ZeroBiasMLP(
-                        [self.latent_dim+1] + self.decoder_hidden_layers + [self.latent_dim],
-                        activation=activate_fct,
-                        output_activation=None,
-                        post_layer_fct=post_layer_fct,
-                        post_act_fct=post_act_fct,
-                        allow_broadcast=self.allow_broadcast,
-                        use_cuda=self.use_cuda,
+                    if self.turn_off_cell_specific:
+                        self.cell_factor_effect.append(ZeroBiasMLP(
+                            [1] + self.decoder_hidden_layers + [self.latent_dim],
+                            activation=activate_fct,
+                            output_activation=None,
+                            post_layer_fct=post_layer_fct,
+                            post_act_fct=post_act_fct,
+                            allow_broadcast=self.allow_broadcast,
+                            use_cuda=self.use_cuda,
+                            )
+                        )
+                    else:
+                        self.cell_factor_effect.append(ZeroBiasMLP(
+                            [self.latent_dim+1] + self.decoder_hidden_layers + [self.latent_dim],
+                            activation=activate_fct,
+                            output_activation=None,
+                            post_layer_fct=post_layer_fct,
+                            post_act_fct=post_act_fct,
+                            allow_broadcast=self.allow_broadcast,
+                            use_cuda=self.use_cuda,
+                            )
                         )
-                    )
             
         self.decoder_concentrate = MLP(
-                [self.latent_dim] + self.decoder_hidden_layers + [self.input_size],
-                activation=activate_fct,
-                output_activation=None,
-                post_layer_fct=post_layer_fct,
-                post_act_fct=post_act_fct,
-                allow_broadcast=self.allow_broadcast,
-                use_cuda=self.use_cuda,
-            )
+                    [self.latent_dim] + self.decoder_hidden_layers + [self.input_size],
+                    activation=activate_fct,
+                    output_activation=None,
+                    post_layer_fct=post_layer_fct,
+                    post_act_fct=post_act_fct,
+                    allow_broadcast=self.allow_broadcast,
+                    use_cuda=self.use_cuda,
+                )
 
         if self.latent_dist == 'studentt':
             self.codebook = MLP(
@@ -304,7 +334,7 @@ class PerturbFlow(nn.Module):
         return xs
 
     def model1(self, xs):
-        pyro.module('PerturbFlow', self)
+        pyro.module('DensityFlow', self)
 
         eps = torch.finfo(xs.dtype).eps
         batch_size = xs.size(0)
@@ -318,7 +348,7 @@ class PerturbFlow(nn.Module):
             gate_logits = pyro.param("dropout_rate", xs.new_zeros(self.input_size))
             
         acs_scale = pyro.param("codebook_scale", xs.new_ones(self.latent_dim), constraint=constraints.positive)
-
+        
         I = torch.eye(self.code_size)
         if self.latent_dist=='studentt':
             acs_dof,acs_loc = self.codebook(I)
@@ -347,12 +377,13 @@ class PerturbFlow(nn.Module):
 
             zs = zns
             concentrate = self.decoder_concentrate(zs)
-            if self.loss_func == 'bernoulli':
+            if self.loss_func in ['bernoulli']:
                 log_theta = concentrate
             else:
                 rate = concentrate.exp()
-                if self.loss_func != 'poisson':
-                    theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                if self.loss_func == 'poisson':
+                    rate = theta * torch.sum(xs, dim=1, keepdim=True)
 
             if self.loss_func == 'negbinomial':
                 if self.use_zeroinflate:
@@ -374,14 +405,15 @@ class PerturbFlow(nn.Module):
 
     def guide1(self, xs):
         with pyro.plate('data'):
-            zn_loc, zn_scale = self.encoder_zn(xs)
+            #zn_loc, zn_scale = self.encoder_zn(xs)
+            zn_loc, zn_scale = self._get_basal_embedding(xs)
             zns = pyro.sample('zn', dist.Normal(zn_loc, zn_scale).to_event(1))
 
             alpha = self.encoder_n(zns)
             ns = pyro.sample('n', dist.OneHotCategorical(logits=alpha))
 
     def model2(self, xs, us=None):
-        pyro.module('PerturbFlow', self)
+        pyro.module('DensityFlow', self)
 
         eps = torch.finfo(xs.dtype).eps
         batch_size = xs.size(0)
@@ -423,23 +455,19 @@ class PerturbFlow(nn.Module):
                 zns = pyro.sample('zn', dist.Gumbel(zn_loc, zn_scale).to_event(1))
 
             if self.cell_factor_size>0:
-                zus = None
-                for i in np.arange(self.cell_factor_size):
-                    if i==0:
-                        zus = self.cell_factor_effect[i]([zns,us[:,i].reshape(-1,1)])
-                    else:
-                        zus = zus + self.cell_factor_effect[i]([zns,us[:,i].reshape(-1,1)])
+                zus = self._total_effects(zns, us)
                 zs = zns+zus
             else:
                 zs = zns
 
             concentrate = self.decoder_concentrate(zs)
-            if self.loss_func == 'bernoulli':
+            if self.loss_func in ['bernoulli']:
                 log_theta = concentrate
             else:
                 rate = concentrate.exp()
-                if self.loss_func != 'poisson':
-                    theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                if self.loss_func == 'poisson':
+                    rate = theta * torch.sum(xs, dim=1, keepdim=True)
 
             if self.loss_func == 'negbinomial':
                 if self.use_zeroinflate:
@@ -461,14 +489,15 @@ class PerturbFlow(nn.Module):
 
     def guide2(self, xs, us=None):
         with pyro.plate('data'):
-            zn_loc, zn_scale = self.encoder_zn(xs)
+            #zn_loc, zn_scale = self.encoder_zn(xs)
+            zn_loc, zn_scale = self._get_basal_embedding(xs)
             zns = pyro.sample('zn', dist.Normal(zn_loc, zn_scale).to_event(1))
 
             alpha = self.encoder_n(zns)
             ns = pyro.sample('n', dist.OneHotCategorical(logits=alpha))
 
     def model3(self, xs, ys, embeds=None):
-        pyro.module('PerturbFlow', self)
+        pyro.module('DensityFlow', self)
 
         eps = torch.finfo(xs.dtype).eps
         batch_size = xs.size(0)
@@ -528,12 +557,13 @@ class PerturbFlow(nn.Module):
             zs = zns
 
             concentrate = self.decoder_concentrate(zs)
-            if self.loss_func == 'bernoulli':
+            if self.loss_func in ['bernoulli']:
                 log_theta = concentrate
             else:
                 rate = concentrate.exp()
-                if self.loss_func != 'poisson':
-                    theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                if self.loss_func == 'poisson':
+                    rate = theta * torch.sum(xs, dim=1, keepdim=True)
 
             if self.loss_func == 'negbinomial':
                 if self.use_zeroinflate:
@@ -556,11 +586,14 @@ class PerturbFlow(nn.Module):
     def guide3(self, xs, ys, embeds=None):
         with pyro.plate('data'):
             if embeds is None:
-                zn_loc, zn_scale = self.encoder_zn(xs)
+                #zn_loc, zn_scale = self.encoder_zn(xs)
+                zn_loc, zn_scale = self._get_basal_embedding(xs)
                 zns = pyro.sample('zn', dist.Normal(zn_loc, zn_scale).to_event(1))
+            else:
+                zns = embeds
 
     def model4(self, xs, us, ys, embeds=None):
-        pyro.module('PerturbFlow', self)
+        pyro.module('DensityFlow', self)
 
         eps = torch.finfo(xs.dtype).eps
         batch_size = xs.size(0)
@@ -618,23 +651,25 @@ class PerturbFlow(nn.Module):
                     zns = pyro.sample('zn', dist.Gumbel(zn_loc, zn_scale).to_event(1), obs=embeds)
 
             if self.cell_factor_size>0:
-                zus = None
-                for i in np.arange(self.cell_factor_size):
-                    if i==0:
-                        zus = self.cell_factor_effect[i]([zns,us[:,i].reshape(-1,1)])
-                    else:
-                        zus = zus + self.cell_factor_effect[i]([zns,us[:,i].reshape(-1,1)])
+                #zus = None
+                #for i in np.arange(self.cell_factor_size):
+                #    if i==0:
+                #        zus = self.cell_factor_effect[i]([zns,us[:,i].reshape(-1,1)])
+                #    else:
+                #        zus = zus + self.cell_factor_effect[i]([zns,us[:,i].reshape(-1,1)])
+                zus = self._total_effects(zns, us)
                 zs = zns+zus
             else:
                 zs = zns
 
             concentrate = self.decoder_concentrate(zs)
-            if self.loss_func == 'bernoulli':
+            if self.loss_func in ['bernoulli']:
                 log_theta = concentrate
             else:
                 rate = concentrate.exp()
-                if self.loss_func != 'poisson':
-                    theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                if self.loss_func == 'poisson':
+                    rate = theta * torch.sum(xs, dim=1, keepdim=True)
 
             if self.loss_func == 'negbinomial':
                 if self.use_zeroinflate:
@@ -657,9 +692,32 @@ class PerturbFlow(nn.Module):
     def guide4(self, xs, us, ys, embeds=None):
         with pyro.plate('data'):
             if embeds is None:
-                zn_loc, zn_scale = self.encoder_zn(xs)
+                #zn_loc, zn_scale = self.encoder_zn(xs)
+                zn_loc, zn_scale = self._get_basal_embedding(xs)
                 zns = pyro.sample('zn', dist.Normal(zn_loc, zn_scale).to_event(1))
-
+            else:
+                zns = embeds
+
+    def _total_effects(self, zns, us):
+        zus = None
+        for i in np.arange(self.cell_factor_size):
+            if i==0:
+                #if self.turn_off_cell_specific:
+                #    zus = self.cell_factor_effect[i](us[:,i].reshape(-1,1))
+                #else:
+                #    zus = self.cell_factor_effect[i]([zns,us[:,i].reshape(-1,1)])
+                zus = self._cell_response(zns, i, us[:,i].reshape(-1,1))
+            else:
+                #if self.turn_off_cell_specific:
+                #    zus = zus + self.cell_factor_effect[i](us[:,i].reshape(-1,1))
+                #else:
+                #    zus = zus + self.cell_factor_effect[i]([zns,us[:,i].reshape(-1,1)])
+                zus = zus + self._cell_response(zns, i, us[:,i].reshape(-1,1))
+        return zus
+                        
+    def _get_codebook_identity(self):
+        return torch.eye(self.code_size, **self.options)
+    
     def _get_codebook(self):
         I = torch.eye(self.code_size, **self.options)
         if self.latent_dist=='studentt':
@@ -672,13 +730,13 @@ class PerturbFlow(nn.Module):
         """
         Return the mean part of metacell codebook
         """
-        cb = self._get_metacell_coordinates()
+        cb = self._get_codebook()
         cb = tensor_to_numpy(cb)
         return cb
 
     def _get_basal_embedding(self, xs):           
-        zns, _ = self.encoder_zn(xs)
-        return zns 
+        loc, scale = self.encoder_zn(xs)
+        return loc, scale 
     
     def get_basal_embedding(self, 
                              xs, 
@@ -705,7 +763,7 @@ class PerturbFlow(nn.Module):
         Z = []
         with tqdm(total=len(dataloader), desc='', unit='batch') as pbar:
             for X_batch, _ in dataloader:
-                zns = self._get_basal_embedding(X_batch)
+                zns,_ = self._get_basal_embedding(X_batch)
                 Z.append(tensor_to_numpy(zns))
                 pbar.update(1)
 
@@ -716,7 +774,8 @@ class PerturbFlow(nn.Module):
         if self.supervised_mode:
             alpha = self.encoder_n(xs)
         else:
-            zns,_ = self.encoder_zn(xs)
+            #zns,_ = self.encoder_zn(xs)
+            zns,_ = self._get_basal_embedding(xs)
             alpha = self.encoder_n(zns)
         return alpha
     
@@ -785,46 +844,80 @@ class PerturbFlow(nn.Module):
         A = np.concatenate(A)
         return A
     
-    def _cell_response(self, xs, factor_idx, perturb):
-        zns,_ = self.encoder_zn(xs)       
+    def predict(self, xs, us, perturbs_predict:list, perturbs_reference:list, library_sizes=None):
+        perturbs_reference = np.array(perturbs_reference)
+        
+        # basal embedding
+        zs = self.get_basal_embedding(xs)
+        for pert in perturbs_predict:
+            pert_idx = int(np.where(perturbs_reference==pert)[0])
+            us_i = us[:,pert_idx].reshape(-1,1)
+            
+            # factor effect of xs 
+            dzs0 = self.get_cell_response(zs, perturb_idx=pert_idx, perturb_us=us_i)
+            
+            # perturbation effect 
+            ps = np.ones_like(us_i)
+            if np.sum(np.abs(ps-us_i))>=1:
+                dzs = self.get_cell_response(zs, perturb_idx=pert_idx, perturb_us=ps)          
+                zs = zs + dzs0 + dzs
+            else:
+                zs = zs + dzs0
+        
+        if library_sizes is None:
+            library_sizes = np.sum(xs, axis=1, keepdims=True)
+        elif type(library_sizes) == list:
+            library_sizes = np.array(library_sizes)
+            library_sizes = library_sizes.reshape(-1,1)
+        elif len(library_sizes.shape)==1:
+            library_sizes = library_sizes.reshape(-1,1)
+            
+        counts = self.get_counts(zs, library_sizes=library_sizes)
+        
+        return counts, zs
+    
+    def _cell_response(self, zs, perturb_idx, perturb):
+        #zns,_ = self.encoder_zn(xs)    
+        #zns,_ = self._get_basal_embedding(xs)   
+        zns = zs
         if perturb.ndim==2:
-            ms = self.cell_factor_effect[factor_idx]([zns, perturb])
+            if self.turn_off_cell_specific:
+                ms = self.cell_factor_effect[perturb_idx](perturb)
+            else:
+                ms = self.cell_factor_effect[perturb_idx]([zns, perturb])
         else:
-            ms = self.cell_factor_effect[factor_idx]([zns, perturb.reshape(-1,1)])
+            if self.turn_off_cell_specific:
+                ms = self.cell_factor_effect[perturb_idx](perturb.reshape(-1,1))
+            else:
+                ms = self.cell_factor_effect[perturb_idx]([zns, perturb.reshape(-1,1)])
             
         return ms 
 
     def get_cell_response(self, 
-                             xs, 
-                             factor_idx,
-                             perturb,
+                             zs, 
+                             perturb_idx,
+                             perturb_us,
                              batch_size: int = 1024):
         """
         Return cells' changes in the latent space induced by specific perturbation of a factor
 
         """
-        xs = self.preprocess(xs)
-        xs = convert_to_tensor(xs, device=self.get_device())
-        ps = convert_to_tensor(perturb, device=self.get_device())
-        dataset = CustomDataset2(xs,ps)
+        #xs = self.preprocess(xs)
+        zs = convert_to_tensor(zs, device=self.get_device())
+        ps = convert_to_tensor(perturb_us, device=self.get_device())
+        dataset = CustomDataset2(zs,ps)
         dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False)
 
         Z = []
         with tqdm(total=len(dataloader), desc='', unit='batch') as pbar:
-            for X_batch, P_batch, _ in dataloader:
-                zns = self._cell_response(X_batch, factor_idx, P_batch)
+            for Z_batch, P_batch, _ in dataloader:
+                zns = self._cell_response(Z_batch, perturb_idx, P_batch)
                 Z.append(tensor_to_numpy(zns))
                 pbar.update(1)
 
         Z = np.concatenate(Z)
         return Z
     
-    def get_metacell_response(self, factor_idx, perturb):
-        zs = self._get_codebook()
-        ps = convert_to_tensor(perturb, device=self.get_device())         
-        ms = self.cell_factor_effect[factor_idx]([zs,ps])
-        return tensor_to_numpy(ms)
-    
     def _get_expression_response(self, delta_zs):
         return self.decoder_concentrate(delta_zs)
     
@@ -849,38 +942,35 @@ class PerturbFlow(nn.Module):
         R = np.concatenate(R)
         return R
     
-    def _count(self,concentrate):
-        if self.loss_func == 'bernoulli':
-            counts = self.sigmoid(concentrate)
-        else:
-            counts = concentrate.exp()
-        return counts
-    
-    def _count_sample(self,concentrate):
+    def _count(self, concentrate, library_size=None):
         if self.loss_func == 'bernoulli':
-            logits = concentrate
-            counts = dist.Bernoulli(logits=logits).to_event(1).sample()
+            #counts = self.sigmoid(concentrate)
+            counts = dist.Bernoulli(logits=concentrate).to_event(1).mean
         else:
-            counts = self._count(concentrate=concentrate)
-            counts = dist.Poisson(rate=counts).to_event(1).sample()
+            rate = concentrate.exp()
+            theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+            counts = theta * library_size
         return counts
     
-    def get_counts(self, zs, 
-                        batch_size: int = 1024, 
-                        use_sampler: bool = False):
+    def get_counts(self, zs, library_sizes,
+                        batch_size: int = 1024):
 
         zs = convert_to_tensor(zs, device=self.get_device())
-        dataset = CustomDataset(zs)
+        
+        if type(library_sizes) == list:
+            library_sizes = np.array(library_sizes).reshape(-1,1)
+        elif len(library_sizes.shape)==1:
+            library_sizes = library_sizes.reshape(-1,1)
+        ls = convert_to_tensor(library_sizes, device=self.get_device())
+            
+        dataset = CustomDataset2(zs,ls)
         dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False)
         
         E = []
         with tqdm(total=len(dataloader), desc='', unit='batch') as pbar:
-            for Z_batch, _ in dataloader:
-                concentrate = self._expression(Z_batch)
-                if use_sampler:
-                    counts = self._count_sample(concentrate)
-                else:
-                    counts = self._count(concentrate)
+            for Z_batch, L_batch, _ in dataloader:
+                concentrate = self._get_expression_response(Z_batch)
+                counts = self._count(concentrate, L_batch)
                 E.append(tensor_to_numpy(counts))
                 pbar.update(1)
         
@@ -903,7 +993,7 @@ class PerturbFlow(nn.Module):
             us = None, 
             ys = None,
             zs = None,
-            num_epochs: int = 200, 
+            num_epochs: int = 500, 
             learning_rate: float = 0.0001, 
             batch_size: int = 256, 
             algo: Literal['adam','rmsprop','adamw'] = 'adam', 
@@ -912,9 +1002,9 @@ class PerturbFlow(nn.Module):
             decay_rate: float = 0.9,
             config_enum: str = 'parallel',
             threshold: int = 0,
-            use_jax: bool = False):
+            use_jax: bool = True):
         """
-        Train the PerturbFlow model.
+        Train the DensityFlow model.
 
         Parameters
         ----------
@@ -940,7 +1030,7 @@ class PerturbFlow(nn.Module):
             Parameter for optimization.
         use_jax
             If toggled on, Jax will be used for speeding up. CAUTION: This will raise errors because of unknown reasons when it is called in
-            the Python script or Jupyter notebook. It is OK if it is used when runing PerturbFlow in the shell command.
+            the Python script or Jupyter notebook. It is OK if it is used when runing DensityFlow in the shell command.
         """
         xs = self.preprocess(xs, threshold=threshold)
         xs = convert_to_tensor(xs, dtype=self.dtype, device=self.get_device())
@@ -1025,7 +1115,7 @@ class PerturbFlow(nn.Module):
                 # Update progress bar
                 pbar.set_postfix({'loss': str_loss})
                 pbar.update(1)
-
+                
     @classmethod
     def save_model(cls, model, file_path, compression=False):
         """Save the model to the specified file path."""
@@ -1058,12 +1148,12 @@ class PerturbFlow(nn.Module):
 
         
 EXAMPLE_RUN = (
-    "example run: PerturbFlow --help"
+    "example run: DensityFlow --help"
 )
 
 def parse_args():
     parser = argparse.ArgumentParser(
-        description="PerturbFlow\n{}".format(EXAMPLE_RUN))
+        description="DensityFlow\n{}".format(EXAMPLE_RUN))
 
     parser.add_argument(
         "--cuda", action="store_true", help="use GPU(s) to speed up training"
@@ -1250,7 +1340,7 @@ def main():
     cell_factor_size = 0 if us is None else us.shape[1]
 
     ###########################################
-    perturbflow = PerturbFlow(
+    DensityFlow = DensityFlow(
         input_size=input_size,
         cell_factor_size=cell_factor_size,
         inverse_dispersion=args.inverse_dispersion,
@@ -1269,7 +1359,7 @@ def main():
         dtype=dtype,
     )
 
-    perturbflow.fit(xs, us=us, 
+    DensityFlow.fit(xs, us=us, 
              num_epochs=args.num_epochs,
              learning_rate=args.learning_rate,
              batch_size=args.batch_size,
@@ -1281,12 +1371,11 @@ def main():
 
     if args.save_model is not None:
         if args.save_model.endswith('gz'):
-            PerturbFlow.save_model(perturbflow, args.save_model, compression=True)
+            DensityFlow.save_model(DensityFlow, args.save_model, compression=True)
         else:
-            PerturbFlow.save_model(perturbflow, args.save_model)
+            DensityFlow.save_model(DensityFlow, args.save_model)
     
 
 
 if __name__ == "__main__":
-
     main()

SURE/SURE.py

@@ -99,19 +99,18 @@ class SURE(nn.Module):
                  cell_factor_size: int = 0,
                  supervised_mode: bool = False,
                  z_dim: int = 10,
-                 z_dist: Literal['normal','studentt','laplacian','cauchy','gumbel'] = 'normal',
-                 loss_func: Literal['negbinomial','poisson','multinomial','bernoulli'] = 'negbinomial',
+                 z_dist: Literal['normal','studentt','laplacian','cauchy','gumbel'] = 'gumbel',
+                 loss_func: Literal['negbinomial','poisson','multinomial','bernoulli'] = 'poisson',
                  inverse_dispersion: float = 10.0,
                  use_zeroinflate: bool = True,
-                 hidden_layers: list = [300],
+                 hidden_layers: list = [500],
                  hidden_layer_activation: Literal['relu','softplus','leakyrelu','linear'] = 'relu',
                  nn_dropout: float = 0.1,
                  post_layer_fct: list = ['layernorm'],
                  post_act_fct: list = None,
                  config_enum: str = 'parallel',
-                 use_cuda: bool = False,
+                 use_cuda: bool = True,
                  seed: int = 42,
-                 zero_bias: bool = True,
                  dtype = torch.float32, # type: ignore
                  ):
         super().__init__()
@@ -135,7 +134,6 @@ class SURE(nn.Module):
         self.post_layer_fct = post_layer_fct
         self.post_act_fct = post_act_fct
         self.hidden_layer_activation = hidden_layer_activation
-        self.use_bias = not zero_bias
         
         self.codebook_weights = None
 
@@ -234,26 +232,16 @@ class SURE(nn.Module):
         )
 
         if self.cell_factor_size>0:
-            if self.use_bias:
-                self.cell_factor_effect = MLP(
-                    [self.latent_dim + self.cell_factor_size] + self.decoder_hidden_layers + [self.latent_dim],
-                    activation=activate_fct,
-                    output_activation=None,
-                    post_layer_fct=post_layer_fct,
-                    post_act_fct=post_act_fct,
-                    allow_broadcast=self.allow_broadcast,
-                    use_cuda=self.use_cuda,
-                )
-            else:
-                self.cell_factor_effect = ZeroBiasMLP(
-                    [self.latent_dim + self.cell_factor_size] + self.decoder_hidden_layers + [self.latent_dim],
-                    activation=activate_fct,
-                    output_activation=None,
-                    post_layer_fct=post_layer_fct,
-                    post_act_fct=post_act_fct,
-                    allow_broadcast=self.allow_broadcast,
-                    use_cuda=self.use_cuda,
-                )
+            self.cell_factor_effect = MLP(
+                [self.latent_dim + self.cell_factor_size] + self.decoder_hidden_layers + [self.latent_dim],
+                activation=activate_fct,
+                output_activation=None,
+                post_layer_fct=post_layer_fct,
+                post_act_fct=post_act_fct,
+                allow_broadcast=self.allow_broadcast,
+                use_cuda=self.use_cuda,
+            )
+
             
         self.decoder_concentrate = MLP(
                 [self.latent_dim] + self.decoder_hidden_layers + [self.input_size],
@@ -381,12 +369,13 @@ class SURE(nn.Module):
 
             zs = zns
             concentrate = self.decoder_concentrate(zs)
-            if self.loss_func == 'bernoulli':
+            if self.loss_func in ['bernoulli']:
                 log_theta = concentrate
             else:
                 rate = concentrate.exp()
-                if self.loss_func != 'poisson':
-                    theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                if self.loss_func == 'poisson':
+                    rate = theta * torch.sum(xs, dim=1, keepdim=True)
 
             if self.loss_func == 'negbinomial':
                 if self.use_zeroinflate:
@@ -463,12 +452,13 @@ class SURE(nn.Module):
                 zs = zns
 
             concentrate = self.decoder_concentrate(zs)
-            if self.loss_func == 'bernoulli':
+            if self.loss_func in ['bernoulli']:
                 log_theta = concentrate
             else:
                 rate = concentrate.exp()
-                if self.loss_func != 'poisson':
-                    theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                if self.loss_func == 'poisson':
+                    rate = theta * torch.sum(xs, dim=1, keepdim=True)
 
             if self.loss_func == 'negbinomial':
                 if self.use_zeroinflate:
@@ -557,12 +547,13 @@ class SURE(nn.Module):
             zs = zns
 
             concentrate = self.decoder_concentrate(zs)
-            if self.loss_func == 'bernoulli':
+            if self.loss_func in ['bernoulli']:
                 log_theta = concentrate
             else:
                 rate = concentrate.exp()
-                if self.loss_func != 'poisson':
-                    theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                if self.loss_func == 'poisson':
+                    rate = theta * torch.sum(xs, dim=1, keepdim=True)
 
             if self.loss_func == 'negbinomial':
                 if self.use_zeroinflate:
@@ -653,13 +644,14 @@ class SURE(nn.Module):
                 zs = zns
 
             concentrate = self.decoder_concentrate(zs)
-            if self.loss_func == 'bernoulli':
+            if self.loss_func in ['bernoulli']:
                 log_theta = concentrate
             else:
                 rate = concentrate.exp()
-                if self.loss_func != 'poisson':
-                    theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
-
+                theta = dist.DirichletMultinomial(total_count=1, concentration=rate).mean
+                if self.loss_func == 'poisson':
+                    rate = theta * torch.sum(xs, dim=1, keepdim=True)
+                    
             if self.loss_func == 'negbinomial':
                 if self.use_zeroinflate:
                     pyro.sample('x', dist.ZeroInflatedDistribution(dist.NegativeBinomial(total_count=total_count, probs=theta),gate_logits=gate_logits).to_event(1), obs=xs)
@@ -825,7 +817,7 @@ class SURE(nn.Module):
             us = None, 
             ys = None,
             zs = None,
-            num_epochs: int = 200, 
+            num_epochs: int = 500, 
             learning_rate: float = 0.0001, 
             batch_size: int = 256, 
             algo: Literal['adam','rmsprop','adamw'] = 'adam', 
@@ -834,7 +826,7 @@ class SURE(nn.Module):
             decay_rate: float = 0.9,
             config_enum: str = 'parallel',
             threshold: int = 0,
-            use_jax: bool = False):
+            use_jax: bool = True):
         """
         Train the SURE model.
 

SURE/__init__.py

@@ -1,12 +1,12 @@
 from .SURE import SURE
-from .PerturbFlow import PerturbFlow
+from .DensityFlow import DensityFlow
 
 from . import utils 
 from . import codebook
 from . import SURE
-from . import PerturbFlow
+from . import DensityFlow
 from . import atac
 from . import flow 
 from . import perturb
 
-__all__ = ['SURE', 'PerturbFlow', 'flow', 'perturb', 'atac', 'utils', 'codebook']
+__all__ = ['SURE', 'DensityFlow', 'flow', 'perturb', 'atac', 'utils', 'codebook']

SURE/flow/flow_stats.py

@@ -1,4 +1,5 @@
 import numpy as np
+from scipy.interpolate import griddata
 from scipy.spatial.distance import pdist, squareform
 from sklearn.decomposition import PCA
 from scipy.stats import pearsonr
@@ -16,6 +17,42 @@ class VectorFieldEval:
         
     def momentum_flow_metric(self, vectors, masses=None):
         return momentum_flow_metric(vectors=vectors, masses=masses)
+    
+    def divergence(self, points, vectors, grid_resolution=30):
+        # 提取坐标和向量分量
+        x_coords = points[:, 0]
+        y_coords = points[:, 1]
+        u_components = vectors[:, 0]  # x方向分量
+        v_components = vectors[:, 1]  # y方向分量
+    
+        # 创建规则网格
+        x_grid = np.linspace(x_coords.min(), x_coords.max(), grid_resolution)
+        y_grid = np.linspace(y_coords.min(), y_coords.max(), grid_resolution)
+        X, Y = np.meshgrid(x_grid, y_grid)
+    
+        # 插值到网格
+        U_grid = griddata((x_coords, y_coords), u_components, (X, Y), method='linear')
+        V_grid = griddata((x_coords, y_coords), v_components, (X, Y), method='linear')
+    
+        # 计算散度
+        dU_dx = np.gradient(U_grid, x_grid, axis=1)
+        dV_dy = np.gradient(V_grid, y_grid, axis=0)
+        divergence = dU_dx + dV_dy
+        divergence[np.isnan(divergence)] = 0
+        
+        return divergence
+    
+    def movement_stats(self,vectors):
+        return calculate_movement_stats(vectors)
+    
+    def direction_stats(self, vectors):
+        return calculate_direction_stats(vectors)
+    
+    def movement_energy(self, vectors, masses=None):
+        return calculate_movement_energy(vectors, masses)
+    
+    def movement_divergence(self, positions, vectors):
+        return calculate_movement_divergence(positions, vectors)
 
         
 def calculate_movement_stats(vectors):

SURE/perturb/__init__.py

@@ -1 +1 @@
-from .perturb import LabelMatrix
+from .perturb import LabelMatrix,DoseMatrix

SURE/perturb/perturb.py

@@ -1,5 +1,7 @@
 import re
 import numpy as np
+import pandas as pd
+from numba import njit
 from itertools import chain
 from joblib import Parallel, delayed
 from typing import Literal
@@ -7,8 +9,10 @@ from typing import Literal
 class LabelMatrix:
     def __init__(self):
         self.labels_ = None
+        self.control_label = None 
+        self.sep_pattern = None
     
-    def fit_transform(self, labels, sep_pattern=r'[;_\-\s]', speedup: Literal['none','vectorize','parallel']='none'):
+    def fit_transform(self, labels, control_label=None, sep_pattern=r'[,;_\s]', speedup: Literal['none','vectorize','parallel']='none'):
         if speedup=='none':
             mat, self.labels_ = label_to_matrix(labels=labels, sep_pattern=sep_pattern)
         elif speedup=='vectorize':
@@ -17,10 +21,53 @@ class LabelMatrix:
             mat, self.labels_ = parallel_label_to_matrix(labels=labels, sep_pattern=sep_pattern)
             
         self.labels_ = np.array(self.labels_)
-        return mat
+        
+        if control_label is not None:
+            idx = np.where(self.labels_==control_label)[0]
+            mat = np.delete(mat, idx, axis=1)
+            self.labels_ = np.delete(self.labels_, idx)
             
+        self.control_label = control_label
+        self.sep_pattern=sep_pattern
+        
+        return mat
+    
+    def transform(self, labels, speedup: Literal['none','vectorize','parallel']='none'):
+        sep_pattern = self.sep_pattern
+        if speedup=='none':
+            mat, labels_ = label_to_matrix(labels=labels, sep_pattern=sep_pattern)
+        elif speedup=='vectorize':
+            mat, labels_ = vectorized_label_to_matrix(labels=labels, sep_pattern=sep_pattern)
+        elif speedup=='parallel':
+            mat, labels_ = parallel_label_to_matrix(labels=labels, sep_pattern=sep_pattern)
+          
+        mat_df = pd.DataFrame(mat, columns=labels_)
+        
+        labels_valid = [x for x in labels_ if x in self.labels_]  
+        mat_df = mat_df[labels_valid]
+        
+        mat_valid = np.zeros([mat.shape[0], len(self.labels_)])
+        mat_valid_df = pd.DataFrame(mat_valid, columns=self.labels_)
+        mat_valid_df[labels_valid] = mat_df 
+        
+        return mat_valid_df.values
+        
     def inverse_transform(self, matrix):
         return matrix_to_labels(matrix=matrix, unique_labels=self.labels_)
+
+class DoseMatrix:
+    def __init__(self):
+        self.labels_ = None 
+        
+    def fit_transform(self, labels, label_dose, control_label=None):
+        mat, self.labels_ = dose_to_matrix(labels, label_dose)
+        
+        if control_label is not None:
+            idx = np.where(self.labels_==control_label)[0]
+            mat = np.delete(mat, idx, axis=1)
+            self.labels_ = np.delete(self.labels_, idx)
+            
+        return mat 
         
 def label_to_matrix(labels, sep_pattern=r'[;_\-\s]'):
     """
@@ -85,3 +132,38 @@ def parallel_label_to_matrix(labels, sep_pattern=r'[;_\-\s]', n_jobs=4):
 def matrix_to_labels(matrix, unique_labels):
     return [';'.join([unique_labels[i] for i in np.where(row)[0]]) 
             for row in matrix]
+
+
+
+
+
+
+
+@njit(parallel=True)
+def _numba_fill_matrix(dose_matrix, label_indices, label_doses):
+    """Numba 加速的矩阵填充函数"""
+    for i in range(len(label_indices)):
+        dose_matrix[i, label_indices[i]] = label_doses[i]
+
+def dose_to_matrix(labels, label_dose, all_labels=None):
+    """
+    使用 Numba 的终极加速版本（需预先安装 numba）
+    """
+    if all_labels is None:
+        all_labels = sorted(set().union(labels))
+    
+    label_to_idx = {label: idx for idx, label in enumerate(all_labels)}
+    n_samples = len(labels)
+    n_labels = len(all_labels)
+    dose_matrix = np.zeros((n_samples, n_labels), dtype=np.float64)
+    
+    # 预处理为 Numba 兼容格式
+    label_indices = []
+    label_doses = []
+    for i, label in enumerate(labels):
+        label_indices.append(label_to_idx[label])
+        label_doses.append(label_dose[i])
+    
+    # 调用 Numba 加速函数
+    _numba_fill_matrix(dose_matrix, label_indices, label_doses)
+    return dose_matrix,np.array(all_labels)

SURE/utils/__init__.py

@@ -7,7 +7,7 @@ from .utils import find_partitions_greedy
 
 from .queue import PriorityQueue
 
-from .custom_mlp import MLP, Exp, ZeroBiasMLP
+from .custom_mlp import MLP, Exp, ZeroBiasMLP, HDMLP
 
 # Importing modules
 #from . import utils

SURE/utils/custom_mlp.py

@@ -239,6 +239,43 @@ class ZeroBiasMLP(nn.Module):
     def forward(self, x):
         y = self.mlp(x)
         mask = torch.zeros_like(y)
-        mask[x[1][:,0]>0,:] = 1
+        if len(y.shape)==2:
+            mask[x[1][:,0]>0,:] = 1
+        elif len(y.shape)==3:
+            mask[:,x[1][:,0]>0,:] = 1
         return y*mask
-        
+        
+
+class HDMLP(nn.Module):
+    def __init__(
+        self,
+        input_size,
+        hidden_sizes,
+        output_depth,
+        activation=nn.ReLU,
+        output_activation=None,
+        post_layer_fct=lambda layer_ix, total_layers, layer: None,
+        post_act_fct=lambda layer_ix, total_layers, layer: None,
+        allow_broadcast=False,
+        use_cuda=False,
+    ):
+        # init the module object
+        super().__init__()
+        self.mlp = MLP(mlp_sizes=[1] + hidden_sizes + [output_depth],
+                       activation=activation,
+                       output_activation=output_activation,
+                       post_layer_fct=post_layer_fct,
+                       post_act_fct=post_act_fct,
+                       allow_broadcast=allow_broadcast,
+                       use_cuda=use_cuda,
+                       bias=True)
+        self.input_size=input_size
+        self.output_depth=output_depth
+        
+    # pass through our sequential for the output!
+    def forward(self, x):
+        batch_size, n = x.shape
+        x = x.view(batch_size * n, 1)
+        out = self.mlp(x)
+        out = out.view(batch_size, n, self.output_depth)
+        return out

{sure_tools-2.1.34.dist-info → sure_tools-2.2.24.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: SURE-tools
-Version: 2.1.34
+Version: 2.2.24
 Summary: Succinct Representation of Single Cells
 Home-page: https://github.com/ZengFLab/SURE
 Author: Feng Zeng
@@ -20,6 +20,7 @@ Requires-Dist: numpy
 Requires-Dist: scikit-learn
 Requires-Dist: pandas
 Requires-Dist: pyro-ppl
+Requires-Dist: jax[cuda12]
 Requires-Dist: leidenalg
 Requires-Dist: python-igraph
 Requires-Dist: networkx

sure_tools-2.2.24.dist-info/RECORD

@@ -0,0 +1,25 @@
+SURE/DensityFlow.py,sha256=IpObVzq3pb2GAYt8f0rCkR8d9YdsRg1RwPruvNKHoHM,56132
+SURE/SURE.py,sha256=MXs7iuvcj-lU4dJ_MwKegpL2Rqk2HB4eFfAgHRA3RtA,47744
+SURE/__init__.py,sha256=NVp22RCHrhSwHNMomABC-eftoCYvt7vV1XOzim-UZHE,293
+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
+SURE/atac/__init__.py,sha256=3smP8IKHfwNCd1G_sZH3pKHXuLkLpFuLtjUTUSy7_As,34
+SURE/atac/utils.py,sha256=m4NYwpy9O5T1pXTzgCOCcmlwrC6GTi-cQ5sm2wZu2O8,4354
+SURE/codebook/__init__.py,sha256=2T5gjp8JIaBayrXAnOJYSebQHsWprOs87difpR1OPNw,243
+SURE/codebook/codebook.py,sha256=ZlN6gRX9Gj2D2u3P5KeOsbZri0MoMAiJo9lNeL-MK-I,17117
+SURE/flow/__init__.py,sha256=rsAjYsh1xVIrxBCuwOE0Q_6N5th1wBgjJceV0ABPG3c,183
+SURE/flow/flow_stats.py,sha256=6SzNMT59WRFRP1nC6bvpBPF7BugWnkIS_DSlr4S-Ez0,11338
+SURE/flow/plot_quiver.py,sha256=UbmuScUcgbQHeMmjKmgqxjrIjHhiHx0VWct16UMMwuE,8110
+SURE/perturb/__init__.py,sha256=8TP1dSUhXiZzKpFebHZmm8XMMGbUz_OfQ10xu-6uPPY,43
+SURE/perturb/perturb.py,sha256=ey7cxsM1tO1MW4UaE_MLpLHK87CjvXzn2CBPtvv1VZ0,6116
+SURE/utils/__init__.py,sha256=YF5jB-PAHJQ40OlcZ7BCZbsN2q1JKuPT6EppilRXQqM,680
+SURE/utils/custom_mlp.py,sha256=HuNb7f8-6RFjsvfEu1XOuNpLrHZkGYHgf8TpJfPSNO0,9382
+SURE/utils/queue.py,sha256=E_5PA5EWcBoGAZj8BkKQnkCK0p4C-4-xcTPqdIXaPXU,1892
+SURE/utils/utils.py,sha256=IUHjDDtYaAYllCWsZyIzqQwaLul6fJRvHRH4vIYcR-c,8462
+sure_tools-2.2.24.dist-info/licenses/LICENSE,sha256=TFHKwmrAViXQbSX5W-NDItkWFjm45HWOeUniDrqmnu0,1065
+sure_tools-2.2.24.dist-info/METADATA,sha256=oQslRmRo5_NDhapldLCnsck6dXrGEEHj-VAEl4XzWNU,2678
+sure_tools-2.2.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sure_tools-2.2.24.dist-info/entry_points.txt,sha256=-nJI8rVe_qqrR0HmfAODzj-JNfEqCcSsyVh6okSqyHk,83
+sure_tools-2.2.24.dist-info/top_level.txt,sha256=BtFTebdiJeqra4r6mm-uEtwVRFLZ_IjYsQ7OnalrOvY,5
+sure_tools-2.2.24.dist-info/RECORD,,

sure_tools-2.1.34.dist-info/RECORD

@@ -1,25 +0,0 @@
-SURE/PerturbFlow.py,sha256=BoaNDubCKpsYJcwipZxrSCpol4nVvCttP28MizHffzY,51650
-SURE/SURE.py,sha256=ghagk4vO3xrAXwdyYTIv7y0X2KXr1R2baXH8lqvUl7k,48094
-SURE/__init__.py,sha256=NOJI_K-eCqPgStXXvgl3wIEMp6d8saMTDYLJ7Ga9MqE,293
-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
-SURE/atac/__init__.py,sha256=3smP8IKHfwNCd1G_sZH3pKHXuLkLpFuLtjUTUSy7_As,34
-SURE/atac/utils.py,sha256=m4NYwpy9O5T1pXTzgCOCcmlwrC6GTi-cQ5sm2wZu2O8,4354
-SURE/codebook/__init__.py,sha256=2T5gjp8JIaBayrXAnOJYSebQHsWprOs87difpR1OPNw,243
-SURE/codebook/codebook.py,sha256=ZlN6gRX9Gj2D2u3P5KeOsbZri0MoMAiJo9lNeL-MK-I,17117
-SURE/flow/__init__.py,sha256=rsAjYsh1xVIrxBCuwOE0Q_6N5th1wBgjJceV0ABPG3c,183
-SURE/flow/flow_stats.py,sha256=cBBsPEDpWNMpbzlyQ3f0385RSrX6_5RCH2caOyi4ihM,9908
-SURE/flow/plot_quiver.py,sha256=UbmuScUcgbQHeMmjKmgqxjrIjHhiHx0VWct16UMMwuE,8110
-SURE/perturb/__init__.py,sha256=ouxShhbxZM4r5Gf7GmKiutrsmtyq7QL8rHjhgF0BU08,32
-SURE/perturb/perturb.py,sha256=CqO3xPfNA3cG175tadDidKvGsTu_yKfJRRLn_93awKM,3303
-SURE/utils/__init__.py,sha256=QJUOfrXzdWSmoM0P3LH8oKEHttzCWqpDy2UF0F0dtN4,673
-SURE/utils/custom_mlp.py,sha256=rHnx9jEef02zfCUdbYVCmbuHcDdIBmRgt__wpdpZvYg,8104
-SURE/utils/queue.py,sha256=E_5PA5EWcBoGAZj8BkKQnkCK0p4C-4-xcTPqdIXaPXU,1892
-SURE/utils/utils.py,sha256=IUHjDDtYaAYllCWsZyIzqQwaLul6fJRvHRH4vIYcR-c,8462
-sure_tools-2.1.34.dist-info/licenses/LICENSE,sha256=TFHKwmrAViXQbSX5W-NDItkWFjm45HWOeUniDrqmnu0,1065
-sure_tools-2.1.34.dist-info/METADATA,sha256=EV5AA3dO2YrSVqVC0wytPt0RkCIb7nuws0FSUhNcXuE,2651
-sure_tools-2.1.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-sure_tools-2.1.34.dist-info/entry_points.txt,sha256=-nJI8rVe_qqrR0HmfAODzj-JNfEqCcSsyVh6okSqyHk,83
-sure_tools-2.1.34.dist-info/top_level.txt,sha256=BtFTebdiJeqra4r6mm-uEtwVRFLZ_IjYsQ7OnalrOvY,5
-sure_tools-2.1.34.dist-info/RECORD,,