ansys-pyensight-core 0.7.8__py3-none-any.whl → 0.7.9__py3-none-any.whl

ansys/pyensight/core/utils/query.py

@@ -160,27 +160,31 @@ class Query:
         >>>             point1=pnt1, point2=pnt2, new_plotter=True)
 
         """
-        if query_type not in [self.DISTANCE_PART1D, self.DISTANCE_LINE, self.DISTANCE_SPLINE]:
-            raise RuntimeError(f"Invalid query type: {query_type} specified.")
+        if query_type not in [
+            self.DISTANCE_PART1D,
+            self.DISTANCE_LINE,
+            self.DISTANCE_SPLINE,
+        ]:  # pragma: no cover
+            raise RuntimeError(f"Invalid query type: {query_type} specified.")  # pragma: no cover
 
         var1 = self._get_variable(variable1)
         var2 = self._get_variable(variable2, "DISTANCE")
 
         if query_type == self.DISTANCE_LINE:
-            if (point1 is None) or (point2 is None):
-                raise RuntimeError("Both point1 and point2 must be specified.")
+            if (point1 is None) or (point2 is None):  # pragma: no cover
+                raise RuntimeError("Both point1 and point2 must be specified.")  # pragma: no cover
             self._create_query_core_begin(name, part_list)
             self._ensight.query_ent_var.number_of_sample_pts(num_samples)
             self._ensight.query_ent_var.constrain("line_tool")
             self._ensight.query_ent_var.line_loc(1, *point1)
             self._ensight.query_ent_var.line_loc(2, *point2)
 
-        elif query_type == self.DISTANCE_PART1D:
+        elif query_type == self.DISTANCE_PART1D:  # pragma: no cover
             self._create_query_core_begin(name, part_list, single=True)
             self._ensight.query_ent_var.constrain("1d_part")
             self._ensight.query_ent_var.multiple_segments_by(segments_by)
 
-        elif query_type == self.DISTANCE_SPLINE:
+        elif query_type == self.DISTANCE_SPLINE:  # pragma: no cover
             if spline_name is None:
                 raise RuntimeError("A spline_name must be specified.")
             self._create_query_core_begin(name, part_list)
@@ -291,7 +295,7 @@ class Query:
         >>> s.ensight.utils.query.TEMPORAL_MAXIMUM, parts, "plastic", new_plotter=True)
 
         """
