sgptools 1.0.6__py3-none-any.whl → 1.1.1__py3-none-any.whl

sgptools/__init__.py

@@ -12,7 +12,7 @@ The library includes python code for the following:
 
 """
 
-__version__ = "1.0.1"
+__version__ = "1.1.0"
 __author__ = 'Kalvik'
 
 from .models.core import *

sgptools/models/bo.py

@@ -29,67 +29,90 @@ class BayesianOpt:
         X_train (ndarray): (n, d); Locations in the environment used to approximate the monitoring regions
         noise_variance (float): data variance
         kernel (gpflow.kernels.Kernel): gpflow kernel function
+        transform (Transform): Transform object
     """
-    def __init__(self, X_train, noise_variance, kernel):
+    def __init__(self, X_train, noise_variance, kernel,
+                 transform=None):
         self.X_train = X_train
         self.noise_variance = noise_variance
         self.kernel = kernel
         self.num_dim = X_train.shape[-1]
-        
+        self.transform = transform
+
         # use the boundaries of the region as the search space
         self.pbounds_dim = []
         for i in range(self.num_dim):
             self.pbounds_dim.append((np.min(X_train[:, i]), np.max(X_train[:, i])))
-
+  
     def objective(self, **kwargs):
-        """Computes the objective function (mutual information) for the sensor placement problem
+        """Objective function (GP-based Mutual Information)
+
+        Args:
+            x<i> (ndarray): (1, d); Current solution sensor placement location i
         """
+        # MI does not depend on waypoint order (reshape to -1, num_dim)
         X = []
         for i in range(len(kwargs)):
             X.append(kwargs['x{}'.format(i)])
         X = np.array(X).reshape(-1, self.num_dim)
-        return -get_mi(X, self.noise_variance, self.kernel, self.X_train)
-    
+        if self.transform is not None:
+            X = self.transform.expand(X)
+            constraints_loss = self.transform.constraints(X)
+
+        try:
+            mi = get_mi(X, self.X_train, self.noise_variance, self.kernel)
+            mi += constraints_loss
+            mi = mi.numpy()
+        except:
+            mi = -1e4 # if the cholskey decomposition fails
+        return mi
+
     def optimize(self, 
                  num_sensors=10, 
                  max_steps=100,  
                  X_init=None,
-                 init_points=10):
+                 init_points=10,
+                 verbose=0, 
+                 seed=1234):
         """Optimizes the sensor placements using Bayesian Optimization without any constraints
 
         Args:
-            num_sensors (int): Number of sensor locations to optimize
-            max_steps (int): Maximum number of optimization steps 
-            X_init (ndarray): (m, d); Initial inducing points
-            init_points (int): How many steps of random exploration you want to perform. 
+            num_sensors (int): Number of sensor locations to optimize.
+            max_steps (int): Maximum number of optimization steps. 
+            X_init (ndarray): (m, d); Initial inducing points.
+            init_points (int): Number of random solutions used for initial exploration. 
                                Random exploration can help by diversifying the exploration space. 
+            verbose (int): The level of verbosity.
+            seed (int): The algorithm will use it to seed the randomnumber generator, ensuring replicability.
 
         Returns:
             Xu (ndarray): (m, d); Solution sensor placement locations
         """
         if X_init is None:
             X_init = get_inducing_pts(self.X_train, num_sensors, random=True)
+        else:
+            num_sensors = len(X_init.reshape(-1, self.num_dim))
         X_init = X_init.reshape(-1)
 
         pbounds = {}
         for i in range(self.num_dim*num_sensors):
             pbounds['x{}'.format(i)] = self.pbounds_dim[i%self.num_dim]
 
-        optimizer = BayesianOptimization(
-            f=self.objective,
-            pbounds=pbounds,
-            verbose=0,
-            random_state=1,
-            allow_duplicate_points=True
-        )
-
-        optimizer.maximize(
-            init_points=init_points,
-            n_iter=max_steps,
-        )
+        optimizer = BayesianOptimization(f=self.objective,
+                                         pbounds=pbounds,
+                                         verbose=verbose,
+                                         random_state=seed,
+                                         allow_duplicate_points=True)
+        optimizer.maximize(init_points=init_points,
+                           n_iter=max_steps)
 
         sol = []
         for i in range(self.num_dim*num_sensors):
             sol.append(optimizer.max['params']['x{}'.format(i)])
-        return np.array(sol).reshape(-1, self.num_dim)
-
+        sol = np.array(sol).reshape(-1, self.num_dim)
+        if self.transform is not None:
+            sol = self.transform.expand(sol,
+                                        expand_sensor_model=False)
+            if not isinstance(sol, np.ndarray):
+                sol = sol.numpy()
+        return sol.reshape(-1, self.num_dim)

sgptools/models/cma_es.py

@@ -57,48 +57,24 @@ class CMA_ES:
         """
         self.noise_variance = noise_variance
         self.kernel = kernel
