resqpy 4.14.1__py3-none-any.whl → 5.1.5__py3-none-any.whl

resqpy/lines/_polyline.py

@@ -25,25 +25,22 @@ class Polyline(rql_c._BasePolyline):
 
     resqml_type = 'PolylineRepresentation'
 
-    def __init__(
-            self,
-            parent_model,
-            uuid = None,
-            set_bool = None,  #: DEPRECATED
-            set_coord = None,
-            set_crs = None,
-            is_closed = None,
-            title = None,
-            rep_int_root = None,
-            originator = None,
-            extra_metadata = None):
+    def __init__(self,
+                 parent_model,
+                 uuid = None,
+                 set_coord = None,
+                 set_crs = None,
+                 is_closed = None,
+                 title = None,
+                 rep_int_root = None,
+                 originator = None,
+                 extra_metadata = None):
         """Initialises a new polyline object.
 
         arguments:
             parent_model (model.Model object): the model which the new PolylineRepresentation belongs to
             uuid (uuid.UUID, optional): the uuid of an existing RESQML PolylineRepresentation from which
                 to initialise the resqpy Polyline
-            set_bool (boolean, optional): DEPRECATED: synonym for is_closed argument
             set_coord (numpy float array, optional): an ordered set of xyz values used to define a new polyline;
                 last dimension of array must have extent 3; ignored if uuid is not None
             set_crs (uuid.UUID, optional): the uuid of a crs to be used when initialising from coordinates;
@@ -65,10 +62,6 @@ class Polyline(rql_c._BasePolyline):
         """
 
         self.model = parent_model
-        if set_bool is not None:
-            warnings.warn('DEPRECATED: use is_closed argument instead of set_bool, in Polyline initialisation')
-            if is_closed is None:
-                is_closed = set_bool
         self.isclosed = is_closed
         self.nodepatch = None
         self.crs_uuid = set_crs
@@ -466,22 +459,20 @@ class Polyline(rql_c._BasePolyline):
         if cache and self.centre is not None:
             return self.centre
         assert mode in ['weighted', 'sampled']
-        if mode == 'sampled':  # this mode is deprecated as it simply approximates the weighted mode
-            sample_points = self.equidistant_points(n, in_xy = in_xy)
-            centre = np.mean(sample_points, axis = 0)
-        else:  # 'weighted'
-            sum = np.zeros(3)
-            seg_count = len(self.coordinates) - 1
-            if self.isclosed:
-                seg_count += 1
-            d = 2 if in_xy else 3
-            p1 = np.zeros(3)
-            p2 = np.zeros(3)
-            for seg_index in range(seg_count):
-                successor = (seg_index + 1) % len(self.coordinates)
-                p1[:d], p2[:d] = self.coordinates[seg_index, :d], self.coordinates[successor, :d]
-                sum += (p1 + p2) * vu.naive_length(p2 - p1)
-            centre = sum / (2.0 * self.full_length(in_xy = in_xy))
+        if mode != 'weighted':  # ignore any other mode, ie. sampled
+            warnings.warn('DEPRECATED: weighted mode is only mode now supported for Polyline.balanced_centre()')
+        sum = np.zeros(3)
+        seg_count = len(self.coordinates) - 1
+        if self.isclosed:
+            seg_count += 1
+        d = 2 if in_xy else 3
+        p1 = np.zeros(3)
+        p2 = np.zeros(3)
+        for seg_index in range(seg_count):
+            successor = (seg_index + 1) % len(self.coordinates)
+            p1[:d], p2[:d] = self.coordinates[seg_index, :d], self.coordinates[successor, :d]
+            sum += (p1 + p2) * vu.naive_length(p2 - p1)
+        centre = sum / (2.0 * self.full_length(in_xy = in_xy))
         if cache:
             self.centre = centre
         return centre

resqpy/model/_catalogue.py

@@ -553,6 +553,15 @@ def _citation_title_for_part(model, part):  # duplicate functionality to title_f
     return title
 
 
+def _source_for_part(model, part):
+    """Returns the source string from the part's extra metadata, if present, else None."""
+
+    part_extra = rqet.load_metadata_from_xml(_root_for_part(model, part))
+    if not part_extra:
+        return None
+    return part_extra.get('source')
+
+
 def _root_for_time_series(model, uuid = None):
     """Return root for time series part."""
 

resqpy/model/_forestry.py

