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

ansys/pyensight/core/listobj.py

@@ -107,12 +107,14 @@ class ensobjlist(List[T]):  # noqa: N801
             value_list = [value]
         out_list: ensobjlist[Any] = ensobjlist(session=self._session)
         for item in self:
-            if isinstance(item, ENSOBJ):
+            if isinstance(item, ENSOBJ):  # pragma: no cover
                 try:
                     item_value = item.getattr(attr)
                     for check_value in value_list:
                         if wildcard == 2:
-                            if fnmatch.fnmatch(str(item_value), str(check_value)):
+                            if fnmatch.fnmatch(
+                                str(item_value), str(check_value)
+                            ):  # pragma: no cover
                                 out_list.append(item)
                                 break
                         elif wildcard > 0:
@@ -123,14 +125,14 @@ class ensobjlist(List[T]):  # noqa: N801
                             if item_value == check_value:
                                 out_list.append(item)
                                 break
-                except RuntimeError:
-                    pass
+                except RuntimeError:  # pragma: no cover
+                    pass  # pragma: no cover
         if group:
             # This is a bit of a hack, but the find() method generates a local list of
             # proxy objects.  We want to put that in a group.  We do that by running
             # a script in EnSight that creates an empty group and then adds those
             # children to the group.  The output becomes the remote referenced ENS_GROUP.
-            if self._session is not None:
+            if self._session is not None:  # pragma: no cover
                 ens_group_cmd = "ensight.objs.core.VPORTS.find('__unknown__', group=1)"
                 ens_group = self._session.cmd(ens_group_cmd)
                 ens_group.addchild(out_list)
@@ -163,14 +165,14 @@ class ensobjlist(List[T]):  # noqa: N801
         """
         session = None
         objid_list = [x.__OBJID__ for x in self if isinstance(x, ENSOBJ)]
-        for item in self:
-            if hasattr(item, "_session"):
+        for item in self:  # pragma: no cover
+            if hasattr(item, "_session"):  # pragma: no cover
                 session = item._session
                 break
-        if session:
+        if session:  # pragma: no cover
             msg = f"ensight.objs.ensobjlist(ensight.objs.wrap_id(x) for x in {objid_list}).set_attr({attr.__repr__()}, {value.__repr__()})"
             return session.cmd(msg)
-        return 0
+        return 0  # pragma: no cover
 
     def get_attr(self, attr: Any, default: Optional[Any] = None):
         """Query a specific attribute for all ENSOBJ objects in the list
@@ -199,20 +201,20 @@ class ensobjlist(List[T]):  # noqa: N801
         """
         session = None
         objid_list = [x.__OBJID__ for x in self if isinstance(x, ENSOBJ)]
-        for item in self:
-            if hasattr(item, "_session"):
+        for item in self:  # pragma: no cover
+            if hasattr(item, "_session"):  # pragma: no cover
                 session = item._session
                 break
         value = None
-        if session:
-            if default:
-                msg = f"ensight.objs.ensobjlist(ensight.objs.wrap_id(x) for x in {objid_list}).get_attr({attr.__repr__()}, {default.__repr__()})"
+        if session:  # pragma: no cover
+            if default:  # pragma: no cover
+                msg = f"ensight.objs.ensobjlist(ensight.objs.wrap_id(x) for x in {objid_list}).get_attr({attr.__repr__()}, {default.__repr__()})"  # pragma: no cover
             else:
                 msg = f"ensight.objs.ensobjlist(ensight.objs.wrap_id(x) for x in {objid_list}).get_attr({attr.__repr__()})"
             value = session.cmd(msg)
-        if value:
+        if value:  # pragma: no cover
             return value
-        return [default] * len(objid_list)
+        return [default] * len(objid_list)  # pragma: no cover
 
     @overload
     def __getitem__(self, index: SupportsIndex) -> T:

ansys/pyensight/core/renderable.py

@@ -563,8 +563,9 @@ class RenderableVNC(Renderable):
         """
         optional_query = self._get_query_parameters_str()
         version = _get_ansysnexus_version(self._session._cei_suffix)