-
-    def constraint(self, X):
-        """Constraint function for the optimization problem (constraint to limit the boundary of the region)
-        Does not work well with CMA-ES as it is a step function and is not continuous
-
-        Args:
-            X (ndarray): (n, d); Current sensor placement locations
-        """
-        X = np.array(X).reshape(-1, self.num_dim)
-        lagrangian = [self.boundaries.contains(geometry.Point(x[0], x[1])) for x in X]
-        lagrangian = np.logical_not(lagrangian).astype(float)
-        return lagrangian
-    
-    def distance_constraint(self, X):
-        """Constraint function for the optimization problem (constraint to limit the total travel distance)
-        Does not work well with CMA-ES as it is a step function and is not continuous
-
-        Args:
-            X (ndarray): (n, d); Current sensor placement locations
-        """
-        X = np.array(X).reshape(self.num_robots, -1, self.num_dim)
-        dists = np.linalg.norm(X[:, 1:] - X[:, :-1], axis=-1)
-        lagrangian = dists - self.distance_budget
-        lagrangian_mask = np.logical_not(lagrangian <= 0)
-        lagrangian[lagrangian_mask] = 0
-        lagrangian = np.sum(lagrangian)
-        return lagrangian
     
     def objective(self, X):
         """Objective function (GP-based Mutual Information)
 
         Args:
-            X (ndarray): (n, d); Initial sensor placement locations
+            X (ndarray): (n, d); Current solution sensor placement locations
         """
         # MI does not depend on waypoint order (reshape to -1, num_dim)
         X = np.array(X).reshape(-1, self.num_dim)
+        constraints_loss = 0.0
         if self.transform is not None:
-            X = self.transform.expand(X, 
-                                      expand_sensor_model=False).numpy()
+            X = self.transform.expand(X)
+            constraints_loss = self.transform.constraints(X)
 
         try:
-            mi = -get_mi(X, self.noise_variance, self.kernel, self.X_train)
+            mi = -get_mi(X, self.X_train, self.noise_variance, self.kernel)
+            mi -= constraints_loss
+            mi = mi.numpy()
         except:
             mi = 0.0 # if the cholskey decomposition fails
         return mi
@@ -106,16 +82,20 @@ class CMA_ES:
     def optimize(self, 
                  num_sensors=10, 
                  max_steps=5000, 
-                 tol=1e-11, 
-                 X_init=None):
-        """Optimizes the SP objective function using CMA-ES without any constraints
+                 tol=1e-6, 
+                 X_init=None,
+                 verbose=0,
+                 seed=1234):
+        """Optimizes the sensor placements using CMA-ES without any constraints
 
         Args:
             num_sensors (int): Number of sensor locations to optimize
             max_steps (int): Maximum number of optimization steps
             tol (float): Convergence tolerance to decide when to stop optimization
             X_init (ndarray): (m, d); Initial inducing points
