ansys-pyensight-core 0.7.7__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

@@ -540,6 +540,20 @@ class RenderableVNC(Renderable):
         self._rendertype = "remote"
         self.update()
 
+    def _update_2023R2_or_less(self):
+        """Update the remote rendering widget and display it for
+        backend EnSight of version earlier than 2024R1
+        """
+        query_params = {
+            "autoconnect": "true",
+            "host": self._session.html_hostname,
+            "port": self._session.ws_port,
+        }
+        url = f"{self._http_protocol}://{self._session.html_hostname}:{self._session.html_port}"
+        url += "/ansys/nexus/novnc/vnc_envision.html"
+        url += self._get_query_parameters_str(query_params)
+        self._url = url
+
     def update(self):
         """Update the remote rendering widget and display it.
 
@@ -549,29 +563,37 @@ class RenderableVNC(Renderable):
         """
         optional_query = self._get_query_parameters_str()
         version = _get_ansysnexus_version(self._session._cei_suffix)
-        html = f"<script src='/ansys{version}/nexus/viewer-loader.js{optional_query}'></script>\n"
-        rest_uri = (
-            f"{self._http_protocol}://{self._session.html_hostname}:{self._session.html_port}"
-        )
-        ws_uri = f"{self._http_protocol}://{self._session.html_hostname}:{self._session.ws_port}"
-
-        query_args = ""
-        if self._using_proxy and optional_query:
-            query_args = f', "extra_query_args":"{optional_query[1:]}"'
-
-        attributes = ' renderer="envnc"'
-        attributes += ' ui="simple"'
-        attributes += ' active="true"'
-        attributes += (
-            " renderer_options='"
-            + f'{{ "ws":"{ws_uri}", "http":"{rest_uri}", "security_token":"{self._session.secret_key}", "connect_to_running_ens":true {query_args} }}'
-            + "'"
-        )
+        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"
+            )
+            rest_uri = (
+                f"{self._http_protocol}://{self._session.html_hostname}:{self._session.html_port}"
+            )
+            ws_uri = (
+                f"{self._http_protocol}://{self._session.html_hostname}:{self._session.ws_port}"
+            )
 
-        html += f"<ansys-nexus-viewer {attributes}></ansys-nexus-viewer>\n"
+            query_args = ""
+            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"'
+            attributes += ' active="true"'
+            attributes += (
+                " renderer_options='"
+                + f'{{ "ws":"{ws_uri}", "http":"{rest_uri}", "security_token":"{self._session.secret_key}", "connect_to_running_ens":true {query_args} }}'
+                + "'"
+            )
 
-        # refresh the remote HTML
-        self._save_remote_html_page(html)
+            html += f"<ansys-nexus-viewer {attributes}></ansys-nexus-viewer>\n"
+
+            # refresh the remote HTML
+            self._save_remote_html_page(html)
         super().update()
 
 
@@ -672,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.py

@@ -2,7 +2,7 @@ import os
 import subprocess
 import sys
 from types import ModuleType
-from typing import TYPE_CHECKING, Optional, Union
+from typing import TYPE_CHECKING, List, Optional, Union
 
 import psutil
 
@@ -17,7 +17,7 @@ class Omniverse:
     """Provides the ``ensight.utils.omniverse`` interface.
 
     The omniverse class methods provide an interface between an EnSight session
-    and an Omniverse instance.
+    and an Omniverse instance.  See :ref:`omniverse_info` for additional details.
 
     Note
     ----
@@ -48,26 +48,60 @@ class Omniverse:
     def __init__(self, interface: Union["ensight_api.ensight", "ensight"]):
         self._ensight = interface
         self._server_pid: Optional[int] = None
+        self._interpreter: List[str] = []
 
-    @staticmethod
-    def _check_modules() -> None:
+    def _check_modules(self) -> None:
         """Verify that the Python interpreter is correct
 
-        Check for omni and pxr modules. If not present, raise an exception.
+        Check for omni module. If not present, raise an exception.
+        If pxr is there as well, then we can just use sys.executable.
+        If not, check to see if 'kit.bat' or 'kit.sh' can be found and
+        arrange to use those instead.
 
         Raises
         ------
         RuntimeError if the necessary modules are missing.
 
         """
+        # One time check for this
+        if len(self._interpreter):
+            return
         try:
             # Note: the EnSight embedded interpreter will not have these
-            import omni  # noqa: F401
-            import pxr  # noqa: F401
+            import omni.client  # noqa: F401
+        except ImportError:
+            raise RuntimeError("The module requires the omni module to be installed.") from None
+
+        try:
+            # if we can import pxr, then we can just use sys.executable
+            from pxr import Gf, Sdf, Usd, UsdGeom, UsdLux, UsdShade  # noqa: F401
+
+            if os.path.basename(sys.executable).startswith("kit"):
+                # we are running inside of an Omniverse app like Create, use the 'kit' script
+                raise ImportError("Internal retry")
+
+            self._interpreter = [sys.executable]
+            return
         except ImportError:
-            raise RuntimeError(
-                "The module requires the omni and pxr modules to be installed."
-            ) from None
+            # Can we find 'kit.bat' or 'kit.sh' (we may be running in it)?
+            # Interesting cases:  something/kit/python/python.exe,
+            # something/kit/kit.exe.  All mapped to something/kit.{bat,sh} if found.
+            ov_dir = os.path.dirname(sys.executable)
+            for _ in range(3):
+                for name in ("kit.bat", "kit.sh"):
+                    exe_name = os.path.join(ov_dir, name)
+                    if os.path.exists(exe_name):
+                        self._interpreter = [
+                            exe_name,
+                            "--enable",
+                            "omni.client",
+                            "--enable",
+                            "omni.usd",
+                            "--exec",
+                        ]
+                        return
+                ov_dir = os.path.dirname(ov_dir)
+            raise RuntimeError("Unable to detect a copy of the Omniverse kit executable.") from None
 
     def _is_running_omniverse(self) -> bool:
         """Check that an Omniverse connection is active
