resqpy 4.14.4__tar.gz → 4.15.1__tar.gz

{resqpy-4.14.4 → resqpy-4.15.1}/PKG-INFO

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

{resqpy-4.14.4 → resqpy-4.15.1}/pyproject.toml

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

{resqpy-4.14.4 → resqpy-4.15.1}/resqpy/__init__.py

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

{resqpy-4.14.4 → resqpy-4.15.1}/resqpy/property/__init__.py

@@ -1,14 +1,14 @@
 """Collections of properties for grids, wellbore frames, grid connection sets etc."""
 
 __all__ = [
-    'PropertyCollection', 'Property', 'WellLog', 'WellIntervalProperty', 'WellIntervalPropertyCollection',
-    'WellLogCollection', 'StringLookup', 'PropertyKind', 'GridPropertyCollection',
+    'PropertyCollection', 'Property', 'AttributePropertySet', 'ApsProperty', 'WellLog', 'WellIntervalProperty',
+    'WellIntervalPropertyCollection', 'WellLogCollection', 'StringLookup', 'PropertyKind', 'GridPropertyCollection',
     'property_over_time_series_from_collection', 'property_collection_for_keyword', 'infer_property_kind',
     'write_hdf5_and_create_xml_for_active_property', 'reformat_column_edges_to_resqml_format',
     'reformat_column_edges_from_resqml_format', 'same_property_kind', 'selective_version_of_collection',
     'supported_local_property_kind_list', 'supported_property_kind_list', 'supported_facet_type_list',
     'expected_facet_type_dict', 'create_transmisibility_multiplier_property_kind',
-    'property_kind_and_facet_from_keyword', 'guess_uom', 'property_parts', 'property_part'
+    'property_kind_and_facet_from_keyword', 'guess_uom', 'property_parts', 'property_part', 'make_aps_key'
 ]
 
 from .property_common import property_collection_for_keyword,  \
@@ -30,6 +30,7 @@ from .property_common import property_collection_for_keyword,  \
 from .property_kind import PropertyKind, create_transmisibility_multiplier_property_kind
 from .string_lookup import StringLookup
 from .property_collection import PropertyCollection
+from .attribute_property_set import AttributePropertySet, ApsProperty, make_aps_key
 from .grid_property_collection import GridPropertyCollection
 from ._property import Property
 from .well_interval_property import WellIntervalProperty

resqpy-4.15.1/resqpy/property/attribute_property_set.py

