resqpy 4.16.2__tar.gz → 4.16.3__tar.gz

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

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

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

@@ -9,7 +9,7 @@ build-backend = "poetry.masonry.api"
 
 [tool.poetry]
 name = "resqpy"
-version = "4.16.2" # 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.2 → resqpy-4.16.3}/resqpy/__init__.py

@@ -28,6 +28,6 @@
 
 import logging
 
-__version__ = "4.16.2"  # 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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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.2 → 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."""

{resqpy-4.16.2 → 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
 

{resqpy-4.16.2 → resqpy-4.16.3}/resqpy/well/_blocked_well.py

@@ -328,6 +328,7 @@ class BlockedWell(BaseResqpy):
 
     def __find_grid_node(self, node, unique_grid_indices):
         """Find the BlockedWell object's grid reference node(s)."""
+
         grid_node_list = rqet.list_of_tag(node, 'Grid')
         assert len(grid_node_list) > 0, 'blocked well grid reference(s) not found in xml'
         assert unique_grid_indices[0] >= -1 and unique_grid_indices[-1] < len(
@@ -344,6 +345,7 @@ class BlockedWell(BaseResqpy):
 
     def extract_property_collection(self, refresh = False):
         """Returns a property collection for the blocked well."""
+
         if self.property_collection is None or refresh:
             self.property_collection = rqp.PropertyCollection(support = self)
         return self.property_collection
@@ -407,6 +409,7 @@ class BlockedWell(BaseResqpy):
 
     def interval_for_cell(self, cell_index):
         """Returns the interval index for a given cell index (identical if there are no unblocked intervals)."""
+
         assert 0 <= cell_index < self.cell_count
         if self.node_count == self.cell_count + 1:
             return cell_index
@@ -424,11 +427,13 @@ class BlockedWell(BaseResqpy):
             (float, float) being the entry and exit measured depths for the cell, along the trajectory;
             uom is held in trajectory object
         """
+
         interval = self.interval_for_cell(cell_index)
         return (self.node_mds[interval], self.node_mds[interval + 1])
 
     def _set_cell_interval_map(self):
         """Sets up an index mapping from blocked cell index to interval index, accounting for unblocked intervals."""
+
         self.cell_interval_map = np.zeros(self.cell_count, dtype = int)
         ci = 0
         for ii in range(self.node_count - 1):
@@ -718,6 +723,7 @@ class BlockedWell(BaseResqpy):
 
     def __derive_from_wellspec_check_well_name(self, well_name):
         """Set the well name to be used in the wellspec file."""
+
         if well_name:
             self.well_name = well_name
         else:
@@ -1211,6 +1217,7 @@ class BlockedWell(BaseResqpy):
     @staticmethod
     def __verify_header_lines_in_cellio_file(fp, well_name, cellio_file):
         """Find and verify the information in the header lines for the specified well in the RMS cellio file."""
+
         while True:
             kf.skip_blank_lines_and_comments(fp)
             line = fp.readline()  # file format version number?
@@ -1637,41 +1644,46 @@ class BlockedWell(BaseResqpy):
             if skip_interval_due_to_min_kh:
                 continue
 
-            length, radw_i, skin_i, radb, wi, wbc = BlockedWell.__get_pc_arrays_for_interval(pc = pc,
-                                                                                             pc_timeless = pc_timeless,
-                                                                                             pc_titles = pc_titles,
-                                                                                             ci = ci,
-                                                                                             length = length,
-                                                                                             radw = radw,
-                                                                                             skin = skin,
-                                                                                             length_uom = length_uom,
-                                                                                             grid = grid,
-                                                                                             traj_crs = traj_crs)
+            length, radw_i, skin_i, radb, wi, wbc, stat_i =  \
+                BlockedWell.__get_pc_arrays_for_interval(pc = pc,
+                                                         pc_timeless = pc_timeless,
+                                                         pc_titles = pc_titles,
+                                                         ci = ci,
+                                                         length = length,
+                                                         radw = radw,
+                                                         skin = skin,
+                                                         stat = stat,
+                                                         length_uom = length_uom,
+                                                         grid = grid,
+                                                         traj_crs = traj_crs)
             if skin_i is None:
                 skin_i = 0.0
             if radw_i is None:
                 radw_i = (0.33 if length_uom == 'ft' else 0.1)
-
-            radb, wi, wbc = BlockedWell.__get_well_inflow_parameters_for_interval(do_well_inflow = do_well_inflow,
-                                                                                  isotropic_perm = isotropic_perm,
-                                                                                  ntg_is_one = ntg_is_one,
-                                                                                  k_i = k_i,
-                                                                                  k_j = k_j,
-                                                                                  k_k = k_k,
-                                                                                  sine_anglv = sine_anglv,
-                                                                                  cosine_anglv = cosine_anglv,
-                                                                                  sine_angla = sine_angla,
-                                                                                  cosine_angla = cosine_angla,
-                                                                                  grid = grid,
-                                                                                  cell_kji0 = cell_kji0,
-                                                                                  radw = radw_i,
-                                                                                  radb = radb,
-                                                                                  wi = wi,
-                                                                                  wbc = wbc,
-                                                                                  skin = skin_i,
-                                                                                  kh = kh,
-                                                                                  length_uom = length_uom,
-                                                                                  column_list = column_list)
+            if stat_i is None:
+                stat_i = stat
+
+            radb, wi, wbc =  \
+                BlockedWell.__get_well_inflow_parameters_for_interval(do_well_inflow = do_well_inflow,
+                                                                      isotropic_perm = isotropic_perm,
+                                                                      ntg_is_one = ntg_is_one,
+                                                                      k_i = k_i,
+                                                                      k_j = k_j,
+                                                                      k_k = k_k,
+                                                                      sine_anglv = sine_anglv,
+                                                                      cosine_anglv = cosine_anglv,
+                                                                      sine_angla = sine_angla,
+                                                                      cosine_angla = cosine_angla,
+                                                                      grid = grid,
+                                                                      cell_kji0 = cell_kji0,
+                                                                      radw = radw_i,
+                                                                      radb = radb,
+                                                                      wi = wi,
+                                                                      wbc = wbc,
+                                                                      skin = skin_i,
+                                                                      kh = kh,
+                                                                      length_uom = length_uom,
+                                                                      column_list = column_list)
 
             xyz = self.__get_xyz_for_interval(doing_xyz = doing_xyz,
                                               length_mode = length_mode,
@@ -1703,7 +1715,7 @@ class BlockedWell(BaseResqpy):
                                                                  kh = kh,
                                                                  xyz = xyz,
                                                                  md = md,
-                                                                 stat = stat,
+                                                                 stat = stat_i,
                                                                  part_perf_fraction = part_perf_fraction,
                                                                  radb = radb,
                                                                  wi = wi,
@@ -1751,6 +1763,7 @@ class BlockedWell(BaseResqpy):
                                        fraction of wellbore frame interval in cell,
                                        fraction of cell's wellbore interval in wellbore frame interval)
         """
+
         return bwf.blocked_well_frame_contributions_list(self, wbf)
 
     def add_properties_from_wellbore_frame(self,
@@ -1965,8 +1978,10 @@ class BlockedWell(BaseResqpy):
             stat = str(stat).upper()
             if 'STAT' not in column_list:
                 column_list.append('STAT')
-        else:
-            stat = 'ON'
+
+
+#         else:
+#             stat = 'ON'
 
         if radw is not None and 'RADW' not in column_list:
             column_list.append('RADW')
@@ -2418,29 +2433,37 @@ class BlockedWell(BaseResqpy):
         return kh
 
     @staticmethod
-    def __get_pc_arrays_for_interval(pc, pc_timeless, pc_titles, ci, length, radw, skin, length_uom, grid, traj_crs):
+    def __get_pc_arrays_for_interval(pc, pc_timeless, pc_titles, ci, length, radw, skin, stat, length_uom, grid,
+                                     traj_crs):
         """Get the property collection arrays for the interval."""
 
         def get_item(v, title, pc_titles, pc, pc_timeless, ci, uom):
 
             def pk_for_title(title):
-                d = {'RADW': 'wellbore radius', 'RADB': 'block equivalent radius', 'SKIN': 'skin'}
+                d = {
+                    'RADW': 'wellbore radius',
+                    'RADB': 'block equivalent radius',
+                    'SKIN': 'skin',
+                    'STAT': 'well connection open'
+                }
                 return d.get(title)
 
+            p = None
+            pk = pk_for_title(title)
             pc_uom = None
-            if title in pc_titles:
-                p = pc.singleton(citation_title = title)
-                v = pc.cached_part_array_ref(p)[ci]
-                pc_uom = pc.uom_for_part(p)
-            elif pc_timeless is not None:
-                p = pc_timeless.singleton(citation_title = title)
-                if p is None:
-                    pk = pk_for_title(title)
-                    if pk is not None:
-                        p = pc_timeless.singleton(property_kind = pk)
+            for try_pc in [pc, pc_timeless]:
+                if try_pc is None:
+                    continue
+                if title in pc_titles:
+                    p = try_pc.singleton(citation_title = title)
+                if p is None and pk is not None:
+                    p = try_pc.singleton(property_kind = pk)
                 if p is not None:
-                    v = pc_timeless.cached_part_array_ref(p)[ci]
-                    pc_uom = pc.uom_for_part(p)
+                    v = try_pc.cached_part_array_ref(p)[ci]
+                    pc_uom = try_pc.uom_for_part(p)
+                    break
+            if (title == 'STAT' or pk == 'well connection open') and v is not None and not isinstance(v, str):
+                v = 'ON' if v else 'OFF'
             if pc_uom is not None and uom is not None and pc_uom != uom:
                 v = wam.convert_lengths(v, pc_uom, uom)
             return v
@@ -2453,6 +2476,7 @@ class BlockedWell(BaseResqpy):
             r_uom = length_uom
         length = get_item(length, 'LENGTH', pc_titles, pc, pc_timeless, ci, l_uom)
         radw = get_item(radw, 'RADW', pc_titles, pc, pc_timeless, ci, r_uom)
+        stat = get_item(stat, 'STAT', pc_titles, pc, pc_timeless, ci, None)
         assert radw is None or radw > 0.0  # todo: allow zero for inactive intervals?
         skin = get_item(skin, 'SKIN', pc_titles, pc, pc_timeless, ci, None)
         if skin is None:
@@ -2463,7 +2487,7 @@ class BlockedWell(BaseResqpy):
         wi = get_item(None, 'WI', pc_titles, pc, pc_timeless, ci, None)
         wbc = get_item(None, 'WBC', pc_titles, pc, pc_timeless, ci, None)
 
-        return length, radw, skin, radb, wi, wbc
+        return length, radw, skin, radb, wi, wbc, stat
 
     @staticmethod
     def __get_well_inflow_parameters_for_interval(do_well_inflow, isotropic_perm, ntg_is_one, k_i, k_j, k_k, sine_anglv,
@@ -2689,6 +2713,7 @@ class BlockedWell(BaseResqpy):
             this method currently only handles single grid situations;
             dataframe rows must be in the same order as the cells in the blocked well
         """
+
         # todo: enhance to handle multiple grids
         assert len(self.grid_list) == 1
         if columns is None or len(columns) == 0 or len(df) == 0:
@@ -2713,8 +2738,9 @@ class BlockedWell(BaseResqpy):
             # 'SKIN': use defaults for now; todo: create local property kind for skin
             if column == 'STAT':
                 col_as_list = list(df[column])
-                expanded = np.array([(0 if (str(st).upper() in ['OFF', '0']) else 1) for st in col_as_list],
-                                    dtype = int)
+                expanded = np.array([(0 if (str(st).upper() in ['OFF', '0', 'FALSE']) else 1) for st in col_as_list],
+                                    dtype = np.int8)
+                dtype = np.int8
             else:
                 expanded = df[column].to_numpy(dtype = dtype, copy = True, na_value = na_value)
             extra_pc.add_cached_array_to_imported_list(
@@ -2739,6 +2765,7 @@ class BlockedWell(BaseResqpy):
 
     def _get_uom_pk_discrete_for_df_properties(self, extra, length_uom, temperature_uom = None):
         """Set the property kind and unit of measure for all properties in the dataframe."""
+
         # todo: this is horribly inefficient, building a whole dictionary for every call but only using one entry
         if length_uom not in ['m', 'ft']:
             raise ValueError(f"The length_uom {length_uom} must be either 'm' or 'ft'.")
@@ -3297,6 +3324,7 @@ class BlockedWell(BaseResqpy):
     def __create_trajectory_xml_if_needed(self, create_for_trajectory_if_needed, add_as_part, add_relationships,
                                           originator, ext_uuid, title):
         """Create root node for associated Trajectory object if necessary."""
+
         if create_for_trajectory_if_needed and self.trajectory_to_be_written and self.trajectory.root is None:
             md_datum_root = self.trajectory.md_datum.create_xml(add_as_part = add_as_part,
                                                                 add_relationships = add_relationships,
@@ -3311,6 +3339,7 @@ class BlockedWell(BaseResqpy):
 
     def __create_bw_node_sub_elements(self, bw_node):
         """Append sub-elements to the BlockedWell object's root node."""
+
         nc_node = rqet.SubElement(bw_node, ns['resqml2'] + 'NodeCount')
         nc_node.set(ns['xsi'] + 'type', ns['xsd'] + 'positiveInteger')
         nc_node.text = str(self.node_count)
@@ -3369,7 +3398,8 @@ class BlockedWell(BaseResqpy):
         fis_values_node.set(ns['xsi'] + 'type', ns['eml'] + 'Hdf5Dataset')
         fis_values_node.text = rqet.null_xml_text
 
-        return nc_node, mds_node, mds_values_node, cc_node, cis_node, cnull_node, cis_values_node, gis_node, gnull_node, gis_values_node, fis_node, fnull_node, fis_values_node
+        return (nc_node, mds_node, mds_values_node, cc_node, cis_node, cnull_node, cis_values_node, gis_node,
+                gnull_node, gis_values_node, fis_node, fnull_node, fis_values_node)
 
     def __create_trajectory_grid_wellbore_interpretation_reference_nodes(self, bw_node):
         """Create nodes and add to BlockedWell object root node."""

{resqpy-4.16.2 → resqpy-4.16.3}/resqpy/well/_trajectory.py

@@ -419,8 +419,13 @@ class Trajectory(BaseResqpy):
             set_tangent_vectors = True):
         """Load MD and control points (xyz) data directly from numpy arrays."""
 
+        if isinstance(mds, list) or isinstance(mds, tuple):
+            mds = np.array(mds, dtype = float)
+        assert mds.ndim == 1
         self.knot_count = len(mds)
         assert self.knot_count >= 2  # vertical well could be hamdled by allowing a single station in survey?
+        if isinstance(control_points, list) or isinstance(control_points, tuple):
+            control_points = np.array(control_points, dtype = float)
         assert control_points.shape == (self.knot_count, 3)
         self.line_kind_index = 5  # assume minimum curvature spline
         self.md_uom = wam.rq_length_unit(md_uom)