-        if query_type not in [
+        if query_type not in [  # pragma: no cover
             self.TEMPORAL_NODE,
             self.TEMPORAL_ELEMENT,
             self.TEMPORAL_IJK,
@@ -299,19 +303,19 @@ class Query:
             self.TEMPORAL_MINIMUM,
             self.TEMPORAL_MAXIMUM,
         ]:
-            raise RuntimeError(f"Invalid query type: {query_type} specified.")
+            raise RuntimeError(f"Invalid query type: {query_type} specified.")  # pragma: no cover
 
         var1 = self._get_variable(variable1)
         var2 = self._get_variable(variable2, "TIME")
 
         # default the time range
-        if start_time is None:
+        if start_time is None:  # pragma: no cover
             start_time = self._ensight.objs.core.SOLUTIONTIME_LIMITS[0]
-        if end_time is None:
+        if end_time is None:  # pragma: no cover
             end_time = self._ensight.objs.core.SOLUTIONTIME_LIMITS[1]
 
         # default the number of timesteps
-        if num_samples is None:
+        if num_samples is None:  # pragma: no cover
             num_samples = (
                 self._ensight.objs.core.TIMESTEP_LIMITS[1]
                 - self._ensight.objs.core.TIMESTEP_LIMITS[0]
@@ -319,38 +323,38 @@ class Query:
             )
 
         if query_type == self.TEMPORAL_NODE:
-            if node_id is None:
-                raise RuntimeError("node_id must be specified.")
+            if node_id is None:  # pragma: no cover
+                raise RuntimeError("node_id must be specified.")  # pragma: no cover
             self._create_query_core_begin(name, part_list)
             self._ensight.query_ent_var.constrain("node")
             self._ensight.query_ent_var.node_id(node_id)
 
         elif query_type == self.TEMPORAL_ELEMENT:
-            if element_id is None:
-                raise RuntimeError("element_id must be specified.")
+            if element_id is None:  # pragma: no cover
+                raise RuntimeError("element_id must be specified.")  # pragma: no cover
             self._create_query_core_begin(name, part_list)
             self._ensight.query_ent_var.constrain("element")
             self._ensight.query_ent_var.elem_id(element_id)
 
         elif query_type == self.TEMPORAL_XYZ:
-            if xyz is None:
-                raise RuntimeError("xyz must be specified.")
+            if xyz is None:  # pragma: no cover
+                raise RuntimeError("xyz must be specified.")  # pragma: no cover
             self._create_query_core_begin(name, part_list)
             self._ensight.query_ent_var.constrain("cursor")
             self._ensight.query_ent_var.cursor_loc(*xyz)
 
         elif query_type == self.TEMPORAL_IJK:
-            if ijk is None:
-                raise RuntimeError("ijk must be specified.")
-            self._create_query_core_begin(name, part_list)
-            self._ensight.query_ent_var.constrain("ijk")
-            self._ensight.query_ent_var.ijk(*ijk)
+            if ijk is None:  # pragma: no cover
+                raise RuntimeError("ijk must be specified.")  # pragma: no cover
+            self._create_query_core_begin(name, part_list)  # pragma: no cover
+            self._ensight.query_ent_var.constrain("ijk")  # pragma: no cover
+            self._ensight.query_ent_var.ijk(*ijk)  # pragma: no cover
 
         elif query_type == self.TEMPORAL_MINIMUM:
             self._create_query_core_begin(name, part_list)
             self._ensight.query_ent_var.constrain("min")
 
-        elif query_type == self.TEMPORAL_MAXIMUM:
+        elif query_type == self.TEMPORAL_MAXIMUM:  # pragma: no cover
             self._create_query_core_begin(name, part_list)
             self._ensight.query_ent_var.constrain("max")
 
@@ -388,12 +392,12 @@ class Query:
         try:
             query = max(self._ensight.objs.core.QUERIES)
             # no new id allocated
-            if query.__OBJID__ < nextid:
-                error_msg = "Unable to create the specified query."
-        except ValueError:
-            error_msg = "Unable to create the specified query."
-        if error_msg:
-            raise RuntimeError(error_msg)
+            if query.__OBJID__ < nextid:  # pragma: no cover
+                error_msg = "Unable to create the specified query."  # pragma: no cover
+        except ValueError:  # pragma: no cover
+            error_msg = "Unable to create the specified query."  # pragma: no cover
+        if error_msg:  # pragma: no cover
+            raise RuntimeError(error_msg)  # pragma: no cover
         return query
 
     def _create_query_core_begin(self, name: str, parts: Optional[List[int]], single=False) -> None:
@@ -414,14 +418,16 @@ class Query:
 
         """
         part_list = []
-        if parts:
+        if parts:  # pragma: no cover
             for p in parts:
-                if type(p) == str:
-                    part_list.append(self._ensight.objs.core.PARTS[p][0].PARTNUMBER)
-                elif type(p) == int:
-                    part_list.append(p)
+                if type(p) == str:  # pragma: no cover
+                    part_list.append(
+                        self._ensight.objs.core.PARTS[p][0].PARTNUMBER
+                    )  # pragma: no cover
+                elif type(p) == int:  # pragma: no cover
+                    part_list.append(p)  # pragma: no cover
                 else:
-                    if hasattr(p, "PARTNUMBER"):
+                    if hasattr(p, "PARTNUMBER"):  # pragma: no cover
                         part_list.append(p.PARTNUMBER)
         if not single:
             self._ensight.part.select_begin(part_list)