foscat 2025.5.2__py3-none-any.whl → 2025.6.1__py3-none-any.whl

foscat/heal_NN.py

@@ -0,0 +1,432 @@
+import pickle
+
+import numpy as np
+
+import foscat.scat_cov as sc
+
+class CNN:
+
+    def __init__(
+        self,
+        nparam=1,
+        KERNELSZ=3,
+        NORIENT=4,
+        chanlist=[],
+        in_nside=1,
+        n_chan_in=1,
+        SEED=1234,
+        all_type='float32',
+        filename=None,
+        scat_operator=None,
+        BACKEND='tensorflow'
+    ):
+
+        if filename is not None:
+            outlist = pickle.load(open("%s.pkl" % (filename), "rb"))
+            self.scat_operator = sc.funct(KERNELSZ=outlist[3],
+                                            NORIENT= outlist[9],
+                                            all_type=outlist[7])
+            self.KERNELSZ = self.scat_operator.KERNELSZ
+            self.all_type = self.scat_operator.all_type
+            self.npar = outlist[2]
+            self.nscale = outlist[5]
+            self.chanlist = outlist[0]
+            self.in_nside = outlist[4]
+            self.nbatch = outlist[1]
+            self.n_chan_in = outlist[8]
+            self.NORIENT = outlist[9]
+            self.x = self.scat_operator.backend.bk_cast(outlist[6])
+            self.out_nside = self.in_nside // (2**(self.nscale+1))
+        else:
+            self.nscale = len(chanlist)-1
+            self.npar = nparam
+            self.n_chan_in = n_chan_in
+            if scat_operator is None:
+                self.scat_operator = sc.funct(
+                    KERNELSZ=KERNELSZ,
+                    NORIENT=NORIENT,
+                    all_type=all_type)
+            else:
+                self.scat_operator = scat_operator
+
+            self.chanlist = chanlist
+            self.KERNELSZ = self.scat_operator.KERNELSZ
+            self.NORIENT = self.scat_operator.NORIENT
+            self.all_type = self.scat_operator.all_type
+            self.in_nside = in_nside
+            self.out_nside = self.in_nside // (2**(self.nscale+1))
+            self.backend = self.scat_operator.backend
+            np.random.seed(SEED)
+            self.x = self.scat_operator.backend.bk_cast(
+                np.random.rand(self.get_number_of_weights())
+            )
+        self.mpi_size = self.scat_operator.mpi_size
+        self.mpi_rank = self.scat_operator.mpi_rank
+        self.BACKEND = BACKEND
+        self.gpupos = self.scat_operator.gpupos
+        self.ngpu = self.scat_operator.ngpu
+        self.gpulist = self.scat_operator.gpulist
+
+    def save(self, filename):
+
+        outlist = [
+            self.chanlist,
+            self.nbatch,
+            self.npar,
+            self.KERNELSZ,
+            self.in_nside,
+            self.nscale,
+            self.get_weights().numpy(),
+            self.all_type,
+            self.n_chan_in,
+            self.NORIENT,
+        ]
+
+        myout = open("%s.pkl" % (filename), "wb")
+        pickle.dump(outlist, myout)
+        myout.close()
+
+    def get_number_of_weights(self):
+        totnchan = 0
+        for i in range(self.nscale):
+            totnchan = totnchan + self.chanlist[i] * self.chanlist[i + 1]
+        return (
+            self.npar * 12 * self.out_nside**2 * self.chanlist[self.nscale]*self.NORIENT
+            + totnchan * self.KERNELSZ * (self.KERNELSZ//2+1)*self.NORIENT*self.NORIENT
+            + self.KERNELSZ * (self.KERNELSZ//2+1) * self.n_chan_in * self.chanlist[0]*self.NORIENT
+        )
+
+    def set_weights(self, x):
+        self.x = x
+
+    def get_weights(self):
+        return self.x
+
+    def init_wave(self):
+        w0=np.zeros([self.n_chan_in, self.KERNELSZ * (self.KERNELSZ//2+1),  self.chanlist[0], self.NORIENT])
+        if self.KERNELSZ==3:
+            w0[:,0]=-0.2
+            w0[:,1]=-0.5
+            w0[:,2]=-0.2
+            w0[:,3]=0.2
+            w0[:,4]=0.5
+            w0[:,5]=0.2
+        if self.KERNELSZ==5:
+            w0[:,0]=-0.1
+            w0[:,1]=-0.2
+            w0[:,2]=-0.5
+            w0[:,3]=-0.2
+            w0[:,4]=-0.1
+            w0[:,10]=0.1
+            w0[:,11]=0.2
+            w0[:,12]=0.5
+            w0[:,13]=0.2
+            w0[:,14]=0.1
+        
+        a=2*np.sqrt(6/(12 * self.out_nside**2 * self.chanlist[self.nscale]*self.NORIENT*self.npar))
+        x=(np.random.rand(self.get_number_of_weights())-0.5)*a
+        
+        w0=w0.flatten()
+        x[0:w0.shape[0]]=w0
+        nn = self.KERNELSZ * (self.KERNELSZ//2+1) * self.n_chan_in * self.chanlist[0]*self.NORIENT
+        
+        for k in range(self.nscale):
+            ww = np.zeros([self.chanlist[k], self.NORIENT, self.KERNELSZ * (self.KERNELSZ//2+1),  self.chanlist[k + 1], self.NORIENT])
+            
+            if self.KERNELSZ==3:
+                ww[:,:,0]=-0.2
+                ww[:,:,1]=-0.5
+                ww[:,:,2]=-0.2
+                ww[:,:,3]=0.2
+                ww[:,:,4]=0.5
+                ww[:,:,5]=0.2
+            if self.KERNELSZ==5:
+                ww[:,:,0]=-0.1
+                ww[:,:,1]=-0.2
+                ww[:,:,2]=-0.5
+                ww[:,:,3]=-0.2
+                ww[:,:,4]=-0.1
+                ww[:,:,10]=0.1
+                ww[:,:,11]=0.2
+                ww[:,:,12]=0.5
+                ww[:,:,13]=0.2
+                ww[:,:,14]=0.1
+            x[nn : nn + self.KERNELSZ
+                    * (self.KERNELSZ//2+1)
+                    * self.NORIENT*self.NORIENT
+                    * self.chanlist[k]
+                    * self.chanlist[k + 1]
+                ]=ww.flatten()
+                
+            nn = nn + (self.KERNELSZ * (self.KERNELSZ//2+1)
+                * self.NORIENT*self.NORIENT
+                * self.chanlist[k]
+                * self.chanlist[k + 1])
+            
+        self.x = self.scat_operator.backend.bk_cast(x)
+        
+    def calc_matrix_first_layer(self,noise_map):
+        # Décalage circulaire par matrice de permutation
+        def circ_shift_matrix(N,k):
+            return np.roll(np.eye(N), shift=-k, axis=1)
+        
+        im=self.scat_operator.convol(noise_map)
+        mm=np.mean(abs(im.cpu().numpy()),0)
+        Norient=mm.shape[1]
+        xx=np.cos(np.arange(Norient)/Norient*2*np.pi)
+        yy=np.sin(np.arange(Norient)/Norient*2*np.pi)
+
+        a=np.sum(mm*xx[None,:,None],1)
+        b=np.sum(mm*yy[None,:,None],1)
+        o=np.fmod(Norient*np.arctan2(-b,a)/(2*np.pi)+Norient,Norient)
+        xx=np.arange(Norient)
+        alpha = o[:,None,:]-xx[None,:,None]
+        beta = np.fmod(1+o[:,None,:]-xx[None,:,None],Norient)
+        alpha=(1-alpha)*(alpha<1)*(alpha>0)+beta*(beta<1)*(beta>0)
+
+        m=np.zeros([mm.shape[0],4,4,mm.shape[2]])
+        for k in range(4):
+            m[:,k,:,:]=np.roll(alpha,k,1)
+        m=np.mean(m,0)
+        return self.scat_operator.backend.bk_cast(m[None,None,...])
+        
+    def eval(self, im, 
+            indices=None, 
+            weights=None, 
+            out_map=False, 
+            first_layer_rot=None,
+            activation='relu'):
+
+        x = self.x
+        ww = self.backend.bk_reshape(
+            x[0 : self.KERNELSZ * (self.KERNELSZ//2+1) * self.n_chan_in * self.chanlist[0]*self.NORIENT],
+            [self.n_chan_in, 1 , self.KERNELSZ * (self.KERNELSZ//2+1),  self.chanlist[0], self.NORIENT],
+        )
+        nn = self.KERNELSZ * (self.KERNELSZ//2+1) * self.n_chan_in * self.chanlist[0]*self.NORIENT
+
+        im = self.scat_operator.healpix_layer(im[:,:,None,:], ww)
+        
+        if first_layer_rot is not None:
+            im = self.backend.bk_reshape(im,[im.shape[0],im.shape[1],self.NORIENT,1,im.shape[3]])
+            im = self.backend.bk_reduce_sum(im*first_layer_rot,2)
+            
+        if out_map:
+            return im
+        
+        if activation=='relu':
+            im = self.backend.bk_relu(im)
+        elif activation=='abs':
+            im = self.backend.bk_abs(im)
+        
+        im = self.backend.bk_reduce_sum(self.backend.bk_reshape(im,[im.shape[0],im.shape[1],self.NORIENT,im.shape[3]//4,4]),4)
+
+        for k in range(self.nscale):
+            ww = self.scat_operator.backend.bk_reshape(
+                x[
+                    nn : nn
+                    + self.KERNELSZ
+                    * (self.KERNELSZ//2+1)
+                    * self.NORIENT*self.NORIENT
+                    * self.chanlist[k]
+                    * self.chanlist[k + 1]
+                ],
+                [self.chanlist[k], self.NORIENT, self.KERNELSZ * (self.KERNELSZ//2+1),  self.chanlist[k + 1], self.NORIENT],
+            )
+            nn = (
+                nn
+                + self.KERNELSZ
+                * (self.KERNELSZ//2+1)
+                * self.NORIENT*self.NORIENT
+                * self.chanlist[k]
+                * self.chanlist[k + 1]
+            )
+            if indices is None:
+                im = self.scat_operator.healpix_layer(im, ww)
+            else:
+                im = self.scat_operator.healpix_layer(
+                    im, ww, indices=indices[k], weights=weights[k]
+                )
+            
+            if activation=='relu':
+                im = self.backend.bk_relu(im)
+            elif activation=='abs':
+                im = self.backend.bk_abs(im)
+            im = self.backend.bk_reduce_sum(self.backend.bk_reshape(im,[im.shape[0],im.shape[1],self.NORIENT,im.shape[3]//4,4]),4)
+
+        ww = self.scat_operator.backend.bk_reshape(
+            x[
+                nn : nn
+                + self.npar * 12 * self.out_nside**2 * self.chanlist[self.nscale]*self.NORIENT
+            ],
+            [12 * self.out_nside**2 * self.chanlist[self.nscale]*self.NORIENT, self.npar],
+        )
+
+        im = self.scat_operator.backend.bk_matmul(
+            self.scat_operator.backend.bk_reshape(
+                im, [im.shape[0], im.shape[1] * im.shape[2] * im.shape[3]]
+            ),
+            ww,
+        )
+        #im = self.scat_operator.backend.bk_reshape(im, [self.npar])
+        #im = self.scat_operator.backend.bk_relu(im)
+        return im
+        
+class GCNN:
+
+    def __init__(
+        self,
+        nparam=1,
+        KERNELSZ=3,
+        NORIENT=4,
+        chanlist=[],
+        in_nside=1,
+        out_chan=1,
+        SEED=1234,
+        all_type='float32',
+        filename=None,
+        scat_operator=None,
+        BACKEND='tensorflow'
+    ):
+
+        if filename is not None:
+            outlist = pickle.load(open("%s.pkl" % (filename), "rb"))
+            self.scat_operator = sc.funct(KERNELSZ=outlist[3],NORIENT=outlist[8], all_type=outlist[7])
+            self.KERNELSZ = self.scat_operator.KERNELSZ
+            self.all_type = self.scat_operator.all_type
+            self.npar = outlist[2]
+            self.nscale = outlist[5]
+            self.chanlist = outlist[0]
+            self.in_nside = outlist[4]
+            self.nbatch = outlist[1]
+            self.NORIENT = outlist[8]
+            self.out_chan = outlist[9]
+            self.x = self.scat_operator.backend.bk_cast(outlist[6])
+            self.out_nside = self.in_nside // (2**self.nscale)
+        else:
+            self.nscale = len(chanlist)-1
+            self.npar = nparam
+            
+            if scat_operator is None:
+                self.scat_operator = sc.funct(
+                    KERNELSZ=KERNELSZ,
+                    NORIENT=NORIENT,
+                    all_type=all_type)
+            else:
+                self.scat_operator = scat_operator
+
+            self.chanlist = chanlist
+            self.KERNELSZ = self.scat_operator.KERNELSZ
+            self.NORIENT = self.scat_operator.NORIENT
+            self.all_type = self.scat_operator.all_type
+            self.in_nside = in_nside
+            self.out_nside = self.in_nside * (2**self.nscale)
+            self.out_chan = out_chan
+            self.backend = self.scat_operator.backend
+            np.random.seed(SEED)
+            self.x = self.scat_operator.backend.bk_cast(
+                np.random.rand(self.get_number_of_weights())
+            )
+        self.mpi_size = self.scat_operator.mpi_size
+        self.mpi_rank = self.scat_operator.mpi_rank
+        self.BACKEND = BACKEND
+        self.gpupos = self.scat_operator.gpupos
+        self.ngpu = self.scat_operator.ngpu
+        self.gpulist = self.scat_operator.gpulist
+
+    def save(self, filename):
+
+        outlist = [
+            self.chanlist,
+            self.nbatch,
+            self.npar,
+            self.KERNELSZ,
+            self.in_nside,
+            self.nscale,
+            self.get_weights().numpy(),
+            self.all_type,
+            self.NORIENT,
+            self.out_chan
+        ]
+
+        myout = open("%s.pkl" % (filename), "wb")
+        pickle.dump(outlist, myout)
+        myout.close()
+
+    def get_number_of_weights(self):
+        totnchan = 0
+        for i in range(self.nscale):
+            totnchan = totnchan + self.chanlist[i] * self.chanlist[i + 1]
+        return (
+            self.npar * 12 * self.in_nside**2 * self.chanlist[0]*self.NORIENT
+            + totnchan * self.KERNELSZ * (self.KERNELSZ//2+1)*self.NORIENT*self.NORIENT
+            + self.chanlist[-1]*self.out_chan*self.NORIENT
+        )
+
+    def set_weights(self, x):
+        self.x = x
+
+    def get_weights(self):
+        return self.x
+
+    def eval(self, im, indices=None, weights=None):
+
+        x = self.x
+        
+        ww = self.backend.bk_reshape(
+            x[0:self.npar * 12 * self.in_nside**2 * self.chanlist[0]*self.NORIENT],
+            [self.npar,12 * self.in_nside**2 * self.chanlist[0]*self.NORIENT],
+        )
+
+        im = self.scat_operator.backend.bk_matmul(im,ww)
+        
+        im = self.backend.bk_reshape(im,[im.shape[0],self.chanlist[0],self.NORIENT,12 * self.in_nside**2])
+        
+        nn = self.npar * 12 * self.in_nside**2 * self.chanlist[0]
+        
+        for k in range(self.nscale):
+            
+            im = self.scat_operator.backend.bk_relu(im)
+            
+            im = self.backend.bk_reshape(
+                        self.scat_operator.backend.bk_repeat(im,4,axis=-1),
+                        [im.shape[0],im.shape[1],self.NORIENT,im.shape[3]*4])
+            
+            ww = self.scat_operator.backend.bk_reshape(
+                x[
+                    nn : nn
+                    + self.KERNELSZ
+                    * (self.KERNELSZ//2+1)
+                    * self.NORIENT *self.NORIENT
+                    * self.chanlist[k]
+                    * self.chanlist[k + 1]
+                ],
+                [self.chanlist[k] , self.NORIENT, self.KERNELSZ * (self.KERNELSZ//2+1),  self.chanlist[k + 1],self.NORIENT],
+            )
+            nn = (
+                nn
+                + self.KERNELSZ
+                * (self.KERNELSZ//2+1)
+                * self.NORIENT *self.NORIENT
+                * self.chanlist[k]
+                * self.chanlist[k + 1]
+            )
+            
+            if indices is None:
+                im = self.scat_operator.healpix_layer(im, ww)
+            else:
+                im = self.scat_operator.healpix_layer(
+                    im, ww, indices=indices[k], weights=weights[k]
+                )
+
+        ww = self.scat_operator.backend.bk_reshape(
+                x[
+                    nn : nn
+                    + self.chanlist[-1]*self.NORIENT
+                    * self.out_chan
+                ],
+                [1,self.chanlist[-1],self.NORIENT, self.out_chan, 1],
+            )
+        im = self.backend.bk_reduce_mean(im[:,:,:,None]*ww,[1,2])
+        #im = self.scat_operator.backend.bk_relu(im)
+         
+        return im

foscat/scat_cov.py

@@ -6079,7 +6079,38 @@ class funct(FOC.FoCUS):
         return scat_cov(
             s0, s2, s3, s4, s1=s1, s3p=s3p, backend=self.backend, use_1D=self.use_1D
         )
-
+    def calc_matrix_orientation(self,noise_map,image2=None):
+        # Décalage circulaire par matrice de permutation
+        def circ_shift_matrix(N,k):
+            return np.roll(np.eye(N), shift=-k, axis=1)
+        Norient = self.NORIENT
+        im=self.convol(noise_map)
+        if image2 is None:
+            mm=np.mean(abs(self.backend.to_numpy(im)),0)
+        else:
+            im2=self.convol(self.backend.bk_cast(image2))
+            mm=np.mean(self.backend.to_numpy(
+                self.backend.bk_L1(im*self.backend.bk_conjugate(im2))).real,0)
+        
+        Norient=mm.shape[0]
+        xx=np.cos(np.arange(Norient)/Norient*2*np.pi)
+        yy=np.sin(np.arange(Norient)/Norient*2*np.pi)
+
+        a=np.sum(mm*xx[:,None],0)
+        b=np.sum(mm*yy[:,None],0)
+        
+        o=np.fmod(Norient*np.arctan2(-b,a)/(2*np.pi)+Norient,Norient)
+        xx=np.arange(Norient)
+        alpha = o[None,:]-xx[:,None]
+        beta = np.fmod(1+o[None,:]-xx[:,None],Norient)
+        alpha=(1-alpha)*(alpha<1)*(alpha>0)+beta*(beta<1)*(beta>0)
+        
+        m=np.zeros([Norient,Norient,mm.shape[1]])
+        for k in range(Norient):
+            m[k,:,:]=np.roll(alpha,k,0)
+        #m=np.mean(m,0)
+        return self.backend.bk_cast(m)
+        
     def synthesis(
         self,
         image_target,

{foscat-2025.5.2.dist-info → foscat-2025.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: foscat
-Version: 2025.5.2
+Version: 2025.6.1
 Summary: Generate synthetic Healpix or 2D data using Cross Scattering Transform
 Author-email: Jean-Marc DELOUIS <jean.marc.delouis@ifremer.fr>
 Maintainer-email: Theo Foulquier <theo.foulquier@ifremer.fr>

{foscat-2025.5.2.dist-info → foscat-2025.6.1.dist-info}/RECORD

@@ -1,30 +1,31 @@
 foscat/BkBase.py,sha256=TEhfqUpIOh_bGBCyQfRCs0yjKdhgELjFpvq_QiouX5A,21514
 foscat/BkNumpy.py,sha256=zRldS_-L6A7y1zDzEPZXQntuw3Paw2zHZowhD43FHRs,10589
 foscat/BkTensorflow.py,sha256=K2s3xYVMHqLlTyApQpeKf9dc3hbRv8EqtCA_gE1bRQA,19958
-foscat/BkTorch.py,sha256=7TwJxSw_XGyJyvombHrfsT7LFm4RNHt1sDQD53Fbll0,18105
-foscat/CNN.py,sha256=j0F2a4Xf3LijhyD_WVZ6Eg_IjGuXw3ddH6Iudj1xVaw,4874
+foscat/BkTorch.py,sha256=OUpa1ajRFxes9v_T6jK0gLlJXzn_DhQ3rlrf-yTSFcY,18126
+foscat/CNN.py,sha256=gQ9V76wmcowo2BaNp5sJYcSDCVOjc18TS9cE6-qEUso,5153
 foscat/CircSpline.py,sha256=CXi49FxF8ZoeZ17Ua8c1AZXe2B5ICEC9aCXb97atB3s,4028
-foscat/FoCUS.py,sha256=kKjuLvdCrR8VHjnxzdgYSCpe8LnNlHaDOV6Riu8UEO4,95289
-foscat/GCNN.py,sha256=5RV-FKuvqbD-k99TwiM4CttM2LMZE21WD0IK0j5Mkko,7599
-foscat/Softmax.py,sha256=aBLQauoG0q2SJYPotV6U-cxAhsJcspWHNRWdnA_nAiQ,2854
+foscat/FoCUS.py,sha256=Ke_h6g4Fqn62OpCkVxfr5zIDnT5hd-b1vvkm9aB3LhY,97364
+foscat/GCNN.py,sha256=q7yWHCMJpP7-m3WvR3OQnp5taeYWaMxIY2hQ6SIb9gs,4487
+foscat/Softmax.py,sha256=UDZGrTroYtmGEyokGUVpwNO_cgbICi9QVuRr8Yx52_k,2917
 foscat/Spline1D.py,sha256=rKzzenduaZZ-yBDJd35it6Gyrj1spqb7hoIaUgISPzY,2983
 foscat/Synthesis.py,sha256=tC5hvpam19QwDdvghVax7dA7gMgKA6ZtxQEcV9HjdC0,13824
 foscat/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-foscat/alm.py,sha256=qZlsYj5HzV1EY9Fdzt0U8bemrZHZziaMOKZ55FU8foM,33806
+foscat/alm.py,sha256=XkK4rFVRoO-oJpr74iBffKt7hdS_iJkR016IlYm10gQ,33832
 foscat/backend.py,sha256=l3aMwDyXP6jURMIvratFMGWCTcQpaR68KnUuuGDezqE,45418
 foscat/backend_tens.py,sha256=9Dp136m9frkclkwifJQLLbIpl3ETI3_txdPUZcKfuMw,1618
+foscat/heal_NN.py,sha256=BXAqBEftvxVNOEtwo6xid6gFLrve8I-9jPQ1xI0HTl0,15648
 foscat/loss_backend_tens.py,sha256=dCOVN6faDtIpN3VO78HTmYP2i5fnFAf-Ddy5qVBlGrM,1783
 foscat/loss_backend_torch.py,sha256=k3z18Dj3SaLKK6ZIKcm7GO4U_YKYVP6LtHG1aIbxkYk,1627
 foscat/scat.py,sha256=qGYiBIysPt65MdmF07WWA4piVlTfA9-lFDTaicnqC2w,72822
 foscat/scat1D.py,sha256=W5Uu6wdQ4ZsFKXpof0f1OBl-1wjJmW7ruvddRWxe7uM,53726
 foscat/scat2D.py,sha256=boKj0ASqMMSy7uQLK6hPniG87m3hZGJBYBiq5v8F9IQ,532
-foscat/scat_cov.py,sha256=tpuYqyPwYdG8vjm4uwYUjajeHzxYwCto-Bky475oPXA,259203
+foscat/scat_cov.py,sha256=bdlaDoMmIDHMAQ7ZdkbtrIKr4Y-3w2xWO9e2_ZTeelk,260445
 foscat/scat_cov1D.py,sha256=XOxsZZ5TYq8f34i2tUgIfzyaqaTDlICB3HzD2l_puro,531
 foscat/scat_cov2D.py,sha256=pAm0fKw8wyXram0TFbtw8tGcc8QPKuPXpQk0kh10r4U,7078
 foscat/scat_cov_map.py,sha256=9MzpwT2g9S3dmnjHEMK7PPLQ27oGQg2VFVsP_TDUU5E,2869
 foscat/scat_cov_map2D.py,sha256=1dS4P1KHqZYkYCLA1sYpPSZulJrCTd_2eL8HFOjlcz4,2841
-foscat-2025.5.2.dist-info/licenses/LICENSE,sha256=i0ukIr8ZUpkSY2sZaE9XZK-6vuSU5iG6IgX_3pjatP8,1505
-foscat-2025.5.2.dist-info/METADATA,sha256=sbR5VT1kq7d1qrLd74c-CdprtKhpkC6eHQ1nE24nqtI,7215
-foscat-2025.5.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-foscat-2025.5.2.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
-foscat-2025.5.2.dist-info/RECORD,,
+foscat-2025.6.1.dist-info/licenses/LICENSE,sha256=i0ukIr8ZUpkSY2sZaE9XZK-6vuSU5iG6IgX_3pjatP8,1505
+foscat-2025.6.1.dist-info/METADATA,sha256=0l5yu57MiVAHs7Q_Ar1I0CsksYBclfPs4Uq5me-4BnI,7215
+foscat-2025.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+foscat-2025.6.1.dist-info/top_level.txt,sha256=AGySXBBAlJgb8Tj8af6m_F-aiNg2zNTcybCUPVOKjAg,7
+foscat-2025.6.1.dist-info/RECORD,,