-        if int(self._session._cei_suffix) < 241:
-            self._update_2023R2_or_less()
+        if int(self._session._cei_suffix) < 242:  # pragma: no cover
+            version = ""
+            self._update_2023R2_or_less()  # pragma: no cover
         else:
             html = (
                 f"<script src='/ansys{version}/nexus/viewer-loader.js{optional_query}'></script>\n"
@@ -577,8 +578,8 @@ class RenderableVNC(Renderable):
             )
 
             query_args = ""
-            if self._using_proxy and optional_query:
-                query_args = f', "extra_query_args":"{optional_query[1:]}"'
+            if self._using_proxy and optional_query:  # pragma: no cover
+                query_args = f', "extra_query_args":"{optional_query[1:]}"'  # pragma: no cover
 
             attributes = ' renderer="envnc"'
             attributes += ' ui="simple"'
@@ -693,11 +694,11 @@ class RenderableEVSN(Renderable):
             f'"ws":"{self._http_protocol}://{self._session.html_hostname}:{self._session.ws_port}"'
         )
         secrets = f'"security_token":"{self._session.secret_key}"'
-        if not self._using_proxy or optional_query == "":
+        if not self._using_proxy or optional_query == "":  # pragma: no cover
             attributes += f" renderer_options='{{ {http_uri}, {ws_uri}, {secrets} }}'"
-        else:
-            query_args = f'"extra_query_args":"{optional_query[1:]}"'
-            attributes += f" renderer_options='{{ {http_uri}, {ws_uri}, {secrets}, {query_args} }}'"
+        else:  # pragma: no cover
+            query_args = f'"extra_query_args":"{optional_query[1:]}"'  # pragma: no cover
+            attributes += f" renderer_options='{{ {http_uri}, {ws_uri}, {secrets}, {query_args} }}'"  # pragma: no cover
         html += f"<ansys-nexus-viewer {attributes}></ansys-nexus-viewer>\n"
         # refresh the remote HTML
         self._save_remote_html_page(html)

ansys/pyensight/core/session.py

@@ -172,7 +172,7 @@ class Session:
         # are we in a jupyter notebook?
         try:
             _ = get_ipython()  # type: ignore
-            self._jupyter_notebook = True
+            self._jupyter_notebook = True  # pragma: no cover
         except NameError:
             self._jupyter_notebook = False
 
@@ -279,7 +279,7 @@ class Session:
             If true, actually try to communicate with EnSight. By default false.
         """
         time_start = time.time()
-        while time.time() - time_start < self._timeout:
+        while time.time() - time_start < self._timeout:  # pragma: no cover
             if self._grpc.is_connected():
                 try:
                     if validate:
@@ -287,10 +287,10 @@ class Session:
                         self._cei_suffix = self.cmd("ensight.version('suffix')")
                     self._check_rest_connection()
                     return
-                except OSError:
-                    pass
+                except OSError:  # pragma: no cover
+                    pass  # pragma: no cover
             self._grpc.connect(timeout=self._timeout)
-        raise RuntimeError("Unable to establish a gRPC connection to EnSight.")
+        raise RuntimeError("Unable to establish a gRPC connection to EnSight.")  # pragma: no cover
 
     def _check_rest_connection(self) -> None:
         """Validate the REST API connection works
@@ -532,7 +532,7 @@ class Session:
 
         out = []
         dirlen = 0
-        if localdir:
+        if localdir:  # pragma: no cover
             # we use dirlen + 1 here to remove the '/' inserted by os.path.join()
             dirlen = len(localdir) + 1
         for item in filelist:
@@ -547,7 +547,7 @@ class Session:
                             out.append((fullname[dirlen:], os.stat(fullname).st_size))
             except Exception:
                 pass
-        if progress:
+        if progress:  # pragma: no cover
             try:
                 from tqdm.auto import tqdm
             except ImportError:
@@ -568,7 +568,9 @@ class Session:
                     data = fp.read(chunk_size)
                     if data == b"":
                         break
