resqpy 4.16.1__tar.gz → 4.16.3__tar.gz

{resqpy-4.16.1 → resqpy-4.16.3}/PKG-INFO

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

{resqpy-4.16.1 → resqpy-4.16.3}/pyproject.toml

@@ -9,7 +9,7 @@ build-backend = "poetry.masonry.api"
 
 [tool.poetry]
 name = "resqpy"
-version = "4.16.1" # Set at build time
+version = "4.16.3" # Set at build time
 description = "Python API for working with RESQML models"
 authors = ["BP"]
 license = "MIT"

{resqpy-4.16.1 → resqpy-4.16.3}/resqpy/__init__.py

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

{resqpy-4.16.1 → resqpy-4.16.3}/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-4.16.1 → resqpy-4.16.3}/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):
@@ -719,9 +720,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-4.16.1 → resqpy-4.16.3}/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.
 

{resqpy-4.16.1 → resqpy-4.16.3}/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)

{resqpy-4.16.1 → resqpy-4.16.3}/resqpy/olio/xml_et.py

@@ -778,6 +778,18 @@ def load_metadata_from_xml(node):
     return extra_metadata
 
 
+def find_metadata_item_node_in_xml(node, key):
+    """Returns the extra metadata node for a particular key, if present."""
+
+    if node is None:
+        return None
+    meta_nodes = list_of_tag(node, 'ExtraMetadata')
+    for meta in meta_nodes:
+        if find_tag_text(meta, 'Name') == key:
+            return meta
+    return None
+
+
 def create_metadata_xml(node, extra_metadata):
     """Writes the xml for the given metadata dictionary."""
 

{resqpy-4.16.1 → resqpy-4.16.3}/resqpy/property/_collection_add_part.py

@@ -202,6 +202,9 @@ 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
@@ -214,7 +217,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 = None 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]
 
     add_min_max = pcga._process_imported_property_get_add_min_max(points, property_kind, string_lookup_uuid,
                                                                   local_property_kind_uuid, p_array_bool)

{resqpy-4.16.1 → resqpy-4.16.3}/resqpy/property/attribute_property_set.py

@@ -159,6 +159,11 @@ class ApsProperty:
         """The extra metadata for this property (synonymous with extra)."""
         return self.extra
 
+    @property
+    def source(self):
+        """The source extra metadata value for this property (or None)."""
+        return self.aps.source_for_part(self.part)
+
     @property
     def support_uuid(self):
         """The uuid of the supporting representation for this property."""
@@ -183,7 +188,14 @@ class ApsProperty:
 class AttributePropertySet(rqp.PropertyCollection):
     """Class for set of RESQML properties for any supporting representation, using attribute syntax."""
 