@@ -0,0 +1,273 @@
+"""Class handling set of RESQML properties using attribute syntax for properties and their metadata."""
+
+# Nexus is a registered trademark of the Halliburton Company
+
+import logging
+
+log = logging.getLogger(__name__)
+
+import numpy as np
+import numpy.ma as ma
+
+import resqpy.property as rqp
+
+
+class ApsProperty:
+    """Class holding a single property with attribute style read access to metadata items."""
+
+    # note: this class could be private to the AttributePropertySet class
+
+    def __init__(self, aps, part):
+        """Initialise a single property from a property set with attribute style read access to metadata items."""
+        self.aps = aps
+        self._part = part
+        self.key = aps._key(part)
+
+    # NB. the following are read-only attributes
+
+    @property
+    def part(self):
+        """The part (string) identifier for this property."""
+        return self._part
+
+    @part.setter
+    def part(self, value):
+        self._part = value
+
+    @property
+    def node(self):
+        """The xml root node for this property."""
+        return self.aps.node_for_part(self.part)
+
+    @property
+    def uuid(self):
+        """The uuid for this property."""
+        return self.aps.uuid_for_part(self.part)
+
+    @property
+    def array_ref(self):
+        """The cached numpy array of values for this property."""
+        return self.aps.cached_part_array_ref(self.part)
+
+    @property
+    def values(self):
+        """A copy of the numpy array of values for this property."""
+        return self.array_ref.copy()
+
+    @property
+    def property_kind(self):
+        """The property kind of this property."""
+        return self.aps.property_kind_for_part(self.part)
+
+    @property
+    def facet_type(self):
+        """The facet type for this property (may be None)."""
+        return self.aps.facet_type_for_part(self.part)
+
+    @property
+    def facet(self):
+        """The facet value for this property (may be None)."""
+        return self.aps.facet_for_part(self.part)
+
+    @property
+    def indexable(self):
+        """The indexable element for this property (synonymous with indexable_element)."""
+        return self.aps.indexable_for_part(self.part)
+
+    @property
+    def indexable_element(self):
+        """The indexable element for this property (synonymous with indexable)."""
+        return self.indexable
+
+    @property
+    def is_continuous(self):
+        """Boolean indicating whether this property is continuous."""
+        return self.aps.continuous_for_part(self.part)
+
+    @property
+    def is_categorical(self):
+        """Boolean indicating whether this property is categorical."""
+        return self.aps.part_is_categorical(self.part)
+
+    @property
+    def is_discrete(self):
+        """Boolean indicating whether this property is discrete (False for categorical properties)."""
+        return not (self.is_continuous or self.is_categorical)
+
+    @property
+    def is_points(self):
+        """Boolean indicating whether this is a points property."""
+        return self.aps.points_for_part(self.part)
+
+    @property
+    def count(self):
+        """The count (number of sub-elements per element, usually 1) for this property."""
+        return self.aps.count_for_part(self.part)
+
+    @property
+    def uom(self):
+        """The unit of measure for this property (will be None for discrete or categorical properties)."""
+        return self.aps.uom_for_part(self.part)
+
+    @property
+    def null_value(self):
+        """The null value for this property (will be None for continuous properties, for which NaN is always the null value)."""
+        return self.aps.null_value_for_part(self.part)
+
+    @property
+    def realization(self):
+        """The realisation number for this property (may be None)."""
+        return self.aps.realization_for_part(self.part)
+
+    @property
+    def time_index(self):
+        """The time index for this property (may be None)."""
+        return self.aps.time_index_for_part(self.part)
+
+    @property
+    def title(self):
+        """The citation title for this property (synonymous with citation_title)."""
+        return self.aps.citation_title_for_part(self.part)
+
+    @property
+    def citation_title(self):
+        """The citation title for this property (synonymous with title)."""
+        return self.title
+
+    @property
+    def min_value(self):
+        """The minimum value for this property, as stored in xml metadata."""
+        return self.aps.minimum_value_for_part(self.part)
+
+    @property
+    def max_value(self):
+        """The maximum value for this property, as stored in xml metadata."""
+        return self.aps.maximum_value_for_part(self.part)
+
+    @property
+    def constant_value(self):
+        """The constant value for this property, as stored in xml metadata (usually None)."""
+        return self.aps.constant_value_for_part(self.part)
+
+    @property
+    def extra(self):
+        """The extra metadata for this property (synonymous with extra_metadata)."""
+        return self.aps.extra_metadata_for_part(self.part)
+
+    @property
+    def extra_metadata(self):
+        """The extra metadata for this property (synonymous with extra)."""
+        return self.extra
+
+    @property
+    def support_uuid(self):
+        """The uuid of the supporting representation for this property."""
+        return self.aps.support_uuid_for_part(self.part)
+
+    @property
+    def string_lookup_uuid(self):
+        """The uuid of the string lookup table for a categorical property (otherwise None)."""
+        return self.aps.string_lookup_uuid_for_part(self.part)
+
+    @property
+    def time_series_uuid(self):
+        """The uuid of the time series for this property (may be None)."""
+        return self.aps.time_series_uuid_for_part(self.part)
+
+    @property
+    def local_property_kind_uuid(self):
+        """The uuid of the local property kind for this property (may be None)."""
+        return self.aps.local_property_kind_uuid(self.part)
+
+
+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'):
+        """Initialise an empty property set, optionally populate properties from a supporting representation.
+
+        arguments:
+           model (Model, optional): required if property_set_uuid is not None
+           support (optional): a grid.Grid object, or a well.BlockedWell, or a well.WellboreFrame object which belongs to a
+              resqpy.Model which includes associated properties; if this argument is given, and property_set_root is None,
+              the properties in the support's parent model which are for this representation (ie. have this object as the
+              supporting representation) are added to this collection as part of the initialisation
+           property_set_uuid (optional): if present, the collection is populated with the properties defined in the xml tree
+              of the property set
+           realization (integer, optional): if present, the single realisation (within an ensemble) that this collection is for;
+              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
+
+        note:
+           at present, if the collection is being initialised from a property set, the support argument must also be specified;
+           also for now, if not initialising from a property set, all properties related to the support are included, whether
+           the relationship is supporting representation or some other relationship;
+
+        :meta common:
+        """
+
+        assert key_mode in ['pk', 'title']
+        assert property_set_uuid is None or model is not None
+        assert support is None or model is None or support.model is model
+        if property_set_uuid is None:
+            property_set_root = None
+        else:
+            property_set_root = model.root_for_uuid(property_set_uuid)
+
+        super().__init__(support = support, property_set_root = property_set_root, realization = realization)
+        self.key_mode = key_mode
+        self._make_attributes()
+
+    def keys(self):
+        """Iterator over property keys within the set."""
+        for p in self.parts():
+            yield self._key(p)
+
+    def properties(self):
+        """Iterator over ApsProperty members of the set."""
+        for k in self.keys():
+            yield getattr(self, k)
+
+    def items(self):
+        """Iterator over (key, ApsProperty) members of the set."""
+        for k in self.keys():
+            yield (k, getattr(self, k))
+
+    def _key(self, part):
+        """Returns the key (attribute name) for a given part."""
+        return make_aps_key(self.key_mode,
+                            property_kind = self.property_kind_for_part(part),
+                            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))
+
+    def _make_attributes(self):
+        """Setup individual properties with attribute style read access to metadata."""
+        for part in self.parts():
+            key = self._key(part)
+            aps_property = ApsProperty(self, part)
+            setattr(self, key, aps_property)
+
+    def __len__(self):
+        """Returns the number of properties in the set."""
+        return self.number_of_parts()
+
+
+def make_aps_key(key_mode, property_kind = None, title = None, facet = None, time_index = None, realization = 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 facet is not None:
+            key += f'_{facet}'
+    else:
+        assert title is not None
+        key = title
+    key = key.replace(' ', '_')
+    if time_index is not None:
+        key += f'_t{time_index}'
+    if realization is not None:
+        key += f'_r{realization}'
+    return key