@@ -200,8 +200,8 @@ def _load_epc(model, epc_file, full_load = True, epc_subdir = None, copy_from =
 def _add_uuid_soft_relations(model, uuid_int, part):
     if "EpcExternalPart" in part:
         return
-    value = model.rels_forest.get(rqet.rels_part_name_for_part(part))
-    if value is not None:
+    rels_part = rqet.rels_part_name_for_part(part)
+    if rels_part in model.rels_forest:
         rels_root = m_c._root_for_part(model, rqet.rels_part_name_for_part(part), is_rels = True)
         if rels_root is not None:
             for relation_node in rels_root:
@@ -214,9 +214,10 @@ def _add_uuid_soft_relations(model, uuid_int, part):
                 if relation_uuid_str is None:
                     return  # probably HDF5 external resource
                 relation_uuid_int = _hex_to_int(relation_uuid_str)
-                value = model.uuid_rels_dict.get(uuid_int)
-                if value is not None and relation_uuid_int not in value[0] and relation_uuid_int not in value[1]:
-                    value[2].add(relation_uuid_int)
+                rels_sets = model.uuid_rels_dict.get(uuid_int)
+                if rels_sets is not None and relation_uuid_int not in rels_sets[
+                        0] and relation_uuid_int not in rels_sets[1]:
+                    rels_sets[2].add(relation_uuid_int)
 
 
 def _add_uuid_relations(model, uuid_int, part):
@@ -685,17 +686,23 @@ def _copy_referenced_parts(model, other_model, realization, consolidate, force,
             resident_uuid_int = model.consolidation.map[ref_uuid_int]
             assert resident_uuid_int is not None
             # find referring node for ref_uuid_int and modify its reference to resident_uuid_int
-            if reference_node_dict is None:
+            if reference_node_dict is None:  # now mapping uuid int to list of nodes
                 ref_nodes = rqet.list_obj_references(root_node)
                 reference_node_dict = {}
                 for ref_node in ref_nodes:
                     uuid_node = rqet.find_tag(ref_node, 'UUID')
                     uuid_int = bu.uuid_from_string(uuid_node.text).int
-                    reference_node_dict[uuid_int] = uuid_node
-            uuid_node = reference_node_dict[ref_uuid_int]
-            uuid_node.text = str(bu.uuid_from_int(resident_uuid_int))
-            reference_node_dict.pop(ref_uuid_int)
-            reference_node_dict[resident_uuid_int] = uuid_node
+                    if uuid_int in reference_node_dict:
+                        reference_node_dict[uuid_int].append(uuid_node)
+                    else:
+                        reference_node_dict[uuid_int] = [uuid_node]
+            uuid_node_list = reference_node_dict.pop(ref_uuid_int)
+            for uuid_node in uuid_node_list:
+                uuid_node.text = str(bu.uuid_from_int(resident_uuid_int))
+            if resident_uuid_int in reference_node_dict:
+                reference_node_dict[resident_uuid_int] += uuid_node_list
+            else:
+                reference_node_dict[resident_uuid_int] = uuid_node_list
 
 
 def _copy_relationships_for_present_targets(model, other_model, consolidate, force, resident_uuid, root_node):
@@ -719,9 +726,6 @@ def _copy_relationships_for_present_targets(model, other_model, consolidate, for
                         continue
                 else:
                     continue
-            if not force and resident_related_part in m_c._parts_list_filtered_by_related_uuid(
-                    model, m_c._list_of_parts(model), resident_uuid):
-                continue
             related_node = m_c._root_for_part(model, resident_related_part)
             assert related_node is not None
 

resqpy/model/_hdf5.py

@@ -262,11 +262,11 @@ def _h5_array_element(model,
         if dtype is None:
             return result
         if result.size == 1:
-            if dtype is float or (isinstance(dtype, str) and dtype.startswith('float')):
+            if dtype is float or (isinstance(dtype, str) and ('float' in dtype)):
                 return float(result)
-            elif dtype is int or (isinstance(dtype, str) and dtype.startswith('int')):
+            elif dtype is int or (isinstance(dtype, str) and ('int' in dtype)):
                 return int(result)
-            elif dtype is bool or (isinstance(dtype, str) and dtype.startswith('bool')):
+            elif dtype is bool or (isinstance(dtype, str) and ('bool' in dtype)):
                 return bool(result)
         return np.array(result, dtype = dtype)
 
@@ -286,6 +286,14 @@ def _h5_overwrite_array_slice(model, h5_key_pair, slice_tuple, array_slice):
     dset[slice_tuple] = array_slice
 
 
+def _h5_overwrite_array(model, h5_key_pair, array):
+    """Overwrites (updates) the whole of an hdf5 array."""
+
+    h5_root = _h5_access(model, h5_key_pair[0], mode = 'a')
+    dset = h5_root[h5_key_pair[1]]
+    dset[...] = array
+
+
 def h5_clear_filename_cache(model):
     """Clears the cached filenames associated with all ext uuids."""
 

resqpy/model/_model.py

@@ -1108,6 +1108,66 @@ class Model():
 
         return m_c._citation_title_for_part(self, part)
 
+    def source_for_part(self, part):
+        """Returns the source string from the part's extra metadata, if present, else None.
+
+        arguments:
+            part (str): the part for which the source information is required
+
+        returns:
+            str being the text of the source field in the xml extra metadata of the part, or None
+        """
+
+        return m_c._source_for_part(self, part)
+
+    def set_source_for_part(self, part, source):
+        """Sets the source string in the part's extra metadata.
+
+        arguments:
+            part (str): the part for which the source information is to be set
+            source (str): text for the extra metadata source item
+
+        notes:
+            this function adds the source item to the in-memory xml extra metadata;
+            any previous text for the source item (if present) will be replaced;
+            it will be included in the epc if store_epc() is subsequently called
+        """
+
+        m_x._create_source(source, root = m_c._root_for_part(self, part))
+        self.set_modified()
+
+    def source_for_obj(self, obj):
+        """Returns the source string from the object's extra metadata, if present, else None.
+
+        arguments:
+            obj (BaseResqpy): any high level resqpy object (eg. Surface)
+
+        returns:
+            str being the text of the source extra metadata item for the object, or None
+        """
+
+        return m_c._source_for_part(self, obj.part)
+
+    def set_source_for_obj(self, obj, source):
+        """Sets the source string in the object's extra metadata.
+
+        arguments:
+            part (str): the part for which the source information is to be set
+            source (str): text for the extra metadata source item
+
+        notes:
+            this function adds the source item to the in-memory xml extra metadata as well as
+            the object's extra_metadata dictionary
+            any previous text for the source item (if present) will be replaced;
+            it will be included in the epc if store_epc() is subsequently called
+        """
+
+        m_x._create_source(source, root = obj.root)
+        if not hasattr(obj, 'extra_metadata') or obj.extra_metadata is None:
+            obj.extra_metadata = {}
+        obj.extra_metadata['source'] = str(source)
+        self.set_modified()
+
     def root_for_time_series(self, uuid = None):
         """Return root for time series part.
 
@@ -1280,7 +1340,8 @@ class Model():
            an hdf5 file name is cached once determined for a given ext uuid; to clear the cache,
            call the h5_clear_filename_cache() method
         """
-
+        if isinstance(override, bool):
+            warnings.warn('DEPRECATED: boolean override argument to Model.h5_file_name(); use string instead')
         return m_h._h5_file_name(self, uuid = uuid, override = override, file_must_exist = file_must_exist)
 
     def h5_access(self, uuid = None, mode = 'r', override = 'default', file_path = None):
@@ -1306,7 +1367,8 @@ class Model():
            an exception will be raised if the hdf5 file cannot be opened; note that sometimes another
            piece of code accessing the file might cause a 'resource unavailable' exception
         """
-
+        if isinstance(override, bool):
+            warnings.warn('DEPRECATED: boolean override argument to Model.h5_access(); use string instead')
         return m_h._h5_access(self, uuid = uuid, mode = mode, override = override, file_path = file_path)
 
     def h5_release(self):
@@ -1339,7 +1401,7 @@ class Model():
                          cache_array = False,
                          object = None,
                          array_attribute = None,
-                         dtype = 'float',
+                         dtype = None,
                          required_shape = None):
         """Returns one element from an hdf5 array and/or caches the array.
 
@@ -1415,6 +1477,21 @@ class Model():
 
         return m_h._h5_overwrite_array_slice(self, h5_key_pair, slice_tuple, array_slice)
 
+    def h5_overwrite_array(self, h5_key_pair, array):
+        """Overwrites (updates) the whole of an hdf5 array.
+
+        arguments:
+           h5_key_pair (uuid, string): the uuid of the hdf5 ext part and the hdf5 internal path to the
+              required hdf5 array
+           array (numpy array of shape to match existing hdf5 dataset): the data to write
+
+        notes:
+           this method naively updates an hdf5 array without using mpi to look after parallel updates;
+           metadata (such as uuid or property min, max values) is not modified in any way by the method
+        """
+
+        return m_h._h5_overwrite_array(self, h5_key_pair, array)
+
     def h5_clear_filename_cache(self):
         """Clears the cached filenames associated with all ext uuids."""
 
@@ -2023,6 +2100,11 @@ class Model():
         if other_model is self:
             return part
         assert part is not None
+        # check whether already existing in this model
+        if part in self.parts_forest.keys():
+            return part
+        if m_c._type_of_part(other_model, part) == 'obj_EpcExternalPartReference':
+            return None
         if realization is not None:
             assert isinstance(realization, int) and realization >= 0
         if force:
@@ -2033,13 +2115,6 @@ class Model():
             self_h5_file_name = self.h5_file_name(file_must_exist = False)
         hdf5_copy_needed = not os.path.samefile(self_h5_file_name, other_h5_file_name)
 
-        # check whether already existing in this model
-        if part in self.parts_forest.keys():
-            return part
-
-        if m_c._type_of_part(other_model, part) == 'obj_EpcExternalPartReference':
-            return None
-
         return m_f._copy_part_from_other_model(self,
                                                other_model,
                                                part,

resqpy/model/_xml.py

@@ -420,22 +420,39 @@ def _create_supporting_representation(model,
 
 
 def _create_source(source, root = None):
-    """Create an extra meta data node holding information on the source of the data, optionally add to root."""
+    """Create an extra meta data node holding information on the source of the data, optionally add to root.
 
-    emd_node = rqet.Element(ns['resqml2'] + 'ExtraMetadata')
-    emd_node.set(ns['xsi'] + 'type', ns['resqml2'] + 'NameValuePair')
-    emd_node.text = rqet.null_xml_text
+    note:
+        if the root already contains a 'source' extra metadata item, its text field is updated and the
+        existing extra metadata xml node is returned
+    """
 
-    name_node = rqet.SubElement(emd_node, ns['resqml2'] + 'Name')
-    name_node.set(ns['xsi'] + 'type', ns['xsd'] + 'string')
-    name_node.text = 'source'
+    emd_node = None
+    if root is not None:
+        emd_node = rqet.find_metadata_item_node_in_xml(root, 'source')
 
-    value_node = rqet.SubElement(emd_node, ns['resqml2'] + 'Value')
-    value_node.set(ns['xsi'] + 'type', ns['xsd'] + 'string')
-    value_node.text = source
+    if emd_node is None:
 
-    if root is not None:
-        root.append(emd_node)
+        emd_node = rqet.Element(ns['resqml2'] + 'ExtraMetadata')
+        emd_node.set(ns['xsi'] + 'type', ns['resqml2'] + 'NameValuePair')
+        emd_node.text = rqet.null_xml_text
+
+        name_node = rqet.SubElement(emd_node, ns['resqml2'] + 'Name')
+        name_node.set(ns['xsi'] + 'type', ns['xsd'] + 'string')
+        name_node.text = 'source'
+
+        value_node = rqet.SubElement(emd_node, ns['resqml2'] + 'Value')
+        value_node.set(ns['xsi'] + 'type', ns['xsd'] + 'string')
+        value_node.text = str(source)
+
+        if root is not None:
+            root.append(emd_node)
+
+    else:
+
+        value_node = rqet.find_tag(emd_node, 'Value')
+        assert value_node is not None
+        value_node.text = str(source)
 
     return emd_node
 
@@ -457,7 +474,9 @@ def _create_patch(model,
         assert ext_uuid is not None
     else:
         assert const_count is not None and const_count > 0
-        if hdf5_type.endswith('Hdf5Array'):
+        if isinstance(const_value, bool):
+            hdf5_type = 'BooleanConstantArray'  # not actually stored in hdf5
+        elif hdf5_type.endswith('Hdf5Array'):
             hdf5_type = hdf5_type[:-9] + 'ConstantArray'
 
     lxt = str(xsd_type).lower()
@@ -488,6 +507,7 @@ def _create_patch(model,
     outer_values_node.text = rqet.null_xml_text
 
     if discrete and const_value is None:
+
         if null_value is None:
             if str(xsd_type).startswith('u'):
                 null_value = 4294967295  # 2^32 - 1, used as default even for 64 bit data!
@@ -507,6 +527,11 @@ def _create_patch(model,
 
     else:
 
+        # TODO: handle bool const_value as special case
+        if isinstance(const_value, bool):
+            const_value = str(const_value).lower()
+            xsd_type = 'boolean'
+
         const_value_node = rqet.SubElement(outer_values_node, ns['resqml2'] + 'Value')
         const_value_node.set(ns['xsi'] + 'type', ns['xsd'] + xsd_type)
         const_value_node.text = str(const_value)