-    def __init__(self, model = None, support = None, property_set_uuid = None, realization = None, key_mode = 'pk'):
+    def __init__(self,
+                 model = None,
+                 support = None,
+                 property_set_uuid = None,
+                 realization = None,
+                 key_mode = 'pk',
+                 indexable = None,
+                 multiple_handling = 'warn'):
         """Initialise an empty property set, optionally populate properties from a supporting representation.
 
         arguments:
@@ -198,6 +210,11 @@ class AttributePropertySet(rqp.PropertyCollection):
               if None, then the collection is either covering a whole ensemble (individual properties can each be flagged with a
               realisation number), or is for properties that do not have multiple realizations
            key_mode (str, default 'pk'): either 'pk' (for property kind) or 'title', identifying the basis of property attribute keys
+           indexable (str, optional): if present and key_mode is 'pk', properties with indexable element other than this will
+              have their indexable element included in their key
+           multiple_handling (str, default 'warn'): either 'ignore', 'warn' ,or 'exception'; if 'warn' or 'ignore', and properties
+              exist that generate the same key, then only the first is visible in the attribute property set (and a warning is given
+              for each of the others in the case of 'warn'); if 'exception', a KeyError is raised if there are any duplicate keys
 
         note:
            at present, if the collection is being initialised from a property set, the support argument must also be specified;
@@ -214,9 +231,12 @@ class AttributePropertySet(rqp.PropertyCollection):
             property_set_root = None
         else:
             property_set_root = model.root_for_uuid(property_set_uuid)
+        assert multiple_handling in ['ignore', 'warn', 'exception']
 
         super().__init__(support = support, property_set_root = property_set_root, realization = realization)
         self.key_mode = key_mode
+        self.indexable_mode = indexable
+        self.multiple_handling = multiple_handling
         self._make_attributes()
 
     def keys(self):
@@ -241,12 +261,21 @@ class AttributePropertySet(rqp.PropertyCollection):
                             title = self.citation_title_for_part(part),
                             facet = self.facet_for_part(part),
                             time_index = self.time_index_for_part(part),
-                            realization = self.realization_for_part(part))
+                            realization = self.realization_for_part(part),
+                            indexable_mode = self.indexable_mode,
+                            indexable = self.indexable_for_part(part))
 
     def _make_attributes(self):
         """Setup individual properties with attribute style read access to metadata."""
         for part in self.parts():
             key = self._key(part)
+            if getattr(self, key, None) is not None:
+                if self.multiple_handling == 'warn':
+                    log.warning(f'duplicate key in AttributePropertySet; only first instance included: {key}')
+                    continue
+                if self.multiple_handling == 'ignore':
+                    continue
+                raise KeyError(f'duplicate key in attribute property set: {key}')
             aps_property = ApsProperty(self, part)
             setattr(self, key, aps_property)
 
@@ -255,11 +284,20 @@ class AttributePropertySet(rqp.PropertyCollection):
         return self.number_of_parts()
 
 
-def make_aps_key(key_mode, property_kind = None, title = None, facet = None, time_index = None, realization = None):
+def make_aps_key(key_mode,
+                 property_kind = None,
+                 title = None,
+                 facet = None,
+                 time_index = None,
+                 realization = None,
+                 indexable_mode = None,
+                 indexable = None):
     """Contructs the key (attribute name) for a property based on metadata items."""
     if key_mode == 'pk':
         assert property_kind is not None
         key = property_kind
+        if indexable_mode is not None and indexable is not None and indexable != indexable_mode:
+            key += f'_{indexable}'
         if facet is not None:
             key += f'_{facet}'
     else:

{resqpy-4.16.1 → resqpy-4.16.3}/resqpy/property/property_collection.py

@@ -85,7 +85,7 @@ class PropertyCollection():
         self.realization = realization  # model realization number within an ensemble
         self.null_value = None
         self.imported_list = []
-        # above is list of (uuid, file_name, keyword, cached_name, discrete, uom, time_index, null_value,
+        # 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)
@@ -1300,6 +1300,12 @@ class PropertyCollection():
 
         return [self.citation_title_for_part(p) for p in self.parts()]
 
+    def source_for_part(self, part):
+        """Returns the source string from the part's extra metadata, if present, else None."""
+
+        assert self.model is not None
+        return self.model.source_for_part(part)
+
     def time_series_uuid_for_part(self, part):
         """If the property has an associated time series (is not static), returns the uuid for the time series.
 
@@ -2275,7 +2281,7 @@ class PropertyCollection():
         if cached_array is not None:
             min_value, max_value = pcga._min_max_of_cached_array(self, cached_name, cached_array, null_value, discrete)
         else:
-            if const_value == null_value or (not discrete and np.isnan(const_value)):
+            if const_value == null_value or isinstance(const_value, bool) or (not discrete and np.isnan(const_value)):
                 min_value = max_value = None
             else:
                 min_value = max_value = const_value
@@ -2652,7 +2658,7 @@ class PropertyCollection():
               must cycle fastest in the array, ie. be the last index
            points (bool, default False): if True, this is a points property
            extra_metadata (dictionary, optional): if present, adds extra metadata in the xml
-           const_value (float or int, optional): if present, create xml for a constant array filled with this value
+           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