resqpy 4.17.0__py3-none-any.whl → 4.17.1__py3-none-any.whl

resqpy/olio/vector_utilities.py

@@ -14,7 +14,7 @@ import math as maths
 import numpy as np
 import numba  # type: ignore
 from numba import njit, prange  # type: ignore
-from typing import Tuple, Optional
+from typing import Tuple, Optional, List
 
 
 def radians_from_degrees(deg):
@@ -1013,6 +1013,47 @@ def vertical_intercept_nan(x: float, x_value_0: float, x_value_1: float, y_value
     return y
 
 
+@njit
+def vertical_intercept_nan_yz(x: float, x_0: float, x_1: float, y_0: float, y_1: float, z_0: float,
+                              z_1: float) -> Tuple[float, float]:  # pragma: no cover
+    """Finds the y & z values of a straight line between two points at a given x.
+
+    If the x value given is not within the x values of the points, returns NaN.
+
+    arguments:
+        x (float): x value at which to determine the y value
+        x_0 (float): the x coordinate of point a
+        x_1 (float): the x coordinate of point b
+        y_0 (float): the y coordinate of point a
+        y_1 (float): the y coordinate of point b
+        z_0 (float): the z coordinate of point a
+        z_1 (float): the z coordinate of point b
+
+    returns:
+        y, z (float, float): y & z values of the straight line segment between point a and point b,
+            evaluated at x; if x is outside the x values range, y & z are NaN
+    """
+    y = np.nan
+    z = np.nan
+    if x_1 < x_0:
+        x_0, x_1 = x_1, x_0
+        y_0, y_1 = y_1, y_0
+        z_0, z_1 = z_1, z_0
+    if x >= x_0 and x <= x_1:
+        if x_0 == x_1:
+            y = y_0
+            z = z_0
+        else:
+            xr = x_1 - x_0
+            m = (y_1 - y_0) / xr
+            c = y_1 - m * x_1
+            y = m * x + c
+            m = (z_1 - z_0) / xr
+            c = z_1 - m * x_1
+            z = m * x + c
+    return (y, z)
+
+
 @njit
 def points_in_triangles_aligned_optimised_old(nx: int, ny: int, dx: float, dy: float,
                                               triangles: np.ndarray) -> np.ndarray:  # pragma: no cover
@@ -1138,6 +1179,56 @@ def points_in_triangles_aligned_optimised(nx: int,
     return collated
 
 
+@njit(parallel = True)
+def points_in_triangles_aligned_unified(nx: int,
+                                        ny: int,
+                                        ax: int,
+                                        ay: int,
+                                        az: int,
+                                        triangles: np.ndarray,
+                                        n_batches: int = 20) -> Tuple[np.ndarray, np.ndarray]:  # pragma: no cover
+    """Calculates which points are within which triangles in 2D for a regular mesh of aligned points.
+
+    arguments:
+        - nx (int): number of points in x axis
+        - ny (int): number of points in y axis
+        - ax (int): 'x' axis selection (0, 1, or 2)
+        - ay (int): 'y' axis selection (0, 1, or 2)
+        - az (int): 'z' axis selection (0, 1, or 2)
+        - triangles (np.ndarray): float array of each triangles' normalised vertices in 3D, shape (N, 3, 3)
+        - n_batches (int, default 20): number of parallel batches
+
+    returns:
+        list like int array with each row being (tri number, axis 'y' int, axis 'x' int), and
+        corresponding list like float array being axis 'z' sampled at point on triangle
+        
+    notes:
+        - actual axes to use for x, y, & z are determined by the ax, ay, & az arguments
+        - 0, 1, & 2 must appear once each amongst the ax, ay, & az arguments
+        - triangles points have already been normalised to a unit grid spacing and offset by half a cell
+        - returned 'z' values are in normalised form
+        - to denormalize 'z' values, add 0.5 and multiply by the actual cell length in the corresponding axis
+    """
+    n_triangles = len(triangles)
+    if n_triangles == 0:
+        return np.empty((0, 3), dtype = np.int32), np.empty((0,), dtype = np.float64)
+    n_batches = min(n_triangles, n_batches)
+    batch_size = (n_triangles - 1) // n_batches + 1
+    tp = [np.empty((0, 3), dtype = np.int32)] * n_batches
+    tz = [np.empty((0,), dtype = np.float64)] * n_batches
+    for batch in prange(n_batches):
+        base = batch * batch_size
+        tp[batch], tz[batch] = _points_in_triangles_aligned_unified_batch(nx, ny, base,
+                                                                          triangles[base:(batch + 1) * batch_size], ax,
+                                                                          ay, az)
+    collated = np.empty((0, 3), dtype = np.int32)
+    collated_z = np.empty((0,), dtype = np.float64)
+    for batch in range(n_batches):
+        collated = np.concatenate((collated, tp[batch]), axis = 0)
+        collated_z = np.concatenate((collated_z, tz[batch]), axis = 0)
+    return collated, collated_z
+
+
 @njit
 def _points_in_triangles_aligned_optimised_batch(nx: int, ny: int, base_triangle: int,
                                                  triangles: np.ndarray) -> np.ndarray:  # pragma: no cover
@@ -1165,6 +1256,89 @@ def _points_in_triangles_aligned_optimised_batch(nx: int, ny: int, base_triangle
     return triangles_points
 
 
+@njit
+def _points_in_triangles_aligned_unified_batch(nx: int, ny: int, base_triangle: int, tp: np.ndarray, ax: int, ay: int,
+                                               az: int) -> Tuple[np.ndarray, np.ndarray]:  # pragma: no cover
+    # returns list like int array with each row being (tri number, axis y int, axis x int), and
+    # corresponding list like float array being axis z sampled at point on triangle
+    # todo: add type subscripting once support for python 3.8 is dropped
+    int_list = []
+    sampled_z_list = []
+
+    for triangle_num in range(len(tp)):
+        tri = tp[triangle_num]
+        min_x = np.min(tri[:, ax])
+        max_x = np.max(tri[:, ax])
+        min_y = np.min(tri[:, ay])
+        max_y = np.max(tri[:, ay])
+        for xi in range(max(maths.ceil(min_x), 0), min(maths.floor(max_x) + 1, nx)):
+            x = float(xi)
+            e0_y, e0_z = vertical_intercept_nan_yz(x, tri[1, ax], tri[2, ax], tri[1, ay], tri[2, ay], tri[1, az],
+                                                   tri[2, az])
+            e1_y, e1_z = vertical_intercept_nan_yz(x, tri[0, ax], tri[1, ax], tri[0, ay], tri[1, ay], tri[0, az],
+                                                   tri[1, az])
+            e2_y, e2_z = vertical_intercept_nan_yz(x, tri[0, ax], tri[2, ax], tri[0, ay], tri[2, ay], tri[0, az],
+                                                   tri[2, az])
+            floor_y = np.nan
+            ceil_y = np.nan
+            floor_z = np.nan
+            ceil_z = np.nan
+            if not np.isnan(e0_y):
+                floor_y = e0_y
+                ceil_y = e0_y
+                floor_z = e0_z
+                ceil_z = e0_z
+            if not np.isnan(e1_y):
+                if np.isnan(floor_y):
+                    floor_y = e1_y
+                    ceil_y = e1_y
+                    floor_z = e1_z
+                    ceil_z = e1_z
+                else:
+                    if e1_y < floor_y:
+                        floor_y = e1_y
+                        floor_z = e1_z
+                    else:
+                        ceil_y = e1_y
+                        ceil_z = e1_z
+            if not np.isnan(e2_y):
+                if np.isnan(floor_y):
+                    floor_y = e2_y
+                    ceil_y = e2_y
+                    floor_z = e2_z
+                    ceil_z = e2_z
+                else:
+                    if e2_y < floor_y:
+                        floor_y = e2_y
+                        floor_z = e2_z
+                    elif e2_y > ceil_y:
+                        ceil_y = e2_y
+                        ceil_z = e2_z
+            y_range = ceil_y - floor_y
+            z_range = ceil_z - floor_z
+            t = triangle_num + base_triangle
+            extend_int_list = []
+            extend_z_list = []
+            for y in range(max(maths.ceil(floor_y), 0), min(maths.floor(ceil_y) + 1, ny)):
+                yf = float(y) - floor_y
+                if y_range > 0.0:
+                    yf /= y_range
+                z = floor_z + yf * z_range
+                extend_int_list.append([triangle_num + base_triangle, y, xi])
+                extend_z_list.append(z)
+            int_list.extend(extend_int_list)
+            sampled_z_list.extend(extend_z_list)
+
+    if len(int_list) == 0:
+        int_array = np.empty((0, 3), dtype = np.int32)
+        z_array = np.empty((0,), dtype = np.float64)
+    else:
+        int_array = np.array(int_list, dtype = np.int32)
+        z_array = np.array(sampled_z_list, dtype = np.float64)
+
+    return (int_array, z_array)
+
+
 def triangle_normal_vector(p3):
     """For a triangle in 3D space, defined by 3 vertex points, returns a unit vector normal to the plane of the triangle.
 

resqpy/surface/_surface.py

@@ -279,11 +279,13 @@ class Surface(rqsb.BaseSurface):
         self.extract_patches(self.root)
         return len(self.patch_list)
 
-    def triangles_and_points(self, patch = None):
+    def triangles_and_points(self, patch = None, copy = False):
         """Returns arrays representing one patch or a combination of all the patches in the surface.
 
         arguments:
            patch (int, optional): patch index; if None, combined arrays for all patches are returned
+           copy (bool, default False): if True, a copy of the arrays is returned; if False, the cached
+              arrays are returned
 
         returns:
            tuple (triangles, points):
@@ -296,21 +298,30 @@ class Surface(rqsb.BaseSurface):
 
         self.extract_patches(self.root)
         if patch is None:
-            if self.triangles is None:
-                points_offset = 0
-                for triangulated_patch in self.patch_list:
-                    (t, p) = triangulated_patch.triangles_and_points()
-                    if points_offset == 0:
-                        self.triangles = t.copy()
-                        self.points = p.copy()
-                    else:
-                        self.triangles = np.concatenate((self.triangles, t.copy() + points_offset))
-                        self.points = np.concatenate((self.points, p.copy()))
-                    points_offset += p.shape[0]
-            return (self.triangles, self.points)
+            if self.triangles is None or self.points is None:
+                if self.triangles is None:
+                    points_offset = 0
+                    for triangulated_patch in self.patch_list:
+                        (t, p) = triangulated_patch.triangles_and_points()
+                        if points_offset == 0:
+                            self.triangles = t
+                            self.points = p
+                        else:
+                            self.triangles = np.concatenate((self.triangles, t.copy() + points_offset))
+                            self.points = np.concatenate((self.points, p))
+                        points_offset += p.shape[0]
+            if copy:
+                return (self.triangles.copy(), self.points.copy())
+            else:
+                return (self.triangles, self.points)
         assert 0 <= patch < len(self.patch_list),  \
             ValueError(f'patch index {patch} out of range for surface with {len(self.patch_list)} patches')
-        return self.patch_list[patch].triangles_and_points()
+        return self.patch_list[patch].triangles_and_points(copy = copy)
+
+    def decache_triangles_and_points(self):
+        """Removes the cached composite triangles and points arrays."""
+        self.points = None
+        self.triangles = None
 
     def triangle_count(self, patch = None):
         """Return the numner of triangles in this surface, or in one patch.

resqpy/surface/_triangulated_patch.py

@@ -57,53 +57,61 @@ class TriangulatedPatch:
             crs_root = self.model.root_for_uuid(self.crs_uuid)
         return crs_root, self.crs_uuid
 
-    def triangles_and_points(self):
+    def triangles_and_points(self, copy = False):
         """Returns arrays representing the patch.
 
-        Returns:
+        arguments:
+            copy (bool, default False): if True, a copy of the arrays is returned; if False, the cached
+              arrays are returned
+
+        returns:
            Tuple (triangles, points):
 
            * triangles (int array of shape[:, 3]): integer indices into points array,
              being the nodes of the corners of the triangles
            * points (float array of shape[:, 3]): flat array of xyz points, indexed by triangles
         """
-        if self.triangles is not None:
+        if self.triangles is None:
+
+            assert self.triangle_count is not None and self.node_count is not None
+
+            geometry_node = rqet.find_tag(self.node, 'Geometry')
+            assert geometry_node is not None
+            p_root = rqet.find_tag(geometry_node, 'Points')
+            assert p_root is not None, 'Points xml node not found for triangle patch'
+            assert rqet.node_type(p_root) == 'Point3dHdf5Array'
+            h5_key_pair = self.model.h5_uuid_and_path_for_node(p_root, tag = 'Coordinates')
+            if h5_key_pair is None:
+                return (None, None)
+            try:
+                self.model.h5_array_element(h5_key_pair,
+                                            cache_array = True,
+                                            object = self,
+                                            array_attribute = 'points',
+                                            dtype = 'float')
+            except Exception:
+                log.error('hdf5 points failure for triangle patch ' + str(self.patch_index))
+                raise
+            self._set_t_type()
+            triangles_node = rqet.find_tag(self.node, 'Triangles')
+            h5_key_pair = self.model.h5_uuid_and_path_for_node(triangles_node)
+            if h5_key_pair is None:
+                log.warning('No Triangles found in xml for patch index: ' + str(self.patch_index))
+                return (None, None)
+            try:
+                self.model.h5_array_element(h5_key_pair,
+                                            cache_array = True,
+                                            object = self,
+                                            array_attribute = 'triangles',
+                                            dtype = self.t_type)
+            except Exception:
+                log.error('hdf5 triangles failure for triangle patch ' + str(self.patch_index))
+                raise
+
+        if copy:
+            return (self.triangles.copy(), self.points.copy())
+        else:
             return (self.triangles, self.points)
-        assert self.triangle_count is not None and self.node_count is not None
-
-        geometry_node = rqet.find_tag(self.node, 'Geometry')
-        assert geometry_node is not None
-        p_root = rqet.find_tag(geometry_node, 'Points')
-        assert p_root is not None, 'Points xml node not found for triangle patch'
-        assert rqet.node_type(p_root) == 'Point3dHdf5Array'
-        h5_key_pair = self.model.h5_uuid_and_path_for_node(p_root, tag = 'Coordinates')
-        if h5_key_pair is None:
-            return (None, None)
-        try:
-            self.model.h5_array_element(h5_key_pair,
-                                        cache_array = True,
-                                        object = self,
-                                        array_attribute = 'points',
-                                        dtype = 'float')
-        except Exception:
-            log.error('hdf5 points failure for triangle patch ' + str(self.patch_index))
-            raise
-        self._set_t_type()
-        triangles_node = rqet.find_tag(self.node, 'Triangles')
-        h5_key_pair = self.model.h5_uuid_and_path_for_node(triangles_node)
-        if h5_key_pair is None:
-            log.warning('No Triangles found in xml for patch index: ' + str(self.patch_index))
-            return (None, None)
-        try:
-            self.model.h5_array_element(h5_key_pair,
-                                        cache_array = True,
-                                        object = self,
-                                        array_attribute = 'triangles',
-                                        dtype = self.t_type)
-        except Exception:
-            log.error('hdf5 triangles failure for triangle patch ' + str(self.patch_index))
-            raise
-        return (self.triangles, self.points)
 
     def set_to_trimmed_patch(self, larger_patch, xyz_box = None, xy_polygon = None, internal = False):
         """Populate this (empty) patch with triangles and points that overlap with a trimming volume.

{resqpy-4.17.0.dist-info → resqpy-4.17.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: resqpy
-Version: 4.17.0
+Version: 4.17.1
 Summary: Python API for working with RESQML models
 Home-page: https://github.com/bp/resqpy
 License: MIT

{resqpy-4.17.0.dist-info → resqpy-4.17.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-resqpy/__init__.py,sha256=nVSvwgDXt9osivrFSA1nCeNxqqKRmGyYX4oG-Lfr1xQ,556
+resqpy/__init__.py,sha256=fUx0U_c8Cc-tXpgWWXbigv3JkaDDuAcnpg-ZSWY-z_8,556
 resqpy/crs.py,sha256=R7DfcTP5xGv5pu9Y8RHA2WVM9DjBCSVMoHcz4RmQ7Yw,27646
 resqpy/derived_model/__init__.py,sha256=NFvMSOKI3cxmH7lAbddV43JjoUj-r2G7ExEfOqinD1I,1982
 resqpy/derived_model/_add_edges_per_column_property_array.py,sha256=cpW3gwp6MSYIrtvFmCjoJXcyUsgGuCDbgmwlJCJebUs,6410
@@ -25,7 +25,7 @@ resqpy/derived_model/_zonal_grid.py,sha256=H-IGMudUV-tiRHZqvl9B1wxMQNjeAM2zHvTll
 resqpy/derived_model/_zone_layer_ranges_from_array.py,sha256=4pHkp7yqvkif_pC59VEK0g0JeFx7kt8mqhqADTOcucI,4358
 resqpy/fault/__init__.py,sha256=IStX_EhPnppIExf_mgYrBddC4KP26VcqblcfXiBT614,996
 resqpy/fault/_gcs_functions.py,sha256=NRyhKkYChRaKDUIQ6pfVQiD67e4TTm3LnBvWEPtpkDU,29569
-resqpy/fault/_grid_connection_set.py,sha256=zvHMSuQ10hd8KRc0NldYDziKlLkuw8u2-tSTFDJ36-A,119064
+resqpy/fault/_grid_connection_set.py,sha256=xStOkWHsbh9m6lql7f2PDURnoFOIM1mFmx-QG6yPaKo,126124
 resqpy/grid/__init__.py,sha256=WsfOnR5lHcnpJEx8ZZ3lhd4dImEiieJLM7eFPxMi3u8,692
 resqpy/grid/_cell_properties.py,sha256=pbyAK2eV9n4teOxm2q5hyBinohEbevFPrCfMcpGiqUU,20689
 resqpy/grid/_connection_sets.py,sha256=-277bh9pMoeESSzy9oZehL-vc82aMGZuSLQs2KJ4Wfg,10120
@@ -46,9 +46,9 @@ resqpy/grid/_transmissibility.py,sha256=cLtuVaLgBQqRXa-_YQ5mjR_QC842Jxn2d-Hl6171
 resqpy/grid/_write_hdf5_from_caches.py,sha256=s3gcoilsFCCSw_wjnTjWe1xMHEWr_cessoGVgzqiqVI,9707
 resqpy/grid/_write_nexus_corp.py,sha256=yEVfiObsedEAXX6UG6ZTf56kZnQVkd3lLqE2NpL-KBM,6147
 resqpy/grid/_xyz.py,sha256=RLQWOdM_DRoCj4JypwB5gUJ78HTdk5JnZHSeAzuU634,13087
-resqpy/grid_surface/__init__.py,sha256=iyK3_Vlg9mXffc_1gjvRdKwQE0zicbNXya0tryHkr04,2593
+resqpy/grid_surface/__init__.py,sha256=rPr5zFFRmUDbMEhnCYsweSC3xugtQ8LnhZOf8JLIqIc,2765
 resqpy/grid_surface/_blocked_well_populate.py,sha256=Lme1AR-nLWOUlNnmHMVThk6jEg_lAZxWWtL82Yksppw,35867
-resqpy/grid_surface/_find_faces.py,sha256=04j5Qt61XWwHOJFrGmz0OB1ieivFbjDl2JxD1DXF0Wo,65620
+resqpy/grid_surface/_find_faces.py,sha256=Lfj3gQnLFtLhDBpDHKrVVIMuZSTVW3NJjEpM7N0WvUY,90018
 resqpy/grid_surface/_grid_skin.py,sha256=D0cjHkcuT5KCKb-8EZfXgh0GgJj3kzOBS2wVNXg4bfY,26056
 resqpy/grid_surface/_grid_surface.py,sha256=l2NJo7Kiucolbb_TlLPC7NGdksg_JahkihfsrJVq99w,14379
 resqpy/grid_surface/_trajectory_intersects.py,sha256=Och9cZYU9Y7ofovhPzsLyIblRUl2xj9_5nHH3fMZp-A,22498
@@ -98,7 +98,7 @@ resqpy/olio/transmission.py,sha256=auz_12TKtSPy6Fv3wmKn5lXPRAEnn2tYVyTQfsj37xU,6
 resqpy/olio/triangulation.py,sha256=0WkN93PzBZ_hfAQ-CYNFldfW88koehPEL62GAjY7ZeM,45928
 resqpy/olio/uuid.py,sha256=JRMi-RZNeGm8tGNloIwTATzNtdj29lBQDV9OILboPRI,7324
 resqpy/olio/vdb.py,sha256=lQYuK1kr1Wnucq2EoKgT6lrR7vloCemnCKZktzBcLUc,45231
-resqpy/olio/vector_utilities.py,sha256=zPJHAcdEvuHNm2L3ldEHztBxVSHVJaSSClCO4ooFRG8,53546
+resqpy/olio/vector_utilities.py,sha256=B354cr9-nqqPcb3SAx1jD9Uk51sjkV95xToAiF3-WHA,61127
 resqpy/olio/volume.py,sha256=F1pMnDoJ4ricy4dfdLuLuK1xkVgJckL9V06tUeyK6Wc,6185
 resqpy/olio/wellspec_keywords.py,sha256=ad3B727golWYiko54OZOw7vG21IvpNxCMCyLv8jSkcI,26533
 resqpy/olio/write_data.py,sha256=bIX7ilMkXWCMz_zQh-Gqk56sNzng4W5l4BahW2EV7Kw,5142
@@ -163,10 +163,10 @@ resqpy/surface/_base_surface.py,sha256=LsWrDrbuuaEVRgf2Dlbc-6ZvGQpjtrKuxF7Jjebvl
 resqpy/surface/_combined_surface.py,sha256=8TnNbSywjej6tW_vRr5zoVgBbvnadCaqWk6WyHWHTYQ,3082
 resqpy/surface/_mesh.py,sha256=yEFldNWT2g8MCGcU4mTeWzDrLHHGLLGLIle1gAjJ_lg,42352
 resqpy/surface/_pointset.py,sha256=niTkBik9hAvqrY8340K1TRG7mg4FMQbbp12WZiiXPMs,27416
-resqpy/surface/_surface.py,sha256=J2BN3wLzrwbvM5jaFsZpHSa7iRHCS2BQvr8T9rE7BXE,71172
+resqpy/surface/_surface.py,sha256=fdVLBC4vI8SwsGNFNZhhPFu0FStlXIgzwxGRBSh85LY,71703
 resqpy/surface/_tri_mesh.py,sha256=EmV4FhyjuusQFruW1SseufbnHF5YFoJ6Uvb07UJbH6s,26609
 resqpy/surface/_tri_mesh_stencil.py,sha256=eXt_HIKvsXGsjQ7nm_NbozR6ProQxPbeO52r79j80ig,16087
-resqpy/surface/_triangulated_patch.py,sha256=y8XWN_AglpEzRfNvgY0RWSLaNXrI3gZ_8gZHuzuPTjk,26451
+resqpy/surface/_triangulated_patch.py,sha256=FKn_Irzp4aLFkkN_-tx1MLMKjEAiOLE8636sOA481TQ,26802
 resqpy/time_series/__init__.py,sha256=jiB3HJUWe47OOJTVmRJ4Gh5vm-XdMaMXmD52kAGr2zY,1074
 resqpy/time_series/_any_time_series.py,sha256=43q5hV-VKReZ6rRMEFHx977OVcOKwPvWOJbB9fj3SFQ,8755
 resqpy/time_series/_from_nexus_summary.py,sha256=LWTcJNx_rDFNGP2iWk74ABip_f__iYNBE0R8lVzHOYo,6617
@@ -194,7 +194,7 @@ resqpy/well/_wellbore_marker_frame.py,sha256=xvYH2_2Ie3a18LReFymbUrZboOx7Rhv5DOD
 resqpy/well/blocked_well_frame.py,sha256=eK7Ca6PcqI3pK-XurZIcXAV5Z4B9PFe6H8a7DqVkmBo,22560
 resqpy/well/well_object_funcs.py,sha256=tWufc8wahihzMEO-Ou1dncIttrf4bNo1qmLgh3I2pOM,24717
 resqpy/well/well_utils.py,sha256=zwpYjT85nXAwWBhYB1Pygu2SgouZ-44k6hEOnpoMfBI,5969
-resqpy-4.17.0.dist-info/LICENSE,sha256=2duHPIkKQyESMdQ4hKjL8CYEsYRHXaYxt0YQkzsUYE4,1059
-resqpy-4.17.0.dist-info/METADATA,sha256=QpYj5sjXGcHQ3pQmtPBT4r-bEl1DxBrsL1R36zez7D0,4028
-resqpy-4.17.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-resqpy-4.17.0.dist-info/RECORD,,
+resqpy-4.17.1.dist-info/LICENSE,sha256=2duHPIkKQyESMdQ4hKjL8CYEsYRHXaYxt0YQkzsUYE4,1059
+resqpy-4.17.1.dist-info/METADATA,sha256=hq9C949cG5WrhQV9bmNJLqYAAIiQf86U1ANfYCrYCLo,4028
+resqpy-4.17.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+resqpy-4.17.1.dist-info/RECORD,,