-
+            verbose (int): The level of verbosity.
+            seed (int): The algorithm will use it to seed the randomnumber generator, ensuring replicability.
+            
         Returns:
             Xu (ndarray): (m, d); Solution sensor placement locations
         """
@@ -127,63 +107,15 @@ class CMA_ES:
 
         xopt, _ = cma.fmin2(self.objective, X_init, sigma0, 
                             options={'maxfevals': max_steps,
-                                     'verb_disp': 0,
+                                     'verb_disp': verbose,
                                      'tolfun': tol,
-                                     'seed': 1234},
+                                     'seed': seed},
                             restarts=5)
         
         xopt = np.array(xopt).reshape(-1, self.num_dim)
         if self.transform is not None:
             xopt = self.transform.expand(xopt, 
-                                         expand_sensor_model=False).numpy()
-
-        return xopt.reshape(-1, self.num_dim)
-    
-    def doptimize(self, num_sensors=10, max_steps=100, tol=1e-11):
-        """Optimizes the SP objective function using CMA-ES with a distance budget constraint
-
-        Args:
-            num_sensors (int): Number of sensor locations to optimize
-            max_steps (int): Maximum number of optimization steps
-            tol (float): Convergence tolerance to decide when to stop optimization
-
-        Returns:
-            Xu (ndarray): (m, d); Solution sensor placement locations
-        """
-        sigma0 = 1.0
-        idx = np.random.randint(len(self.X_train), size=num_sensors)
-        x_init = self.X_train[idx].reshape(-1)
-        cfun = cma.ConstrainedFitnessAL(self.objective, self.distance_constraint)
-        xopt, _ = cma.fmin2(cfun, x_init, sigma0, 
-                            options={'maxfevals': max_steps,
-                                     'verb_disp': 0,
-                                     'tolfun': tol,
-                                     'seed': 1234},
-                            callback=cfun.update,
-                            restarts=5)
-        return xopt.reshape(-1, self.num_dim)
-
-    def coptimize(self, num_sensors=10, max_steps=100, tol=1e-11):
-        """Optimizes the SP objective function using CMA-ES with the constraints
-        to ensure that the sensors are placed within the boundaries of the region
-
-        Args:
-            num_sensors (int): Number of sensor locations to optimize
-            max_steps (int): Maximum number of optimization steps
-            tol (float): Convergence tolerance to decide when to stop optimization
-
-        Returns:
-            Xu (ndarray): (m, d); Solution sensor placement locations
-        """
-        sigma0 = 1.0
-        idx = np.random.randint(len(self.X_train), size=num_sensors*self.num_robots)
-        x_init = self.X_train[idx].reshape(-1)
-        cfun = cma.ConstrainedFitnessAL(self.objective, self.constraint)
-        xopt, _ = cma.fmin2(cfun, x_init, sigma0, 
-                            options={'maxfevals': max_steps,
-                                     'verb_disp': 0,
-                                     'tolfun': tol,
-                                     'seed': 1234},
-                            callback=cfun.update,
-                            restarts=5)
-        return xopt.reshape(-1, self.num_dim)
+                                         expand_sensor_model=False)
+            if not isinstance(xopt, np.ndarray):
+                xopt = xopt.numpy()
+        return xopt.reshape(-1, self.num_dim)

sgptools/models/core/transformations.py

@@ -159,7 +159,6 @@ class IPPTransform(Transform):
         if self.Xu_fixed is not None:
             self.Xu_fixed.assign(Xu_fixed)
         else:
-            # ToDo: Use binary mask of fixed size to avoid retracing
             self.Xu_fixed = tf.Variable(Xu_fixed, 
                                         shape=tf.TensorShape(None), 
                                         trainable=False)
@@ -325,24 +324,9 @@ class SquareTransform(Transform):
                                       self.num_side, axis=1))
         xy = tf.concat(points, axis=1)
         xy = tf.transpose(xy, [2, 1, 0])
-        xy = self._reshape(xy)
+        xy = tf.reshape(xy, (-1, 2))
         return xy
     
-    def _reshape(self, X):
-        """Reorder the inducing points to be in the correct order for aggregation with square FoV.
-
-        Args:
-            X (ndarray): (mp, 2); Inducing points in input space. `p` is the number of points each 
-                        inducing point is mapped to in order to form the FoV.
-                            
-        Returns:
-            Xu (ndarray): (mp, 2); Reorder inducing points
-        """
-        X = tf.reshape(X, (-1, self.num_side, self.num_side, 2))
-        X = tf.transpose(X, (1, 0, 2, 3))
-        X = tf.reshape(X, (-1, 2))
-        return X
-    
     def distance(self, Xu):
         """Computes the distance incured by sequentially visiting the inducing points
         Args:

sgptools/models/greedy_mi.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .core.augmented_gpr import AugmentedGPR
 from apricot import CustomSelection
+from gpflow.models.gpr import GPR
 import numpy as np
 
 