-                    self.cmd(f"copy_write_function__(r'{name}', {data!r})", do_eval=False)
+                    self.cmd(
+                        f"copy_write_function__(r'{name}', {data!r})", do_eval=False
+                    )  # pragma: no cover
         return out
 
     def copy_from_session(
@@ -713,23 +715,23 @@ class Session:
 
         """
         dirname = os.path.dirname(filename)
-        if not dirname:
-            dirname = "."
+        if not dirname:  # pragma: no cover
+            dirname = "."  # pragma: no cover
         if dirname not in sys.path:
             sys.path.append(dirname)
         module_name, _ = os.path.splitext(os.path.basename(filename))
         # get the module reference
         spec = importlib.util.find_spec(module_name)
-        if spec:
+        if spec:  # pragma: no cover
             module = importlib.util.module_from_spec(spec)
             # insert an ensight interface into the module
             if self.ensight:
                 module.ensight = self.ensight  # type: ignore
                 # load (run) the module
-                if spec.loader:
+                if spec.loader:  # pragma: no cover
                     spec.loader.exec_module(module)
             return module
-        return None
+        return None  # pragma: no cover
 
     def exec(self, function: Callable, *args, remote: bool = False, **kwargs) -> Any:
         """Run a function containing EnSight API calls locally or in the EnSight interpreter.
@@ -812,7 +814,9 @@ class Session:
             # Create a bound object that allows for direct encoding of the args/kwargs params
             # The new function would be bound_function(ensight) where the args are captured
             # in the lambda.
-            bound_function = lambda ens: function(ens, *args, **kwargs)  # noqa: E731
+            bound_function = lambda ens: function(  # noqa: E731  # pragma: no cover
+                ens, *args, **kwargs
+            )
             # Serialize the bound function
             serialized_function = dill.dumps(bound_function, recurse=True)
             self.cmd("import dill", do_eval=False)
@@ -1022,8 +1026,8 @@ class Session:
 
         """
         obj_str = ""
-        if object_id:
-            obj_str = f", id={object_id}"
+        if object_id:  # pragma: no cover
+            obj_str = f", id={object_id}"  # pragma: no cover
         cmd = f"ensight.objs.release_id('{self.name}'{obj_str})"
         _ = self.cmd(cmd, do_eval=False)
 
@@ -1073,9 +1077,9 @@ class Session:
                 spec = importlib.util.spec_from_file_location(
                     f"ansys.pyensight.core.utils.{_name}", _filename
                 )
-                if spec:
+                if spec:  # pragma: no cover
                     _module = importlib.util.module_from_spec(spec)
-                    if spec.loader:
+                    if spec.loader:  # pragma: no cover
                         spec.loader.exec_module(_module)
                     # get the class from the module (query.py filename -> Query() object)
                     _the_class = getattr(_module, _cap_name)
@@ -1329,8 +1333,8 @@ class Session:
 
         """
         base_uri = "https://s3.amazonaws.com/www3.ensight.com/PyEnSight/ExampleData"
-        if root is not None:
-            base_uri = root
+        if root is not None:  # pragma: no cover
+            base_uri = root  # pragma: no cover
         pathname = self.download_pyansys_example(example_name, root=base_uri)
         script = f'outpath = r"""{pathname}"""\n'
         if uncompress:
@@ -1600,8 +1604,8 @@ class Session:
             if tail == -1:
                 tail_len = 12
                 tail = s.find(", cached:yes", offset)
-            if tail == -1:
-                break
+            if tail == -1:  # pragma: no cover
+                break  # pragma: no cover
             # just this object substring
             tmp = s[start + 7 : tail]
             # Subtype (PartType:, AnnotType:, ToolType:)
@@ -1634,7 +1638,7 @@ class Session:
                         if (classname_lookup is not None) and (subtype in classname_lookup):
                             classname = classname_lookup[subtype]
                             subclass_info = f",attr_id={attr_id}, attr_value={subtype}"
-                    elif classname_lookup is not None:
+                    elif classname_lookup is not None:  # pragma: no cover
                         # if a "subclass" case and no subclass attrid value, ask for it...
                         remote_name = self.remote_obj(objid)
                         cmd = f"{remote_name}.getattr({attr_id})"
@@ -1645,8 +1649,8 @@ class Session:
                 if owned_flag:
                     subclass_info += ",owned=True"
                 replace_text = f"session.ensight.objs.{classname}(session, {objid}{subclass_info})"
-            if replace_text is None:
-                break
+            if replace_text is None:  # pragma: no cover
+                break  # pragma: no cover
             offset = start + len(replace_text)
             s = prefix + replace_text + suffix
         s = s.strip()
@@ -1752,7 +1756,7 @@ class Session:
         ens_version = int(self.ensight.version("suffix"))
         # handle various input formats
         target = version
-        if isinstance(target, str):
+        if isinstance(target, str):  # pragma: no cover
             # could be 'year RX' or the suffix as a string
             if "R" in target:
                 tmp = [int(x) for x in target.split("R")]
@@ -1762,14 +1766,14 @@ class Session:
         # check validity
         valid = ens_version == target
         at_least = ""
-        if not strict:
+        if not strict:  # pragma: no cover
             at_least = "at least "
             valid = ens_version >= target
         if (not valid) and exception:
             ens_version = self.ensight.version("version-full")
             base_msg = f" ({at_least}'{version}' required, '{ens_version}' current)"
-            if message:
-                message += base_msg
+            if message:  # pragma: no cover
+                message += base_msg  # pragma: no cover
             else:
                 message = f"A newer version of EnSight is required to use this API:{base_msg}"
             raise InvalidEnSightVersion(message)

ansys/pyensight/core/utils/export.py

@@ -53,10 +53,10 @@ class Export:
             return  # pragma: no cover
         try:
             _ = self._ensight._session.cmd("dir(ensight.utils.export)")
-        except RuntimeError:
-            import ansys.pyensight.core
+        except RuntimeError:  # pragma: no cover
+            import ansys.pyensight.core  # pragma: no cover
 
-            raise RuntimeError(
+            raise RuntimeError(  # pragma: no cover
                 f"Remote EnSight session must have PyEnsight version \
             {ansys.pyensight.core.DEFAULT_ANSYS_VERSION} or higher installed to use this API."
             )
@@ -344,8 +344,8 @@ class Export:
         else:
             num_frames = frames
 
-        if num_frames < 1:
-            raise RuntimeError(
+        if num_frames < 1:  # pragma: no cover
+            raise RuntimeError(  # pragma: no cover
                 "No frames selected. Perhaps a static dataset SOLUTIONTIME request \
                  or no FLIPBOOK/KEYFRAME defined."
             )
@@ -478,7 +478,7 @@ class Export:
         GEOM_EXPORT_STL: ".stl",
     }
 
-    def _geometry_remote(
+    def _geometry_remote(  # pragma: no cover
         self, format: str, starting_timestep: int, frames: int, delta_timestep: int
     ) -> List[bytes]:
         """EnSight-side implementation.
@@ -570,7 +570,7 @@ class Export:
             self._ensight._session.ensight_version_check("2024 R2")
             cmd = f"ensight.utils.export._geometry_remote('{format}', {starting_timestep}, {frames}, {delta_timestep})"
             raw_data_list = self._ensight._session.cmd(cmd)
-        if raw_data_list:
+        if raw_data_list:  # pragma: no cover
             if len(raw_data_list) == 1:
                 with open(filename, "wb") as fp:
                     fp.write(raw_data_list[0])
@@ -580,5 +580,5 @@ class Export:
                     _filename = f"{filename_base}{str(idx).zfill(3)}{extension}"
                     with open(_filename, "wb") as fp:
                         fp.write(raw_data)
-        else:
-            raise IOError("Export was not successful")
+        else:  # pragma: no cover
+            raise IOError("Export was not successful")  # pragma: no cover

ansys/pyensight/core/utils/omniverse_dsg_server.py

@@ -337,6 +337,7 @@ class OmniverseWrapper:
         name = name.replace("<", "_").replace(">", "_")
         name = name.replace("/", "_").replace("=", "_")
         name = name.replace(",", "_").replace(" ", "_")
+        name = name.replace("\\", "_")
         if id_name is not None:
             name = name + "_" + str(id_name)
         if name in self._cleaned_names.values():

ansys/pyensight/core/utils/parts.py

@@ -52,7 +52,7 @@ def convert_variable(
         return var
     elif hasattr(var, "ID"):
         return int(var.ID)
-    return None
+    return None  # pragma: no cover
 
 
 class Parts:
@@ -214,7 +214,7 @@ class Parts:
                 found = ensobjlist([p for p, met in metadata.items() if met.get(tag) == value])
             elif value and not tag:
                 found = ensobjlist([p for p, met in metadata.items() if value in met.values()])
-            elif tag and not value:
+            elif tag and not value:  # pragma: no cover
                 found = ensobjlist([p for p, met in metadata.items() if tag in met.keys()])
         else:
             found = ensobjlist(
@@ -254,8 +254,10 @@ class Parts:
         """Private routine to create emitter objects"""
         new_emitters: List[Any] = []
         if emitter_type == self._EMIT_POINT:
-            if not points:
-                raise RuntimeError("list of points needed if particle trace emitted from points")
+            if not points:  # pragma: no cover
+                raise RuntimeError(
+                    "list of points needed if particle trace emitted from points"
+                )  # pragma: no cover
             for p in points:
                 if isinstance(self.ensight, ModuleType):  # pragma: no cover
                     new_emitters.append(
@@ -280,7 +282,7 @@ class Parts:
                 )
         elif emitter_type == self._EMIT_PLANE:
             if not any([point1, point2, point3]):
-                raise RuntimeError(
+                raise RuntimeError(  # pragma: no cover
                     "point1, point2 and point3 needed if particle trace emitted from plane"
                 )
             if isinstance(self.ensight, ModuleType):  # pragma: no cover
@@ -298,9 +300,11 @@ class Parts:
                 new_emitters.append(
                     f"ensight.utils.parts._EnSEmitterGrid(ensight, point1={point1}, point2={point2}, point3={point3}, num_points_x={num_points_x}, num_points_y={num_points_y})"
                 )
-        elif emitter_type == self._EMIT_PART:
-            if not parts:
-                raise RuntimeError("part and num_points needed if particle trace emitted from part")
+        elif emitter_type == self._EMIT_PART:  # pragma: no cover
+            if not parts:  # pragma: no cover
+                raise RuntimeError(
+                    "part and num_points needed if particle trace emitted from part"
+                )  # pragma: no cover
             for p in parts:
                 if isinstance(self.ensight, ModuleType):  # pragma: no cover
                     new_emitters.append(  # pragma: no cover
@@ -316,7 +320,9 @@ class Parts:
                         f"ensight.utils.parts._EnSEmitterPart(ensight, part={convert_part(self.ensight ,p)}, num_points={num_points}, part_kind={part_distribution_type})"
                     )
         else:
-            raise RuntimeError("No input provided to create the emitters for the particle trace")
+            raise RuntimeError(
+                "No input provided to create the emitters for the particle trace"
+            )  # pragma: no cover
         return new_emitters
 
     def _create_particle_trace_part(
@@ -349,7 +355,7 @@ class Parts:
             def_part.TOTALTIME = total_time
         if delta_time:
             def_part.DELTATIME = delta_time
-        if emit_time:
+        if emit_time:  # pragma: no cover
             def_part.STARTTIME = emit_time
         def_part.DESCRIPTION = name
         def_part.VARIABLE = convert_variable(self.ensight, variable)
@@ -407,15 +413,17 @@ class Parts:
         """Private utility to cure an input particle trace part and convert it to an ``ENS_PART`"""
 
         # the add_emitter* functions were added in 2024 R2
-        if not isinstance(self.ensight, ModuleType):
+        if not isinstance(self.ensight, ModuleType):  # pragma: no cover
             self.ensight._session.ensight_version_check("2024 R2")
 
         _particle_trace_part: "ENS_PART_PARTICLE_TRACE"
-        if isinstance(particle_trace_part, (str, int)):
-            temp = self.ensight.objs.core.PARTS[particle_trace_part]
-            if not temp:
-                raise RuntimeError("particle_trace_part input is not a valid part")
-            _particle_trace_part = temp[0]
+        if isinstance(particle_trace_part, (str, int)):  # pragma: no cover
+            temp = self.ensight.objs.core.PARTS[particle_trace_part]  # pragma: no cover
+            if not temp:  # pragma: no cover
+                raise RuntimeError(
+                    "particle_trace_part input is not a valid part"
+                )  # pragma: no cover
+            _particle_trace_part = temp[0]  # pragma: no cover
         else:
             _particle_trace_part = particle_trace_part
         return _particle_trace_part
@@ -428,29 +436,32 @@ class Parts:
         """Private utility to set the direction if not provided, and to cure the list of source parts."""
 
         # the create_particle* functions were added in 2024 R2
-        if not isinstance(self.ensight, ModuleType):
+        if not isinstance(self.ensight, ModuleType):  # pragma: no cover
             self.ensight._session.ensight_version_check("2024 R2")
 
         if not direction:
             direction = self.PT_POS_TIME
-        if source_parts:
+        if source_parts:  # pragma: no cover
             converted_source_parts = [convert_part(self.ensight, p) for p in source_parts]
-        if not source_parts:
-            converted_source_parts = self.ensight.objs.core.selection(name="ENS_PART")
-        if not converted_source_parts:
-            raise RuntimeError("No part selected for particle trace generation")
+        if not source_parts:  # pragma: no cover
+            converted_source_parts = self.ensight.objs.core.selection(  # pragma: no cover
+                name="ENS_PART"
+            )
+        if not converted_source_parts:  # pragma: no cover
+            raise RuntimeError("No part selected for particle trace generation")  # pragma: no cover
         return direction, converted_source_parts
 
     def _find_palette(self, color_by: Optional[Union[str, int, "ENS_VAR"]] = None) -> Optional[str]:
         """Private utility to find the description of the input color_by variable"""
         palette: Optional[str] = None
         if color_by:
-            _color_by_var: List["ENS_VAR"] = ensight.objs.core.VARIABLES[
-                convert_variable(self.ensight, color_by)
-            ]
-            if _color_by_var:
-                palette = _color_by_var[0].DESCRIPTION
-            else:
+            try:
+                _color_by_var: List["ENS_VAR"] = self.ensight.objs.core.VARIABLES.find(
+                    [convert_variable(self.ensight, color_by)], attr="ID"
+                )
+                if _color_by_var:
+                    palette = _color_by_var[0].DESCRIPTION
+            except Exception:
                 raise RuntimeError(
                     "The variable supplied to color the particle trace by does not exist"
                 )
@@ -1141,20 +1152,23 @@ class Parts:
             p_list = [plist]
         elif isinstance(plist, list) or isinstance(plist, ensobjlist):
             p_list = [p for p in plist]
-        else:
-            raise RuntimeError("Unknown type of input var plist {}".format(type(plist)))
+        else:  # pragma: no cover
+            raise RuntimeError(  # pragma: no cover
+                "Unknown type of input var plist {}".format(type(plist))
+            )
         #
         #  p_list must now be a list
         #
 
         if not p_list:
             return None
-        if not isinstance(p_list[0], (str, int, self.ensight.objs.ENS_PART)):
-            error = "First member is neither ENS_PART, int, nor string"
-            error += f"{p_list[0]} type = {type(p_list[0])}; aborting"
-            raise RuntimeError(error)
+        if not isinstance(p_list[0], (str, int, self.ensight.objs.ENS_PART)):  # pragma: no cover
+            error = "First member is neither ENS_PART, int, nor string"  # pragma: no cover
+            error += f"{p_list[0]} type = {type(p_list[0])}; aborting"  # pragma: no cover
+            raise RuntimeError(error)  # pragma: no cover
         pobjs: List["ENS_PART"]
-        if isinstance(p_list[0], int):  # list of ints must be part ids
+        if isinstance(p_list[0], int):
+            # list of ints must be part ids
             for pid in p_list:
                 pobjs = [p for p in self.ensight.objs.core.PARTS if p.PARTNUMBER == pid]
                 for prt in pobjs:
@@ -1181,5 +1195,5 @@ class Parts:
         if ret_flag == "obj":
             val_objs = [p for p in pobj_list]
             return val_objs
-        val_ints = [int(p.ID) for p in pobj_list]
+        val_ints = [int(p.PARTNUMBER) for p in pobj_list]
         return val_ints