resqpy 4.18.0__py3-none-any.whl → 4.18.2__py3-none-any.whl

resqpy/__init__.py

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

resqpy/grid_surface/_find_faces.py

@@ -865,7 +865,7 @@ def find_faces_to_represent_surface_regular_dense_optimised(grid,
     if progress_fn is not None:
         progress_fn(1.0)
 
-    log.debug(f"finishing find_faces_to_represent_surface_regular_optimised for {name}")
+    log.debug(f"finishing find_faces_to_represent_surface_regular_dense_optimised for {name}")
 
     # if returning properties, construct dictionary
     if return_properties:
@@ -1537,7 +1537,7 @@ def packed_bisector_from_face_indices(  # type: ignore
 
     # find the surface boundary (includes a buffer slice where surface does not reach edge of grid), and shrink the I axis
     box = get_packed_boundary_from_indices(k_faces_kji0, j_faces_kji0, i_faces_kji0, grid_extent_kji)
-    # set k_faces as uint8 packed bool arrays covering box
+    # set k_faces, j_faces & i_faces as uint8 packed bool arrays covering box
     k_faces, j_faces, i_faces = _packed_box_face_arrays_from_indices(k_faces_kji0, j_faces_kji0, i_faces_kji0, box)
 
     box_shape = box[1, :] - box[0, :]
@@ -1562,9 +1562,10 @@ def packed_bisector_from_face_indices(  # type: ignore
     else:
         open_i = np.invert(i_faces, dtype = np.uint8)
 
-    # close off faces in padding bits
-    tail = grid_extent_kji[2] % 8  # number of valid bits in padded byte
-    if tail:
+    # close off faces in padding bits, if within box
+    if box[1, 2] * 8 > grid_extent_kji[2]:
+        tail = grid_extent_kji[2] % 8  # number of valid bits in padded byte
+        assert tail
         m = np.uint8((255 << (8 - tail)) & 255)
         open_k[:, :, -1] &= m
         open_j[:, :, -1] &= m
@@ -1581,7 +1582,7 @@ def packed_bisector_from_face_indices(  # type: ignore
     array[box[0, 0]:box[1, 0], box[0, 1]:box[1, 1], box[0, 2]:box[1, 2]] = box_array
 
     # set bisector values outside of the bounding box
-    _set_packed_bisector_outside_box(array, box, box_array)
+    _set_packed_bisector_outside_box(array, box, box_array, grid_extent_kji[2] % 8)
 
     # check all array elements are not the same
     true_count = np.sum(bitwise_count(array))  # note: will usually include some padding bits, so not so true!
@@ -2127,7 +2128,7 @@ def _set_bisector_outside_box(a: np.ndarray, box: np.ndarray, box_array: np.ndar
         a[:, :, :box[0, 2]] = True
 
 
-def _set_packed_bisector_outside_box(a: np.ndarray, box: np.ndarray, box_array: np.ndarray):
+def _set_packed_bisector_outside_box(a: np.ndarray, box: np.ndarray, box_array: np.ndarray, tail: int):
     # set values outside of the bounding box, working with packed arrays
     if box[1, 0] < a.shape[0] and np.any(box_array[-1, :, :]):
         a[box[1, 0]:, :, :] = 255
@@ -2141,6 +2142,9 @@ def _set_packed_bisector_outside_box(a: np.ndarray, box: np.ndarray, box_array:
         a[:, :, box[1, 2]:] = 255
     if box[0, 2] != 0:
         a[:, :, :box[0, 2]] = 255
+    if tail:
+        m = np.uint8((255 << (8 - tail)) & 255)
+        a[:, :, -1] &= m
 
 
 def _box_face_arrays_from_indices(  # type: ignore

resqpy/multi_processing/wrappers/grid_surface_mp.py

@@ -18,32 +18,32 @@ import resqpy.surface as rqs
 import resqpy.olio.uuid as bu
 
 
-def find_faces_to_represent_surface_regular_wrapper(
-        index: int,
-        parent_tmp_dir: str,
-        use_index_as_realisation: bool,
-        grid_epc: str,
-        grid_uuid: Union[UUID, str],
-        surface_epc: str,
-        surface_uuid: Union[UUID, str],
-        name: str,
-        title: Optional[str] = None,
-        agitate: bool = False,
-        random_agitation: bool = False,
-        feature_type: str = 'fault',
-        trimmed: bool = False,
-        is_curtain = False,
-        extend_fault_representation: bool = False,
-        flange_inner_ring = False,
-        saucer_parameter = None,
-        retriangulate: bool = False,
-        related_uuid = None,
-        progress_fn: Optional[Callable] = None,
-        extra_metadata = None,
-        return_properties: Optional[List[str]] = None,
-        raw_bisector: bool = False,
-        use_pack: bool = False,
-        flange_radius = None) -> Tuple[int, bool, str, List[Union[UUID, str]]]:
+def find_faces_to_represent_surface_regular_wrapper(index: int,
+                                                    parent_tmp_dir: str,
+                                                    use_index_as_realisation: bool,
+                                                    grid_epc: str,
+                                                    grid_uuid: Union[UUID, str],
+                                                    surface_epc: str,
+                                                    surface_uuid: Union[UUID, str],
+                                                    name: str,
+                                                    title: Optional[str] = None,
+                                                    agitate: bool = False,
+                                                    random_agitation: bool = False,
+                                                    feature_type: str = 'fault',
+                                                    trimmed: bool = False,
+                                                    is_curtain = False,
+                                                    extend_fault_representation: bool = False,
+                                                    flange_inner_ring = False,
+                                                    saucer_parameter = None,
+                                                    retriangulate: bool = False,
+                                                    related_uuid = None,
+                                                    progress_fn: Optional[Callable] = None,
+                                                    extra_metadata = None,
+                                                    return_properties: Optional[List[str]] = None,
+                                                    raw_bisector: bool = False,
+                                                    use_pack: bool = False,
+                                                    flange_radius = None,
+                                                    n_threads = 20) -> Tuple[int, bool, str, List[Union[UUID, str]]]:
     """Multiprocessing wrapper function of find_faces_to_represent_surface_regular_optimised.
 
     arguments:
@@ -92,10 +92,11 @@ def find_faces_to_represent_surface_regular_wrapper(
            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)
-        use_pack (bool, default False): if True, boolean properties will be stored in numpy packed format,
-           which will only be readable by resqpy based applications
+        use_pack (bool, default False): if True, boolean properties will be generated and stored in numpy
+           packed format, which will only be readable by resqpy based applications
         flange_radius (float, optional): the radial distance to use for outer flange extension points; if None,
            a large value will be calculated from the grid size; units are xy units of grid crs
+        n_threads (int, default 20): the number of parallel threads to use in numba points in triangles function
 
     returns:
         Tuple containing:
@@ -250,7 +251,9 @@ def find_faces_to_represent_surface_regular_wrapper(
                                                                      is_curtain,
                                                                      progress_fn,
                                                                      return_properties,
-                                                                     raw_bisector = raw_bisector)
+                                                                     raw_bisector = raw_bisector,
+                                                                     n_batches = n_threads,
+                                                                     packed_bisectors = use_pack)
 
     success = False
 
@@ -340,17 +343,17 @@ def find_faces_to_represent_surface_regular_wrapper(
                 if grid_pc is None:
                     grid_pc = rqp.PropertyCollection()
                     grid_pc.set_support(support = grid)
-                grid_pc.add_cached_array_to_imported_list(
-                    array,
-                    f"from find_faces function for {surface.title}",
-                    f'{surface.title} {p_name}',
-                    discrete = True,
-                    property_kind = "grid bisector",
-                    facet_type = 'direction',
-                    facet = 'raw' if raw_bisector else ('vertical' if is_curtain else 'sloping'),
-                    realization = realisation,
-                    indexable_element = "columns" if is_curtain else "cells",
-                )
+                grid_pc.add_cached_array_to_imported_list(array,
+                                                          f"from find_faces function for {surface.title}",
+                                                          f'{surface.title} {p_name}',
+                                                          discrete = True,
+                                                          property_kind = "grid bisector",
+                                                          facet_type = 'direction',
+                                                          facet = 'raw' if raw_bisector else
+                                                          ('vertical' if is_curtain else 'sloping'),
+                                                          realization = realisation,
+                                                          indexable_element = "columns" if is_curtain else "cells",
+                                                          pre_packed = use_pack)
             elif p_name == 'grid shadow':
                 if grid_pc is None:
                     grid_pc = rqp.PropertyCollection()

resqpy/olio/write_hdf5.py

@@ -101,7 +101,7 @@ class H5Register():
         assert chunks is None or isinstance(chunks, str) or isinstance(chunks, tuple)
         assert compression is None or (isinstance(compression, str) and compression in ['gzip', 'lzf', 'none'])
         if str(dtype) == 'pack':
-            a = np.packbits(a, axis = -1)  # todo: check this returns uint8 array
+            a = np.packbits(a, axis = -1)
             dtype = 'uint8'
         elif dtype is not None:
             a = a.astype(dtype, copy = copy)

resqpy/property/_collection_add_part.py

@@ -199,7 +199,7 @@ def _process_imported_property(collection, attributes, property_kind_uuid, strin
                                extra_metadata, expand_const_arrays):
     (p_uuid, p_file_name, p_keyword, p_cached_name, p_discrete, p_uom, p_time_index, p_null_value, p_min_value,
      p_max_value, property_kind, facet_type, facet, realization, indexable_element, count, local_property_kind_uuid,
-     const_value, points, p_time_series_uuid, p_string_lookup_uuid) = attributes
+     const_value, points, p_time_series_uuid, p_string_lookup_uuid, pre_packed) = attributes
 
     log.debug('processing imported property ' + str(p_keyword))
     assert not points or not p_discrete
@@ -214,7 +214,7 @@ def _process_imported_property(collection, attributes, property_kind_uuid, strin
                                                                  p_keyword, p_discrete, string_lookup_uuid, points)
 
     p_array = _process_imported_property_get_p_array(collection, p_cached_name)
-    p_array_bool = isinstance(const_value, bool) if p_array is None else p_array.dtype in [bool, np.int8]
+    p_array_bool = isinstance(const_value, bool) if p_array is None else p_array.dtype in [bool, np.int8, np.uint8]
 
     add_min_max = pcga._process_imported_property_get_add_min_max(points, property_kind, string_lookup_uuid,
                                                                   local_property_kind_uuid, p_array_bool)
@@ -251,7 +251,8 @@ def _process_imported_property(collection, attributes, property_kind_uuid, strin
         find_local_property_kinds = find_local_property_kinds,
         extra_metadata = extra_metadata,
         const_value = const_value,
-        expand_const_arrays = expand_const_arrays)
+        expand_const_arrays = expand_const_arrays,
+        pre_packed = pre_packed)
     if p_node is not None:
         return p_node
     else:

resqpy/property/_collection_create_xml.py

@@ -246,8 +246,10 @@ def _create_xml_facet_node(facet_type, facet, p_node):
         facet_value_node.text = facet
 
 
-def _check_shape_list(collection, indexable_element, direction, property_array, points, count):
+def _check_shape_list(collection, indexable_element, direction, property_array, points, count, pre_packed):
     shape_list = collection.supporting_shape(indexable_element = indexable_element, direction = direction)
+    if pre_packed:
+        shape_list[-1] = (shape_list[-1] - 1) // 8 + 1
     if shape_list is not None:
         if count > 1:
             shape_list.append(count)

resqpy/property/property_collection.py

@@ -88,7 +88,7 @@ class PropertyCollection():
         # above is list of (uuid, source, keyword, cached_name, discrete, uom, time_index, null_value,
         #                   min_value, max_value, property_kind, facet_type, facet, realization,
         #                   indexable_element, count, local_property_kind_uuid, const_value, points,
-        #                   time_series_uuid, string_lookup_uuid)
+        #                   time_series_uuid, string_lookup_uuid, pre_packed)
         self.guess_warning = False
         if support is not None:
             self.model = support.model
@@ -404,7 +404,8 @@ class PropertyCollection():
           call this method once for each group of differently sized properties; for very large collections
           it might also be necessary to divide the work into smaller groups to reduce memory usage;
           this method does not write to hdf5 nor create xml – use the usual methods for further processing
-          of the imported list
+          of the imported list;
+          does not currently support packed arrays
         """
 
         source = 'sampled'
@@ -2219,7 +2220,8 @@ class PropertyCollection():
                                           const_value = None,
                                           points = False,
                                           time_series_uuid = None,
-                                          string_lookup_uuid = None):
+                                          string_lookup_uuid = None,
+                                          pre_packed = False):
         """Caches array and adds to the list of imported properties (but not to the collection dict).
 
         arguments:
@@ -2250,6 +2252,7 @@ class PropertyCollection():
               be provided when writing hdf5 and creating xml for the imported list
            string_lookup_uuid (UUID, optional): should be provided for categorical properties, though can alternatively
               be specified when creating xml
+           pre_packed (bool, default False): set to True if the property is boolean and the array is already packed
 
         returns:
            uuid of nascent property object
@@ -2271,6 +2274,7 @@ class PropertyCollection():
         assert (cached_array is not None and const_value is None) or (cached_array is None and const_value is not None)
         assert not points or not discrete
         assert count > 0
+        assert (not pre_packed) or ((cached_array is not None) and (cached_array.dtype == np.uint8))
         rqp_c.check_and_warn_property_kind(property_kind, 'adding property to imported list')
 
         if self.imported_list is None:
@@ -2288,7 +2292,7 @@ class PropertyCollection():
         self.imported_list.append(
             (uuid, source_info, keyword, cached_name, discrete, uom, time_index, null_value, min_value, max_value,
              property_kind, facet_type, facet, realization, indexable_element, count, local_property_kind_uuid,
-             const_value, points, time_series_uuid, string_lookup_uuid))
+             const_value, points, time_series_uuid, string_lookup_uuid, pre_packed))
         return uuid
 
     def add_similar_to_imported_list(self,
@@ -2311,6 +2315,7 @@ class PropertyCollection():
                                      points = None,
                                      time_series_uuid = None,
                                      string_lookup_uuid = None,
+                                     pre_packed = False,
                                      similar_model = None,
                                      title = None):
         """Caches array and adds to the list of imported properties using default metadata from a similar property.
@@ -2342,6 +2347,7 @@ class PropertyCollection():
               be provided when writing hdf5 and creating xml for the imported list
            string_lookup_uuid (UUID, optional): should be provided for categorical properties, though can alternatively
               be specified when creating xml
+           pre_packed (bool, default False): set to True if the property is boolean and the cached array is packed
            similar_model (Model, optional): the model where the similar property resides, if not the same as this
               property collection
            title (str, optional): synonym for keyword argument
@@ -2398,6 +2404,7 @@ class PropertyCollection():
         args['string_lookup_uuid'] = get_arg(time_series_uuid, similar.string_lookup_uuid())
         em = similar.extra_metadata if hasattr(similar, 'extra_metadata') else {}
         args['source_info'] = get_arg(source_info, em.get('source'))
+        args['pre_packed'] = pre_packed
 
         return self.add_cached_array_to_imported_list(cached_array, **args)
 
@@ -2445,7 +2452,8 @@ class PropertyCollection():
               as 32 bit; if None, the system default is to write as 32 bit; if True, 32 bit is used; if
               False, 64 bit data is written; ignored if dtype is not None
            use_pack (bool, default False): if True, bool arrays will be packed along their last axis; this
-              will generally result in hdf5 data that is not readable by non-resqpy applications
+              will generally result in hdf5 data that is not readable by non-resqpy applications; leave
+              as False for already packed arrays
            chunks (str, optional): if not None, one of 'auto', 'all', or 'slice', controlling hdf5 chunks
            compression (str, optional): if not None, one of 'gzip' or 'lzf' being the hdf5 compression
               algorithm to be used; gzip gives better compression ratio but is slower
@@ -2473,8 +2481,8 @@ class PropertyCollection():
                 uuid = entry[0]
                 cached_name = entry[3]
             tail = 'points_patch0' if entry[18] else 'values_patch0'
-            if use_pack and (str(dtype).startswith('bool') or
-                             (dtype is None and str(self.__dict__[cached_name].dtype) == 'bool')):
+            if use_pack and ('bool' in str(dtype) or
+                             (dtype is None and 'bool' in str(self.__dict__[cached_name].dtype))):
                 dtype = 'pack'
             h5_reg.register_dataset(uuid, tail, self.__dict__[cached_name], dtype = dtype)
         h5_reg.write(file = file_name, mode = mode, use_int32 = use_int32)
@@ -2601,7 +2609,8 @@ class PropertyCollection():
                    points = False,
                    extra_metadata = {},
                    const_value = None,
-                   expand_const_arrays = False):
+                   expand_const_arrays = False,
+                   pre_packed = False):
         """Create a property xml node for a single property related to a given supporting representation node.
 
         arguments:
@@ -2661,6 +2670,8 @@ class PropertyCollection():
            const_value (float, int or bool, optional): if present, create xml for a constant array filled with this value
            expand_const_arrays (boolean, default False): if True, the hdf5 write must also have been called with the
               same argument and the xml will treat a constant array as a normal array
+           pre_packed (boolean, default False): if True, the property is a boolean property and the array has already
+              been packed into bits
 
         returns:
            the newly created property xml node
@@ -2688,7 +2699,7 @@ class PropertyCollection():
         direction = None if facet_type is None or facet_type != 'direction' else facet
 
         if self.support is not None:
-            pcxml._check_shape_list(self, indexable_element, direction, property_array, points, count)
+            pcxml._check_shape_list(self, indexable_element, direction, property_array, points, count, pre_packed)
 
         # todo: assertions:
         #    numpy data type matches discrete flag (and assumptions about precision)

{resqpy-4.18.0.dist-info → resqpy-4.18.2.dist-info}/METADATA

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

{resqpy-4.18.0.dist-info → resqpy-4.18.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-resqpy/__init__.py,sha256=S2prKms_0RorT6KXe8u1LxIRwdkwMJyiHcJIlp0qpFw,556
+resqpy/__init__.py,sha256=x8ZNx5VINljpsdVs90zE08SbRx4LaxTtLTEVOc697cM,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=IlPwm6G7P_Vg_w7JHqSs-d_oxk2QmFtWGTk_vvr1qm8,2911
 resqpy/grid_surface/_blocked_well_populate.py,sha256=Lme1AR-nLWOUlNnmHMVThk6jEg_lAZxWWtL82Yksppw,35867
-resqpy/grid_surface/_find_faces.py,sha256=kJl9DEN2AdhKZH7xzmS6Pvp8wSy6antAwgl9I5CE-2w,104982
+resqpy/grid_surface/_find_faces.py,sha256=iqXVt0VsiRjJ4rddrbNiBT2YzfWwhfRmOolhyFfWN0Y,105197
 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
@@ -69,7 +69,7 @@ resqpy/multi_processing/__init__.py,sha256=ZRudHfN9aaZjxvat7t8BZr6mwMi9baiCNjczw
 resqpy/multi_processing/_multiprocessing.py,sha256=bnCKfSC1tWwvZmZ7BZqCyje0C93m6q7HZPxNpx8xoxA,7301
 resqpy/multi_processing/wrappers/__init__.py,sha256=7vjuTWdHnp3rN9Ud8ljpDnt1NbBAyhA08lv-sQ9Kf3o,72
 resqpy/multi_processing/wrappers/blocked_well_mp.py,sha256=_2fEsSmJVQCnbQIjTHqmnNEugfhN1KvX-o4ZbvtChdI,5952
-resqpy/multi_processing/wrappers/grid_surface_mp.py,sha256=ZIYH34BfdFY7wkcxX3VycJtaFGL4NRpa8tQY391SzQs,23409
+resqpy/multi_processing/wrappers/grid_surface_mp.py,sha256=rnq5i34MRnwFFTzjcs_TzL4Y_dVn68Eg6Jh9nvSNx8Y,25245
 resqpy/multi_processing/wrappers/mesh_mp.py,sha256=0VYoqtgBFfrlyYB6kkjbdrRQ5FKe6t5pHJO3wD9b8Fc,5793
 resqpy/olio/__init__.py,sha256=j2breqKYVufhw5k8qS2uZwB3tUKT7FhdZ23ninS75YA,84
 resqpy/olio/ab_toolbox.py,sha256=bZlAhOJVS0HvIYBW0Lg68re17N8eltoQhIUh0xuUyVc,2147
@@ -102,7 +102,7 @@ resqpy/olio/vector_utilities.py,sha256=B354cr9-nqqPcb3SAx1jD9Uk51sjkV95xToAiF3-W
 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
-resqpy/olio/write_hdf5.py,sha256=KXB2L6Qz3TFb9yDjT-Ty0CXgjyq0nhVp3GADlekWhMQ,19055
+resqpy/olio/write_hdf5.py,sha256=iUIYPWlbJsSSq9UXXiXAW_S6TeK-N2M7QvlJJE43EK8,19015
 resqpy/olio/xml_et.py,sha256=aPjxr2XWvYcwlnckL_UiZmd5EGEoIfy_JxeOKOk3vwQ,25322
 resqpy/olio/xml_namespaces.py,sha256=PiQi2W7gRLxhMSEs26ahT4MlagYqsjMWJlNpIiZupoA,1824
 resqpy/olio/zmap_reader.py,sha256=YuhZjde_DZszVFsUKfu0XieKGg7ONXtJWskRV9Pw7VE,5709
@@ -128,14 +128,14 @@ 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=7GRtiYVP5nmIj48Xynbu19evhQslnbbfiM8Wfnz3vcU,17101
-resqpy/property/_collection_create_xml.py,sha256=E48fu8h64T_bz5k3OEqIzPvZAOYRTBgvQ75wreqMwZc,12915
+resqpy/property/_collection_add_part.py,sha256=uM64TWqJ0aBUwP1u1OJNTUhKLGlmOQj14fGPLG-2pRs,17156
+resqpy/property/_collection_create_xml.py,sha256=p9GASodhg4vQqDDvCOHScto_Qtz_nDADGtvZY92Dcu8,13001
 resqpy/property/_collection_get_attributes.py,sha256=MlontPfGo00lxt0SpB49YG9PRsi5oXPqduDgCSOSmzs,32441
 resqpy/property/_collection_support.py,sha256=77_DG-0pzhMWdG_mNDiGfihXD7Pp-CvDSGCV8ZlDjj4,5889
 resqpy/property/_property.py,sha256=JcG7h6k4cJ4l3WC_VCsvoqHM3FBxrnUuxbIK2Ono1M0,24426
 resqpy/property/attribute_property_set.py,sha256=gATFe-vI00GrgaJNMHSKbM0xmlxIsO5DT1qRSU9snYI,12295
 resqpy/property/grid_property_collection.py,sha256=37dVQSBSTpX22UfBcpPvwGjd8H3O2MepKpWXYc4yJvM,66858
-resqpy/property/property_collection.py,sha256=Ax1wzqE9xfsMaIIKVlVTxNaDRZ4RpEK9ZcBEf_JDtWU,152167
+resqpy/property/property_collection.py,sha256=RqFzbN60P_Q973R9UsxXo2gBnwv-9NSuNPpo38fQgxY,152986
 resqpy/property/property_common.py,sha256=wf429weNtgf6J4gCNNoRwj64elQvUPI_ZWzg4qI7l6c,35993
 resqpy/property/property_kind.py,sha256=6SK0La09eisHPYOSgdx69K_Ordrq0x2tz4IAyurVyY8,5557
 resqpy/property/string_lookup.py,sha256=eH-lbLRbb8JKtO91FTtyuYseRGwPkmsghcXbKUTvVgI,7737
@@ -194,7 +194,7 @@ resqpy/well/_wellbore_marker_frame.py,sha256=xvYH2_2Ie3a18LReFymbUrZboOx7Rhv5DOD
 resqpy/well/blocked_well_frame.py,sha256=Rx8jwkCjchseDZaTttPkA1-f6l7W6vRGrxWtDHlEPx8,22560
 resqpy/well/well_object_funcs.py,sha256=tWufc8wahihzMEO-Ou1dncIttrf4bNo1qmLgh3I2pOM,24717
 resqpy/well/well_utils.py,sha256=zwpYjT85nXAwWBhYB1Pygu2SgouZ-44k6hEOnpoMfBI,5969
-resqpy-4.18.0.dist-info/LICENSE,sha256=2duHPIkKQyESMdQ4hKjL8CYEsYRHXaYxt0YQkzsUYE4,1059
-resqpy-4.18.0.dist-info/METADATA,sha256=odcTjgSWg-tflxhp7J5ixu9jQarKY5aStpB0ZRP_bNw,4028
-resqpy-4.18.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-resqpy-4.18.0.dist-info/RECORD,,
+resqpy-4.18.2.dist-info/LICENSE,sha256=2duHPIkKQyESMdQ4hKjL8CYEsYRHXaYxt0YQkzsUYE4,1059
+resqpy-4.18.2.dist-info/METADATA,sha256=0pU9qfLEhFddkYoUstNROtZbXcxt2m4kg0l19rt7deI,4028
+resqpy-4.18.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+resqpy-4.18.2.dist-info/RECORD,,