@@ -32,15 +32,24 @@ class GreedyMI:
         kernel (gpflow.kernels.Kernel): gpflow kernel function
         transform (Transform): Transform object
     """
-    def __init__(self, S, V, noise_variance, kernel, transform=None):
+    def __init__(self, S, V, noise_variance, kernel, 
+                 transform=None):
         self.S = S
         self.V = V
         self.kernel = kernel
         self.input_dim = S.shape[1]
         self.noise_variance = noise_variance
         self.transform = transform
-                                 
+
     def mutual_info(self, x):
+        """Computes mutual information using the points `x` 
+
+        Args:
+            x (ndarray): (n); Indices of the solution placement locations
+
+        Returns:
+            MI (float): Mutual information between the placement x and candidate locations
+        """
         x = np.array(x).reshape(-1).astype(int)
         A = self.S[x[:-1]].reshape(-1, self.input_dim)
         y = self.S[x[-1]].reshape(-1, self.input_dim)
@@ -50,26 +59,27 @@ class GreedyMI:
         else:
             if self.transform is not None:
                 A = self.transform.expand(A)
-            a_gp = AugmentedGPR(data=(A, np.zeros((len(A), 1))),
-                                kernel=self.kernel,
-                                noise_variance=self.noise_variance,
-                                transform=self.transform)
-            _, sigma_a = a_gp.predict_f(y, aggregate_train=True)
+            a_gp = GPR(data=(A, np.zeros((len(A), 1))),
+                       kernel=self.kernel,
+                       noise_variance=self.noise_variance)
+            _, sigma_a = a_gp.predict_f(y)
 
-        # Remove locations in A to build A bar
+        # Remove locations in A∪y from V to build A bar (Refer to Krause et al., 2008)
         V_ = self.V.copy()
         V_rows = V_.view([('', V_.dtype)] * V_.shape[1])
+
         if self.transform is not None:
-            A_ = self.transform.expand(self.S[x]).numpy()
+            solution = self.S[x].reshape(-1, self.input_dim)
+            A_ = self.transform.expand(solution)
         else:
             A_ = self.S[x]
         A_rows = A_.view([('', V_.dtype)] * A_.shape[1])
+
         V_ = np.setdiff1d(V_rows, A_rows).view(V_.dtype).reshape(-1, V_.shape[1])
 
-        self.v_gp = AugmentedGPR(data=(V_, np.zeros((len(V_), 1))), 
-                                 kernel=self.kernel,
-                                 noise_variance=self.noise_variance,
-                                 transform=self.transform)
+        self.v_gp = GPR(data=(V_, np.zeros((len(V_), 1))), 
+                        kernel=self.kernel,
+                        noise_variance=self.noise_variance)
         _, sigma_v = self.v_gp.predict_f(y)
 
         return (sigma_a/sigma_v).numpy().squeeze()

sgptools/models/greedy_sgp.py

@@ -30,20 +30,16 @@ class GreedySGP:
         V (ndarray): (n, d); Locations in the environment used to approximate the monitoring regions
         noise_variance (float): Data noise variance
         kernel (gpflow.kernels.Kernel): gpflow kernel function
-        Xu_fixed (ndarray): (m, d); Inducing points that are not optimized and are always 
-                                    added to the inducing points set during loss function computation
         transform (Transform): Transform object
     """
     def __init__(self, num_inducing, S, V, noise_variance, kernel, 
-                 Xu_fixed=None, 
                  transform=None):
-        self.gp = AugmentedSGPR((V, np.zeros((len(V), 1))),
-                                noise_variance=noise_variance,
-                                kernel=kernel, 
-                                inducing_variable=S[:num_inducing],
-                                transform=transform)
+        self.sgp = AugmentedSGPR((V, np.zeros((len(V), 1))),
+                                 noise_variance=noise_variance,
+                                 kernel=kernel, 
+                                 inducing_variable=S[:num_inducing],
+                                 transform=transform)
         self.locs = S
-        self.Xu_fixed = Xu_fixed
         self.num_inducing = num_inducing
         self.inducing_dim = S.shape[1]
 
@@ -51,21 +47,25 @@ class GreedySGP:
         """Computes the SGP's optimization bound using the inducing points `x` 
 
         Args:
-            x (ndarray): (n, d); Inducing points
+            x (ndarray): (n); Indices of the solution placement locations
 
         Returns:
             elbo (float): Evidence lower bound/SGP's optimization bound value
         """
         x = np.array(x).reshape(-1).astype(int)
         Xu = np.ones((self.num_inducing, self.inducing_dim), dtype=np.float32)
