resqpy 4.16.3__py3-none-any.whl → 4.16.5__py3-none-any.whl

resqpy/__init__.py

@@ -28,6 +28,6 @@
 
 import logging
 
-__version__ = "4.16.3"  # Set at build time
+__version__ = "4.16.5"  # Set at build time
 log = logging.getLogger(__name__)
 log.info(f"Imported resqpy version {__version__}")

resqpy/grid_surface/_find_faces.py

@@ -495,19 +495,18 @@ def find_faces_to_represent_surface_regular(
     return gcs
 
 
-def find_faces_to_represent_surface_regular_optimised(
-    grid,
-    surface,
-    name,
-    title = None,
-    agitate = False,
-    random_agitation = False,
-    feature_type = "fault",
-    is_curtain = False,
-    progress_fn = None,
-    return_properties = None,
-    raw_bisector = False,
-):
+def find_faces_to_represent_surface_regular_optimised(grid,
+                                                      surface,
+                                                      name,
+                                                      title = None,
+                                                      agitate = False,
+                                                      random_agitation = False,
+                                                      feature_type = "fault",
+                                                      is_curtain = False,
+                                                      progress_fn = None,
+                                                      return_properties = None,
+                                                      raw_bisector = False,
+                                                      n_batches = 20):
     """Returns a grid connection set containing those cell faces which are deemed to represent the surface.
 
     argumants:
@@ -539,6 +538,8 @@ def find_faces_to_represent_surface_regular_optimised(
            the returned dictionary has the passed strings as keys and numpy arrays as values
         raw_bisector (bool, default False): if True and grid bisector is requested then it is left in a raw
            form without assessing which side is shallower (True values indicate same side as origin cell)
+        n_batches (int, default 20): the number of batches of triangles to use at the low level (numba multi
+           threading allows some parallelism between the batches)
 
     returns:
         gcs  or  (gcs, gcs_props)
@@ -627,8 +628,9 @@ def find_faces_to_represent_surface_regular_optimised(
         p_xy = np.delete(points, 2, 1)
 
         k_hits = vec.points_in_triangles_aligned_optimised(grid.ni, grid.nj, grid_dxyz[0], grid_dxyz[1],
-                                                           p_xy[triangles])
+                                                           p_xy[triangles], n_batches)
 
+        del p_xy
         axis = 2
         index1 = 1
         index2 = 2
@@ -650,7 +652,6 @@ def find_faces_to_represent_surface_regular_optimised(
             k_triangles,
         )
         del k_hits
-        del p_xy
         log.debug(f"k face count: {np.count_nonzero(k_faces)}")
     else:
         k_faces = None
@@ -670,8 +671,10 @@ def find_faces_to_represent_surface_regular_optimised(
         j_offsets = np.full((nk, grid.nj - 1, grid.ni), np.nan)
         p_xz = np.delete(points, 1, 1)
 
-        j_hits = vec.points_in_triangles_aligned_optimised(grid.ni, nk, grid_dxyz[0], grid_dxyz[2], p_xz[triangles])
+        j_hits = vec.points_in_triangles_aligned_optimised(grid.ni, nk, grid_dxyz[0], grid_dxyz[2], p_xz[triangles],
+                                                           n_batches)
 
+        del p_xz
         axis = 1
         index1 = 0
         index2 = 2
@@ -693,7 +696,6 @@ def find_faces_to_represent_surface_regular_optimised(
             j_triangles,
         )
         del j_hits
-        del p_xz
         if is_curtain and grid.nk > 1:  # expand arrays to all layers
             j_faces = np.repeat(j_faces, grid.nk, axis = 0)
             j_triangles = np.repeat(j_triangles, grid.nk, axis = 0)
@@ -718,8 +720,10 @@ def find_faces_to_represent_surface_regular_optimised(
         i_offsets = np.full((nk, grid.nj, grid.ni - 1), np.nan)
         p_yz = np.delete(points, 0, 1)
 
-        i_hits = vec.points_in_triangles_aligned_optimised(grid.nj, nk, grid_dxyz[1], grid_dxyz[2], p_yz[triangles])
+        i_hits = vec.points_in_triangles_aligned_optimised(grid.nj, nk, grid_dxyz[1], grid_dxyz[2], p_yz[triangles],
+                                                           n_batches)
 
+        del p_yz
         axis = 0
         index1 = 0
         index2 = 1
@@ -741,7 +745,6 @@ def find_faces_to_represent_surface_regular_optimised(
             i_triangles,
         )
         del i_hits
-        del p_yz
         if is_curtain and grid.nk > 1:  # expand arrays to all layers
             # log.debug('expanding curtain faces')
             i_faces = np.repeat(i_faces, grid.nk, axis = 0)

resqpy/olio/vector_utilities.py

@@ -13,7 +13,7 @@ log = logging.getLogger(__name__)
 import math as maths
 import numpy as np
 import numba  # type: ignore
-from numba import njit  # type: ignore
+from numba import njit, prange  # type: ignore
 from typing import Tuple, Optional
 
 
@@ -952,13 +952,13 @@ def triangle_box(triangle: np.ndarray) -> Tuple[float, float, float, float]:  #
     """
     x_values = triangle[:, 0]
     y_values = triangle[:, 1]
-    return min(x_values), max(x_values), min(y_values), max(y_values)
+    return np.min(x_values), np.max(x_values), np.min(y_values), np.max(y_values)
 
 
 @njit
 def vertical_intercept(x: float, x_values: np.ndarray, y_values: np.ndarray) -> Optional[float]:  # pragma: no cover
     """Finds the y value 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 None.
 
     arguments:
@@ -982,8 +982,40 @@ def vertical_intercept(x: float, x_values: np.ndarray, y_values: np.ndarray) ->
 
 
 @njit
-def points_in_triangles_aligned_optimised(nx: int, ny: int, dx: float, dy: float,
-                                          triangles: np.ndarray) -> np.ndarray:  # pragma: no cover
+def vertical_intercept_nan(x: float, x_value_0: float, x_value_1: float, y_value_0: float,
+                           y_value_1: float) -> float:  # pragma: no cover
+    """Finds the y value 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_value_0 (np.ndarray): the x coordinate of point 1
+        x_value_1 (np.ndarray): the x coordinate of point 2
+        y_value_0 (np.ndarray): the y coordinate of point 1
+        y_value_1 (np.ndarray): the y coordinate of point 2
+
+    returns:
+        y (float): y value of the straight line segment between point 1 and point 2,
+            evaluated at x; if x is outside the x values range, y is NaN
+    """
+    y = np.NaN
+    if x_value_1 < x_value_0:
+        x_value_0, x_value_1 = x_value_1, x_value_0
+        y_value_0, y_value_1 = y_value_1, y_value_0
+    if x >= x_value_0 and x <= x_value_1:
+        if x_value_0 == x_value_1:
+            y = y_value_0
+        else:
+            m = (y_value_1 - y_value_0) / (x_value_1 - x_value_0)
+            c = y_value_1 - m * x_value_1
+            y = m * x + c
+    return y
+
+
+@njit
+def points_in_triangles_aligned_optimised_old(nx: int, ny: int, dx: float, dy: float,
+                                              triangles: np.ndarray) -> np.ndarray:  # pragma: no cover
     """Calculates which points are within which triangles in 2D for a regular mesh of aligned points.
 
     arguments:
@@ -1023,6 +1055,116 @@ def points_in_triangles_aligned_optimised(nx: int, ny: int, dx: float, dy: float
     return triangles_points
 
 
+@njit
+def points_in_triangles_aligned_optimised_serial(nx: int, ny: int, dx: float, dy: float,
+                                                 triangles: 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
+        dx (float): spacing of points in x axis (first point is at half dx)
+        dy (float): spacing of points in y axis (first point is at half dy)
+        triangles (np.ndarray): float array of each triangles' vertices in 2D, shape (N, 3, 2)
+
+    returns:
+        triangles_points (np.ndarray): 2D array (list-like) containing only the points within each triangle,
+            with each row being the triangle number, points y index, and points x index
+    """
+    triangles = triangles.copy()
+    triangles[..., 0] /= dx
+    triangles[..., 1] /= dy
+    triangles -= 0.5
+    triangles_points_list = []
+    for triangle_num in range(len(triangles)):
+        triangle = triangles[triangle_num]
+        min_x, max_x, min_y, max_y = triangle_box(triangle)
+        for xi in range(max(maths.ceil(min_x), 0), min(maths.floor(max_x) + 1, nx)):
+            x = float(xi)
+            e0_y = vertical_intercept_nan(x, triangle[1, 0], triangle[2, 0], triangle[1, 1], triangle[2, 1])
+            e1_y = vertical_intercept_nan(x, triangle[0, 0], triangle[1, 0], triangle[0, 1], triangle[1, 1])
+            e2_y = vertical_intercept_nan(x, triangle[0, 0], triangle[2, 0], triangle[0, 1], triangle[2, 1])
+            ey_list = np.array([e0_y, e1_y, e2_y], dtype = np.float64)
+            floor_y = np.nanmin(ey_list)
+            ceil_y = np.nanmax(ey_list)
+            triangles_points_list.extend(
+                [[triangle_num, y, xi] for y in range(max(maths.ceil(floor_y), 0), min(maths.floor(ceil_y) + 1, ny))])
+
+    if len(triangles_points_list) == 0:
+        triangles_points = np.empty((0, 3), dtype = np.int32)
+    else:
+        triangles_points = np.array(triangles_points_list, dtype = np.int32)
+
+    return triangles_points
+
+
+@njit(parallel = True)
+def points_in_triangles_aligned_optimised(nx: int,
+                                          ny: int,
+                                          dx: float,
+                                          dy: float,
+                                          triangles: np.ndarray,
+                                          n_batches: int = 20) -> 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
+        dx (float): spacing of points in x axis (first point is at half dx)
+        dy (float): spacing of points in y axis (first point is at half dy)
+        triangles (np.ndarray): float array of each triangles' vertices in 2D, shape (N, 3, 2)
+        n_batches (int, default 20): number of parallel batches
+
+    returns:
+        triangles_points (np.ndarray): 2D array (list-like) containing only the points within each triangle,
+            with each row being the triangle number, points y index, and points x index
+    """
+    n_triangles = len(triangles)
+    if n_triangles == 0:
+        return np.empty((0, 3), dtype = np.int32)
+    triangles = triangles.copy()
+    triangles[..., 0] /= dx
+    triangles[..., 1] /= dy
+    triangles -= 0.5
+    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
+    for batch in prange(n_batches):
+        base = batch * batch_size
+        tp[batch] = _points_in_triangles_aligned_optimised_batch(nx, ny, base, triangles[base:(batch + 1) * batch_size])
+    collated = np.empty((0, 3), dtype = np.int32)
+    for batch in range(n_batches):
+        collated = np.concatenate((collated, tp[batch]), axis = 0)
+    return collated
+
+
+@njit
+def _points_in_triangles_aligned_optimised_batch(nx: int, ny: int, base_triangle: int,
+                                                 triangles: np.ndarray) -> np.ndarray:  # pragma: no cover
+    triangles_points_list = []
+    for triangle_num in range(len(triangles)):
+        triangle = triangles[triangle_num]
+        min_x, max_x, min_y, max_y = triangle_box(triangle)
+        for xi in range(max(maths.ceil(min_x), 0), min(maths.floor(max_x) + 1, nx)):
+            x = float(xi)
+            e0_y = vertical_intercept_nan(x, triangle[1, 0], triangle[2, 0], triangle[1, 1], triangle[2, 1])
+            e1_y = vertical_intercept_nan(x, triangle[0, 0], triangle[1, 0], triangle[0, 1], triangle[1, 1])
+            e2_y = vertical_intercept_nan(x, triangle[0, 0], triangle[2, 0], triangle[0, 1], triangle[2, 1])
+            ey_list = np.array([e0_y, e1_y, e2_y], dtype = np.float64)
+            floor_y = np.nanmin(ey_list)
+            ceil_y = np.nanmax(ey_list)
+            triangles_points_list.extend([[triangle_num + base_triangle, y, xi]
+                                          for y in range(max(maths.ceil(floor_y), 0), min(maths.floor(ceil_y) + 1, ny))
+                                         ])
+
+    if len(triangles_points_list) == 0:
+        triangles_points = np.empty((0, 3), dtype = np.int32)
+    else:
+        triangles_points = np.array(triangles_points_list, dtype = np.int32)
+
+    return triangles_points
+
+
 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/property/_collection_add_part.py

@@ -202,9 +202,6 @@ def _process_imported_property(collection, attributes, property_kind_uuid, strin
      const_value, points, p_time_series_uuid, p_string_lookup_uuid) = attributes
 
     log.debug('processing imported property ' + str(p_keyword))
-    print(
-        f'**** keyword: {p_keyword}; const value: {const_value}; type: {type(const_value)}; is bool: {isinstance(const_value, bool)}'
-    )
     assert not points or not p_discrete
     if local_property_kind_uuid is None:
         local_property_kind_uuid = property_kind_uuid

resqpy/well/_blocked_well.py

@@ -1417,20 +1417,21 @@ class BlockedWell(BaseResqpy):
            time_series_uuid (UUID, optional): the uuid of the time series for time dependent properties being added
 
         notes:
-           units of length along wellbore will be those of the trajectory's length_uom (also applies to K.H values) unless
-           the length_uom argument is used;
-           the constraints are applied independently for each row and a row is excluded if it fails any constraint;
-           the min_k0 and max_k0 arguments do not stop later rows within the layer range from being included;
-           the min_length and min_kh limits apply to individual cell intervals and thus depend on cell size;
-           the water and oil saturation limits are for saturations at a single time and affect whether the interval
-           is included in the dataframe – there is no functionality to support turning perforations off and on over time;
-           the saturation limits do not stop deeper intervals with qualifying saturations from being included;
-           the k0_list, perforation_list and region_list arguments should be set to None to disable the corresponding functionality,
-           if set to an empty list, no rows will be included in the dataframe;
-           if add_as_properties is True, the blocked well must already have been added as a part to the model;
-           add_as_properties and use_properties cannot both be True;
-           add_as_properties and use_properties are only currently functional for single grid blocked wells;
-           at present, unit conversion is not handled when using properties
+           - units of length along wellbore will be those of the trajectory's length_uom (also applies to K.H values) unless
+             the length_uom argument is used;
+           - the constraints are applied independently for each row and a row is excluded if it fails any constraint;
+           - the min_k0 and max_k0 arguments do not stop later rows within the layer range from being included;
+           - the min_length and min_kh limits apply to individual cell intervals and thus depend on cell size;
+           - the water and oil saturation limits are for saturations at a single time and affect whether the interval
+             is included in the dataframe
+           – to turn perforations off and on over time create a time series dependent bunch of boolean properties on
+             the blocked well, with title 'STAT' or local property kind 'well connection open';
+           - the saturation limits do not stop deeper intervals with qualifying saturations from being included;
+           - the k0_list, perforation_list and region_list arguments should be set to None to disable the
+             corresponding functionality, if set to an empty list, no rows will be included in the dataframe;
+           - if add_as_properties is True, the blocked well must already have been added as a part to the model;
+           - add_as_properties and use_properties cannot both be True;
+           - add_as_properties and use_properties are only currently functional for single grid blocked wells;
 
         :meta common:
         """

{resqpy-4.16.3.dist-info → resqpy-4.16.5.dist-info}/METADATA

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

{resqpy-4.16.3.dist-info → resqpy-4.16.5.dist-info}/RECORD

@@ -1,4 +1,4 @@
-resqpy/__init__.py,sha256=3qzjPwU5teamMAPXmjH-nkErGVRVbmIvRt6bs5bWDNU,556
+resqpy/__init__.py,sha256=nZA4OZlU88gioRPPaTSnEOUtDFv-7qvPceSeglqSU9o,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
@@ -48,7 +48,7 @@ resqpy/grid/_write_nexus_corp.py,sha256=yEVfiObsedEAXX6UG6ZTf56kZnQVkd3lLqE2NpL-
 resqpy/grid/_xyz.py,sha256=RLQWOdM_DRoCj4JypwB5gUJ78HTdk5JnZHSeAzuU634,13087
 resqpy/grid_surface/__init__.py,sha256=iyK3_Vlg9mXffc_1gjvRdKwQE0zicbNXya0tryHkr04,2593
 resqpy/grid_surface/_blocked_well_populate.py,sha256=MQIHf7Sh_XR3cUCfGhvlu4Xl498DtIKH2ffo4iud93w,35843
-resqpy/grid_surface/_find_faces.py,sha256=WRoc5g-kLtR0JkuT0nueVF8ZgG09YfR3K_aRp2Rc2K8,64645
+resqpy/grid_surface/_find_faces.py,sha256=frwC2pTuFkHkBdmrLjx7X43e1Crtjh9TfHrgsbhIiAw,65534
 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=ojMRvzMOulb-S3FHnkR3ouIBTXA4knI0drDOt_WACso,6
 resqpy/olio/triangulation.py,sha256=JA4LN4uASqkN_gx4eE_cAHNOJfTqAQQPYET_cLPJuU8,45621
 resqpy/olio/uuid.py,sha256=JRMi-RZNeGm8tGNloIwTATzNtdj29lBQDV9OILboPRI,7324
 resqpy/olio/vdb.py,sha256=lQYuK1kr1Wnucq2EoKgT6lrR7vloCemnCKZktzBcLUc,45231
-resqpy/olio/vector_utilities.py,sha256=yPxHseCCAG8z-IqLvqIVYRQvXte5jBiSTinYkuN-5EY,46836
+resqpy/olio/vector_utilities.py,sha256=V4DRixcJPtM6Z0i_eHxu9HA-gLiRTj3rXKEsChKA-j4,53546
 resqpy/olio/volume.py,sha256=F1pMnDoJ4ricy4dfdLuLuK1xkVgJckL9V06tUeyK6Wc,6185
 resqpy/olio/wellspec_keywords.py,sha256=MqrXRSzVfXAKUhiJkop3EwoVdKEjgZRwHYBJjx2IW8Q,26265
 resqpy/olio/write_data.py,sha256=bIX7ilMkXWCMz_zQh-Gqk56sNzng4W5l4BahW2EV7Kw,5142
@@ -128,7 +128,7 @@ resqpy/organize/tectonic_boundary_feature.py,sha256=mMSsIW8YJ6qpeOe-6gRFaQbK39-W
 resqpy/organize/wellbore_feature.py,sha256=E2gFwgPZGr8nkhRHAIR0wTZ8uwcze7y2WBIV7AXeW2A,1843
 resqpy/organize/wellbore_interpretation.py,sha256=jRAHq90tR2dCQSXsZicujXhSVHOEPoGjFgh5S87SMAI,6973
 resqpy/property/__init__.py,sha256=KegXDizklsMB-EnGFrzhCSszrXAHXEIoStdC5XmyifQ,2294
-resqpy/property/_collection_add_part.py,sha256=D3-VB1HdbW3JcGHoCUX4DBhoHO6gjyLBZ33v2wOHUQ0,17252
+resqpy/property/_collection_add_part.py,sha256=7GRtiYVP5nmIj48Xynbu19evhQslnbbfiM8Wfnz3vcU,17101
 resqpy/property/_collection_create_xml.py,sha256=E48fu8h64T_bz5k3OEqIzPvZAOYRTBgvQ75wreqMwZc,12915
 resqpy/property/_collection_get_attributes.py,sha256=MlontPfGo00lxt0SpB49YG9PRsi5oXPqduDgCSOSmzs,32441
 resqpy/property/_collection_support.py,sha256=77_DG-0pzhMWdG_mNDiGfihXD7Pp-CvDSGCV8ZlDjj4,5889
@@ -184,7 +184,7 @@ resqpy/weights_and_measures/__init__.py,sha256=Kp1pPZFH4rS5_PkCERZBEzGoat6n_dSS0
 resqpy/weights_and_measures/nexus_units.py,sha256=pHqcFbe-8nyqozFgN5Ce-W-UvEnXQ6yiaX3dP1ONtAQ,5434
 resqpy/weights_and_measures/weights_and_measures.py,sha256=1WnrmhtcyCgY2crClNddmfwtf33JdVZy9wNhqPQIvuc,16210
 resqpy/well/__init__.py,sha256=v5_gd7sSPRM9q2KsLiLWaw3jbnXFZkou38qeB7_HSN4,990
-resqpy/well/_blocked_well.py,sha256=07Do0oKvxPFc5HL4SWEwjWE0xYIeJHQCOB2DtI6YgzI,192034
+resqpy/well/_blocked_well.py,sha256=XszaLuRs-McCEP9jjQkpflPqTyaez3v-F0H5qa01UjM,192115
 resqpy/well/_deviation_survey.py,sha256=d3u31JbBqMCsaz6MUrtZium90wrC3omtm46A755fvgk,23115
 resqpy/well/_md_datum.py,sha256=rRrDQckTJwZtIEh28dlgXj32kcBSu-ZvHFYZOiQsyqg,7154
 resqpy/well/_trajectory.py,sha256=QGFgdYVvA_gJth3n-RaFPS71S5KGgECnNMx0dp1r4Tw,52771
@@ -194,7 +194,7 @@ resqpy/well/_wellbore_marker_frame.py,sha256=xvYH2_2Ie3a18LReFymbUrZboOx7Rhv5DOD
 resqpy/well/blocked_well_frame.py,sha256=Lg7TgynfPv9WkklXTLt9VN6uBXWUqX1LI-Xmv_FBqYk,22555
 resqpy/well/well_object_funcs.py,sha256=LYTcC07ezlBxClfrug_B4iXXZUkXDPgsVufNzp361Wo,24703
 resqpy/well/well_utils.py,sha256=zwpYjT85nXAwWBhYB1Pygu2SgouZ-44k6hEOnpoMfBI,5969
-resqpy-4.16.3.dist-info/LICENSE,sha256=2duHPIkKQyESMdQ4hKjL8CYEsYRHXaYxt0YQkzsUYE4,1059
-resqpy-4.16.3.dist-info/METADATA,sha256=QWki_LhRdOqIPNUB9whUt4p16Hp0RvwtxnNGx8-CJdA,4028
-resqpy-4.16.3.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-resqpy-4.16.3.dist-info/RECORD,,
+resqpy-4.16.5.dist-info/LICENSE,sha256=2duHPIkKQyESMdQ4hKjL8CYEsYRHXaYxt0YQkzsUYE4,1059
+resqpy-4.16.5.dist-info/METADATA,sha256=zdLyj409DVsunADWO6B_3G2tBA04jvE4vaLrHD42ZsY,4028
+resqpy-4.16.5.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+resqpy-4.16.5.dist-info/RECORD,,