@@ -88,7 +122,6 @@ class Omniverse:
         include_camera: bool = False,
         normalize_geometry: bool = False,
         live: bool = True,
-        temporal: bool = False,
         debug_filename: str = "",
     ) -> None:
         """Ensure that an EnSight dsg -> omniverse server is running
@@ -103,21 +136,18 @@ class Omniverse:
         omniverse_path : str
             The URI to the Omniverse server. It will look like this:
             "omniverse://localhost/Users/test"
-        include_camera: bool
+        include_camera : bool
             If True, apply the EnSight camera to the Omniverse scene.  This option
             should be used if the target viewer is in AR/VR mode.  Defaults to False.
-        normalize_geometry: bool
+        normalize_geometry : bool
             Omniverse units are in meters.  If the source dataset is not in the correct
             unit system or is just too large/small, this option will remap the geometry
             to a unit cube.  Defaults to False.
-        live: bool
+        live : bool
             If True, one can call 'update()' to send updated geometry to Omniverse.
             If False, the Omniverse connection will push a single update and then
             disconnect.  Defaults to True.
-        temporal: bool
-            If True, all EnSight timesteps will be pushed to Omniverse.  Defaults to False, only
-            the current timestep is pushed.
-        debug_filename: str
+        debug_filename : str
             If the name of a file is provided, it will be used to save logging information on
             the connection between EnSight and Omniverse.
 
@@ -136,7 +166,6 @@ class Omniverse:
         script_name = "omniverse_dsg_server.py"
         working_dir = os.path.dirname(__file__)
         cmd = [
-            sys.executable,
             script_name,
             "--host",
             hostname,
@@ -151,17 +180,23 @@ class Omniverse:
             cmd.extend(["--vrmode"])
         if token:
             cmd.extend(["--security", token])
-        if temporal:
-            cmd.extend(["--animation"])
-        else:
-            cmd.extend(["--no-animation"])
+        # if temporal:
+        #     cmd.extend(["--animation"])
+        # else:
+        #     cmd.extend(["--no-animation"])
         if debug_filename:
             cmd.extend(["--log_file", debug_filename])
             cmd.extend(["--verbose", "1"])
         if normalize_geometry:
             cmd.extend(["--normalize_geometry"])
+        # if using kit.bat, convert args into a string, otherwise, just use them
+        cmdline = []
+        cmdline.extend(self._interpreter)
+        if len(self._interpreter) > 1:
+            cmd = [" ".join(cmd)]
+        cmdline.extend(cmd)
         env_vars = os.environ.copy()
-        process = subprocess.Popen(cmd, close_fds=True, env=env_vars, cwd=working_dir)
+        process = subprocess.Popen(cmdline, close_fds=True, env=env_vars, cwd=working_dir)
         self._server_pid = process.pid
 
     def close_connection(self) -> None:

ansys/pyensight/core/utils/omniverse_dsg_server.py

@@ -63,6 +63,8 @@ class OmniverseWrapper:
         path: str = "omniverse://localhost/Users/test",
         verbose: int = 0,
     ):
+        self._cleaned_index = 0
+        self._cleaned_names: dict = {}
         self._connectionStatusSubscription = None
         self._stage = None
         self._destinationPath = path
@@ -299,17 +301,52 @@ class OmniverseWrapper:
         self.save_stage()
         return boxPrim
 
-    @staticmethod
-    def clean_name(name: str, id_name: Any = None) -> str:
-        name = name.replace(" ", "_").replace("-", "_")
+    def clear_cleaned_names(self) -> None:
+        """Clear the list of cleaned names"""
+        self._cleaned_names = {}
+        self._cleaned_index = 0
+
+    def clean_name(self, name: str, id_name: Any = None) -> str:
+        """Generate a vais USD name
+
+        From a base (EnSight) varname, partname, etc. and the DSG id, generate
+        a unique, valid USD name.  Save the names so that if the same name
+        comes in again, the previously computed name is returned and if the
+        manipulation results in a conflict, the name can be made unique.
+
+        Parameters
+        ----------
+        name:
+            The name to generate a USD name for.
+
+        id_name:
+            The DSG id associated with the DSG name, if any.
+
+        Returns
+        -------
+            A unique USD name.
+        """
+        # return any previously generated name
+        if (name, id_name) in self._cleaned_names:
+            return self._cleaned_names[(name, id_name)]
+        # replace invalid characters
+        name = name.replace("+", "_").replace("-", "_")
         name = name.replace(".", "_").replace(":", "_")
         name = name.replace("[", "_").replace("]", "_")
         name = name.replace("(", "_").replace(")", "_")
         name = name.replace("<", "_").replace(">", "_")
         name = name.replace("/", "_").replace("=", "_")
-        name = name.replace(",", "_")
-        if id is not None:
+        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():
+            # Make the name unique
+            while f"{name}_{self._cleaned_index}" in self._cleaned_names.values():
+                self._cleaned_index += 1
+            name = f"{name}_{self._cleaned_index}"
+        # store off the cleaned name
+        self._cleaned_names[(name, id_name)] = name
         return name
 
     @staticmethod
@@ -1011,6 +1048,7 @@ class DSGOmniverseLink(object):
         self._part = Part(self)
         self._scene_bounds = None
         self._mesh_block_count = 0  # reset when a new group shows up
+        self._omni.clear_cleaned_names()
 
         # handle the various commands until UPDATE_SCENE_END
         cmd = self.get_next_message()