+
+        # Initialize all inducing points at the first solution placement location.
+        # Ensures that the number of inducing points is always fixed and no additional
+        # information is passed to the SGP
         Xu *= self.locs[x][0]
-        Xu[-len(x):] = self.locs[x]
 
-        if self.Xu_fixed is not None:
-            Xu[:len(self.Xu_fixed)] = self.Xu_fixed
+        # Copy all given solution placements to the inducing points set
+        Xu[-len(x):] = self.locs[x]
 
-        self.gp.inducing_variable.Z.assign(Xu)
-        return self.gp.elbo().numpy()
+        # Update the SGP inducing points
+        self.sgp.inducing_variable.Z.assign(Xu)
+        return self.sgp.elbo().numpy() # return the ELBO
 
 
 def get_greedy_sgp_sol(num_sensors, candidates, X_train, noise_variance, kernel, 

sgptools/utils/misc.py

@@ -86,6 +86,7 @@ def plot_paths(paths, candidates=None, title=None):
             plt.legend(bbox_to_anchor=(1.0, 1.02))
     if title is not None:
         plt.title(title)
+    plt.gca().set_aspect('equal')
     plt.xlabel('X')
     plt.ylabel('Y')
 

{sgptools-1.0.6.dist-info → sgptools-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sgptools
-Version: 1.0.6
+Version: 1.1.1
 Summary: Software Suite for Sensor Placement and Informative Path Planning
 Home-page: https://www.itskalvik.com/sgp-tools
 Author: Kalvik
@@ -13,18 +13,18 @@ Requires-Dist: matplotlib
 Requires-Dist: pandas
 Requires-Dist: scikit-learn
 Requires-Dist: scipy
-Requires-Dist: numpy
+Requires-Dist: numpy<2.0.0
 Requires-Dist: ortools
 Requires-Dist: scikit-image
 Requires-Dist: shapely
 Requires-Dist: cma
 Requires-Dist: bayesian-optimization
-Requires-Dist: hkb-diamondsquare
-Requires-Dist: tensorflow-probability[tf] >=0.21.0
-Requires-Dist: typing-extensions
-Requires-Dist: gpflow >=2.7.0
+Requires-Dist: hkb_diamondsquare
+Requires-Dist: tensorflow-probability[tf]>=0.21.0
+Requires-Dist: tensorflow>=2.13.0; platform_machine != "arm64"
+Requires-Dist: tensorflow-aarch64>=2.13.0; platform_machine == "arm64"
+Requires-Dist: typing_extensions
+Requires-Dist: gpflow>=2.7.0
 Requires-Dist: pillow
-Requires-Dist: tensorflow >=2.13.0 ; platform_machine != "arm64"
-Requires-Dist: tensorflow-aarch64 >=2.13.0 ; platform_machine == "arm64"
 
 Software Suite for Sensor Placement and Informative Path Planning

{sgptools-1.0.6.dist-info → sgptools-1.1.1.dist-info}/RECORD

@@ -1,25 +1,25 @@
-sgptools/__init__.py,sha256=J4jZOdSzuUtaabg4TtYxxWfQwZkA0E_bVK3aaBPgPAc,449
+sgptools/__init__.py,sha256=pC3DPZgQ3mDxhgiKB8E9pyfFlxkeXmmwZCyHSY9T_a4,449
 sgptools/kernels/__init__.py,sha256=zRf4y-wJwjXKt1uOnmI5MbzCA6pRlyA7C-eagLfb3d0,190
 sgptools/kernels/neural_kernel.py,sha256=9XEjcwwi1Gwj4D5cAZwq5QdWqMaI-Vu2DKgYO58DmPg,6709
 sgptools/models/__init__.py,sha256=X2lIg9kf1-2MHUswk-VW2dHHcbSLxf6_IuV7lc_kvDc,682
-sgptools/models/bo.py,sha256=RkcbD0t2d1gkZf7SMtMyymlYne9sFEaA4pjmgQhlTWY,3640
-sgptools/models/cma_es.py,sha256=URLndW_lb9zQj6XrxO6tnm9U6xld8jgsrqsg-Oo5vyw,8006
+sgptools/models/bo.py,sha256=sjs18oRXL-yoNiLoaaoROjaJXqfj_CwouJPe9HgzjL0,4857
+sgptools/models/cma_es.py,sha256=LjWRcUIcARcFvAHR2F8prPDmgxLzYI0kRwYXzKp3APc,4861
 sgptools/models/continuous_sgp.py,sha256=USf9fG1Pl-rQfcD_ffP6mB4mrh0F9RMUA7Lfhw9rc48,2940
-sgptools/models/greedy_mi.py,sha256=LJVXKHC58iJs1CyfAioAjCeK2o5hiViTchFxuiKj73o,4870
-sgptools/models/greedy_sgp.py,sha256=jgQexdEZ_z88iD6sM_D0NhJvBodQ9zindh9L7117q_8,4462
+sgptools/models/greedy_mi.py,sha256=06CY6tm9C3iBYEG_DOuQKDmWIww9Ah0rkeJUXsCR2YU,5018
+sgptools/models/greedy_sgp.py,sha256=giddMbU3ohePTdLTcH4fDx-bS9upq1T_K8KUW_Ag6HI,4490
 sgptools/models/core/__init__.py,sha256=TlUdvrM0A7vSzc5IM8C2Y2kliB1ip7YLEcHHzvuw-C4,482
 sgptools/models/core/augmented_gpr.py,sha256=NuYwlggz7ho7pvW4-so3ghos5vZ8oK7nRZqvHpAt0Zk,3497
 sgptools/models/core/augmented_sgpr.py,sha256=qMP9J4AnOUx9AEZfaPhoyb3RP_2AOhOUCUY4eh7uOi0,7185
 sgptools/models/core/osgpr.py,sha256=gqliUdXdnt3fea206LP0rqGIggmIdKh8WP2DtFWzdBw,11798
-sgptools/models/core/transformations.py,sha256=avluSP7g4EWjijlpFQYobO_CHKA0-V7PemC6SdVwrG8,18976
+sgptools/models/core/transformations.py,sha256=X7WEKo_lFAYB5HKnFvxFsxfz6CB-jzPfVWcx1sWe2lI,18313
 sgptools/utils/__init__.py,sha256=jgWqzSDgUbqOTFo8mkqZaTlyz44l3v2XYPJfcHYHjqM,376
 sgptools/utils/data.py,sha256=oTXq4oRuzJdXpZC6frUfja8jhwy_ZdDDi7L1BYZcdQs,7309
 sgptools/utils/gpflow.py,sha256=LnFYufnMW4ch7qsKnru53QUxEtIzJqE822qj6w8ssRg,8576
 sgptools/utils/metrics.py,sha256=tu8H129n8GuxV5fQIKLcfzPUxd7sp8zEF9qZBOZjNKo,5834
-sgptools/utils/misc.py,sha256=_6hZRoSnbnKCt9H3XRlPT74Wh5VO5zArFddE1dszHGo,5408
+sgptools/utils/misc.py,sha256=LdAFJS7-xubWpRnrgdLOorCa9vB_8vRrvL5cahxHYNA,5442
 sgptools/utils/tsp.py,sha256=RJAQ4_uE7CUtR1ei3nSnGy-1kNhw82E9P_HyaCkc4iI,7007
-sgptools-1.0.6.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sgptools-1.0.6.dist-info/METADATA,sha256=fdUW1EPBQkGG-rKXi6xVa8i4Qt5gIwKDr_8MPsI-Lh4,944
-sgptools-1.0.6.dist-info/WHEEL,sha256=ixB2d4u7mugx_bCBycvM9OzZ5yD7NmPXFRtKlORZS2Y,91
-sgptools-1.0.6.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
-sgptools-1.0.6.dist-info/RECORD,,
+sgptools-1.1.1.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sgptools-1.1.1.dist-info/METADATA,sha256=wGH0O-OJRPgT6AjtTqMQnbae8Zvhu6mqD3_bU3SHRUs,944
+sgptools-1.1.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+sgptools-1.1.1.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
+sgptools-1.1.1.dist-info/RECORD,,

{sgptools-1.0.6.dist-info → sgptools-1.1.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (74.1.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any