ansys-fluent-core 0.27.dev1__py3-none-any.whl → 0.28.dev0__py3-none-any.whl

ansys/fluent/core/solver/flobject.py

@@ -48,10 +48,13 @@ import warnings
 import weakref
 from zipimport import zipimporter
 
+import ansys.fluent.core as pyfluent
 from ansys.fluent.core.utils.fluent_version import FluentVersion
 from ansys.fluent.core.warnings import PyFluentDeprecationWarning, PyFluentUserWarning
 
+from .error_message import allowed_name_error_message, allowed_values_error
 from .flunits import UnhandledQuantity, get_si_unit_for_fluent_quantity
+from .settings_external import expand_api_file_argument
 
 
 def _ansys_units():
@@ -64,11 +67,6 @@ def _ansys_units():
         pass
 
 
-import ansys.fluent.core as pyfluent
-
-from .error_message import allowed_name_error_message, allowed_values_error
-from .settings_external import expand_api_file_argument, use_search
-
 settings_logger = logging.getLogger("pyfluent.settings_api")
 
 
@@ -76,6 +74,7 @@ class InactiveObjectError(RuntimeError):
     """Inactive object access."""
 
     def __init__(self, python_path):
+        """Initialize InactiveObjectError."""
         super().__init__(f"'{python_path}' is currently inactive.")
 
 
@@ -173,6 +172,38 @@ def to_python_name(fluent_name: str) -> str:
     return name
 
 
+def _get_python_path_comps(obj):
+    """Get python path components for traversing class hierarchy."""
+    comps = []
+    while obj:
+        python_name = obj._python_name
+        obj = obj._parent
+        if isinstance(obj, (NamedObject, ListObject)):
+            comps.append(obj._python_name)
+            obj = obj._parent
+        else:
+            comps.append(python_name)
+    comps.reverse()
+    return comps[1:]
+
+
+def _get_class_from_paths(root_cls, some_path: list[str], other_path: list[str]):
+    """Get the class for the given alias path."""
+    parent_count = 0
+    while other_path[0] == "..":
+        parent_count += 1
+        other_path.pop(0)
+    for _ in range(parent_count):
+        some_path.pop()
+    full_path = some_path + other_path
+    cls = root_cls
+    for comp in full_path:
+        cls = cls._child_classes[comp]
+        if issubclass(cls, (NamedObject, ListObject)):
+            cls = cls.child_object_type
+    return cls, full_path
+
+
 class Base:
     """Provides the base class for settings and command objects.
 
@@ -467,6 +498,9 @@ class Numerical(Property):
         return None if isinstance(val, bool) else val
 
 
+QuantityT = TypeVar("QuantityT")
+
+
 class RealNumerical(Numerical):
     """A ``RealNumerical`` object representing a real value setting, including single
     real values and containers of real values, such as lists.
@@ -483,7 +517,7 @@ class RealNumerical(Numerical):
         Get the units string.
     """
 
-    def as_quantity(self) -> ansys.units.Quantity | None:
+    def as_quantity(self) -> QuantityT | None:
         """Get the state of the object as an ansys.units.Quantity."""
         error = None
         if not _ansys_units():
@@ -644,43 +678,6 @@ def _create_child(cls, name, parent: weakref.CallableProxyType, alias_path=None)
     return cls(name, parent)
 
 
-def _combine_set_states(states: List[Tuple[str, StateT]]) -> Tuple[str, StateT]:
-    """Combines multiple set-states into a single set-state at a common parent path.
-
-    Parameters
-    ----------
-    states : list[tuple[str, StateT]]
-        List of (<path>, <state>) tuples.
-
-    Returns
-    -------
-    tuple[str, StateT]
-        Common parent path, combined state.
-    """
-    paths, _ = zip(*states)
-    common_path = []
-    paths = [path.split("/") for path in paths]
-    for comps in zip(*paths):
-        if len(set(comps)) == 1:
-            common_path.append(comps[0])
-        else:
-            break
-    combined_state = {}
-    for path, state in states:
-        comps = path.split("/")
-        comps = comps[len(common_path) :]
-        if comps:
-            if not isinstance(combined_state, dict):
-                combined_state = {}
-            obj = combined_state
-            for comp in comps[:-1]:
-                obj = obj.setdefault(comp, {})
-            obj[comps[-1]] = state
-        else:
-            combined_state = state
-    return "/".join(common_path), combined_state
-
-
 class SettingsBase(Base, Generic[StateT]):
     """Base class for settings objects.
 
@@ -694,7 +691,7 @@ class SettingsBase(Base, Generic[StateT]):
     """
 
     @classmethod
-    def to_scheme_keys(cls, value: StateT) -> StateT:
+    def to_scheme_keys(cls, value: StateT, root_cls, path: list[str]) -> StateT:
         """Convert value to have keys with scheme names.
 
         This is overridden in the ``Group``, ``NamedObject``, and
@@ -719,63 +716,6 @@ class SettingsBase(Base, Generic[StateT]):
         """Get the state of the object."""
         return self.to_python_keys(self.flproxy.get_var(self.path))
 
-    # Following is not a classmethod, as parent (required to support ".." in alias-path)
-    # is available only at the instance level.
-    def _unalias(self, cls, value):
-        """Unalias the given value."""
-        if isinstance(value, collections.abc.Mapping):
-            ret = {}
-            outer_set_states = []
-            for k, v in value.items():
-                if hasattr(cls, "_child_aliases") and k in cls._child_aliases:
-                    alias = cls._child_aliases[k]
-                    comps = alias.split("/")
-                    if comps[0] == "..":
-                        outer_obj = self
-                        while comps[0] == "..":
-                            outer_obj = outer_obj.parent
-                            comps = comps[1:]
-                        for comp in comps:
-                            try:
-                                outer_obj = getattr(outer_obj, comp)
-                            except InactiveObjectError:
-                                outer_obj = super(
-                                    SettingsBase, outer_obj
-                                ).__getattribute__(comp)
-                        outer_set_states.append((outer_obj, v))
-                    else:
-                        ret_alias = ret
-                        aliased_cls = cls
-                        obj = self
-                        for i, comp in enumerate(comps):
-                            aliased_cls = aliased_cls._child_classes[comp]
-                            try:
-                                obj = getattr(obj, comp)
-                            except InactiveObjectError:
-                                obj = super(SettingsBase, obj).__getattribute__(comp)
-                            if i == len(comps) - 1:
-                                ret_alias[comp], o_set_states = obj._unalias(
-                                    aliased_cls, v
-                                )
-                                outer_set_states.extend(o_set_states)
-                            else:
-                                ret_alias = ret_alias.setdefault(comp, {})
-                else:
-                    if issubclass(cls, Group):
-                        ccls = cls._child_classes[k]
-                        try:
-                            cobj = getattr(self, k)
-                        except InactiveObjectError:
-                            cobj = super(SettingsBase, self).__getattribute__(k)
-                        ret[k], o_set_states = cobj._unalias(ccls, v)
-                        outer_set_states.extend(o_set_states)
-                    else:
-                        ret[k], o_set_states = self._unalias(cls, v)
-                        outer_set_states.extend(o_set_states)
-            return ret, outer_set_states
-        else:
-            return value, []
-
     def set_state(self, state: StateT | None = None, **kwargs):
         """Set the state of the object."""
         with self._while_setting_state():
@@ -784,17 +724,14 @@ class SettingsBase(Base, Generic[StateT]):
             ):
                 self.value.set_state(state, **kwargs)
             else:
-                state, outer_set_states = self._unalias(self.__class__, kwargs or state)
-                if outer_set_states:
-                    set_states = []
-                    if state:
-                        set_states.append((self.path, self.to_scheme_keys(state)))
-                    for obj, state in outer_set_states:
-                        set_states.append((obj.path, obj.to_scheme_keys(state)))
-                    path, state = _combine_set_states(set_states)
-                    self.flproxy.set_var(path, state)
-                else:
-                    self.flproxy.set_var(self.path, self.to_scheme_keys(state))
+                self.flproxy.set_var(
+                    self.path,
+                    self.to_scheme_keys(
+                        kwargs or state,
+                        self._root.__class__,
+                        _get_python_path_comps(self),
+                    ),
+                )
 
     @staticmethod
     def _print_state_helper(state, out, indent=0, indent_factor=2):
@@ -1020,7 +957,7 @@ class Group(SettingsBase[DictStateType]):
             return self.get_state()
 
     @classmethod
-    def to_scheme_keys(cls, value):
+    def to_scheme_keys(cls, value, root_cls, path: list[str]):
         """Convert value to have keys with scheme names.
 
         Raises
@@ -1033,7 +970,15 @@ class Group(SettingsBase[DictStateType]):
             for k, v in value.items():
                 if k in cls.child_names:
                     ccls = cls._child_classes[k]
-                    ret[ccls.fluent_name] = ccls.to_scheme_keys(v)
+                    ret[ccls.fluent_name] = ccls.to_scheme_keys(v, root_cls, path + [k])
+                elif k in cls._child_aliases:
+                    alias, scm_alias_name = cls._child_aliases[k]
+                    alias_cls, alias_path = _get_class_from_paths(
+                        root_cls, path.copy(), alias.split("/")
+                    )
+                    ret[scm_alias_name] = alias_cls.to_scheme_keys(
+                        v, root_cls, alias_path
+                    )
                 else:
                     raise RuntimeError("Key '" + str(k) + "' is invalid")
             return ret
@@ -1053,7 +998,7 @@ class Group(SettingsBase[DictStateType]):
                     ret[mname] = ccls.to_python_keys(mvalue)
             return ret
         else:
-            return value
+            return {}
 
     _child_classes = {}
     child_names = []
@@ -1120,6 +1065,7 @@ class Group(SettingsBase[DictStateType]):
                 raise InactiveObjectError(self.python_path)
         alias = super().__getattribute__("_child_aliases").get(name)
         if alias:
+            alias = alias[0]
             alias_obj = self._child_alias_objs.get(name)
             if alias_obj is None:
                 obj = self.find_object(alias)
@@ -1133,27 +1079,18 @@ class Group(SettingsBase[DictStateType]):
                 attr._check_stable()
             return attr
         except AttributeError as ex:
-            modified_search_results = []
-            if use_search(
-                codegen_outdir=pyfluent.CODEGEN_OUTDIR,
-                version=super().__getattribute__("version"),
-            ):
-                search_results = pyfluent.utils._search(
-                    word=name,
-                    search_root=self,
-                    match_case=False,
-                    match_whole_word=False,
-                )
-                if search_results:
-                    for search_result in search_results:
-                        search_result = search_result.replace(
-                            "<search_root>", self.__class__.__name__
-                        )
-                        modified_search_results.append(search_result)
+            pyfluent.PRINT_SEARCH_RESULTS = False
+            search_results = pyfluent.utils.search(
+                search_string=name,
+                match_case=False,
+                match_whole_word=False,
+            )
+            pyfluent.PRINT_SEARCH_RESULTS = True
+            results = search_results if search_results else []
             error_msg = allowed_name_error_message(
                 trial_name=name,
                 message=ex.args[0],
-                search_results=modified_search_results,
+                search_results=results,
             )
             ex.args = (error_msg,)
             raise
@@ -1249,18 +1186,14 @@ class WildcardPath(Group):
     # get_state example: a.b["*"].c.d.get_state() == {"<bN>" {"c": {"d": <d_value>}}}
     # set_state example: a.b["*"].set_state({"c": {"d": <d_value>}})
 
-    def to_scheme_keys(self, value):
+    def to_scheme_keys(self, value, root_cls, path):
         """Convert value to have keys with scheme names."""
-        return self._settings_cls.to_scheme_keys(value)
+        return self._settings_cls.to_scheme_keys(value, root_cls, path)
 
     def to_python_keys(self, value):
         """Convert value to have keys with Python names."""
         return self._state_cls.to_python_keys(value)
 
-    def _unalias(self, cls, value):
-        # Not yet implemented
-        return value, []
-
 
 class NamedObjectWildcardPath(WildcardPath):
     """WildcardPath at a NamedObject path, so it can be looked up by wildcard again."""
@@ -1312,12 +1245,12 @@ class NamedObject(SettingsBase[DictStateType], Generic[ChildTypeT]):
             )
 
     @classmethod
-    def to_scheme_keys(cls, value):
+    def to_scheme_keys(cls, value, root_cls, path: list[str]):
         """Convert value to have keys with scheme names."""
         if isinstance(value, collections.abc.Mapping):
             ret = {}
             for k, v in value.items():
-                ret[k] = cls.child_object_type.to_scheme_keys(v)
+                ret[k] = cls.child_object_type.to_scheme_keys(v, root_cls, path)
             return ret
         else:
             return value
@@ -1331,7 +1264,7 @@ class NamedObject(SettingsBase[DictStateType], Generic[ChildTypeT]):
                 ret[k] = cls.child_object_type.to_python_keys(v)
             return ret
         else:
-            return value
+            return {}
 
     _child_classes = {}
     command_names = []
@@ -1464,6 +1397,7 @@ class NamedObject(SettingsBase[DictStateType], Generic[ChildTypeT]):
     def __getattr__(self, name: str):
         alias = self._child_aliases.get(name)
         if alias:
+            alias = alias[0]
             alias_obj = self._child_alias_objs.get(name)
             if alias_obj is None:
                 obj = self.find_object(alias)
@@ -1523,10 +1457,12 @@ class ListObject(SettingsBase[ListStateType], Generic[ChildTypeT]):
             self._setattr(query, _create_child(cls, None, self))
 
     @classmethod
-    def to_scheme_keys(cls, value):
+    def to_scheme_keys(cls, value, root_cls, path: list[str]):
         """Convert value to have keys with scheme names."""
         if isinstance(value, collections.abc.Sequence):
-            return [cls.child_object_type.to_scheme_keys(v) for v in value]
+            return [
+                cls.child_object_type.to_scheme_keys(v, root_cls, path) for v in value
+            ]
         else:
             return value
 
@@ -1536,7 +1472,7 @@ class ListObject(SettingsBase[ListStateType], Generic[ChildTypeT]):
         if isinstance(value, collections.abc.Sequence):
             return [cls.child_object_type.to_python_keys(v) for v in value]
         else:
-            return value
+            return []
 
     _child_classes = {}
     command_names = []
@@ -1581,6 +1517,7 @@ class ListObject(SettingsBase[ListStateType], Generic[ChildTypeT]):
     def __getattr__(self, name: str):
         alias = self._child_aliases.get(name)
         if alias:
+            alias = alias[0]
             alias_obj = self._child_alias_objs.get(name)
             if alias_obj is None:
                 obj = self.find_object(alias)
@@ -1598,24 +1535,35 @@ class Map(SettingsBase[DictStateType]):
 
 def _get_new_keywords(obj, *args, **kwds):
     newkwds = {}
-    argNames = []
-    argumentNames = []
+    unknown_keywords = set()
+    # Convert positional arguments to keyword arguments
     if args:
         argNames = obj.argument_names[:]
-        for i, arg in enumerate(args):
-            ccls = getattr(obj, argNames[0])
-            newkwds[ccls.fluent_name] = ccls.to_scheme_keys(arg)
-            argNames.pop(0)
+        for arg in args:
+            argName = argNames.pop(0)
+            newkwds[argName] = arg
     if kwds:
-        argumentNames = obj.argument_names[:]
-        if argNames:
-            argumentNames = argNames
-    for k, v in kwds.items():
-        if k in argumentNames:
-            ccls = getattr(obj, k)
-            newkwds[ccls.fluent_name] = ccls.to_scheme_keys(v)
-        else:
-            raise RuntimeError("Argument '" + str(k) + "' is invalid")
+        # Convert deprecated keywords through aliases
+        # We don't get arguments-aliases from static-info yet.
+        argument_aliases_scm = obj.get_attr("arguments-aliases") or {}
+        argument_aliases = {}
+        for k, v in argument_aliases_scm.items():
+            argument_aliases[to_python_name(k)] = to_python_name(v.removeprefix("'"))
+        for k, v in kwds.items():
+            alias = argument_aliases.get(k)
+            if alias:
+                newkwds[alias] = v
+            elif k in obj.argument_names:
+                newkwds[k] = v
+            else:
+                unknown_keywords.add(k)
+    for k in unknown_keywords:
+        # Noisily ignore unknown keywords
+        warnings.warn(
+            f"Unknown keyword '{k}' for command '{obj.python_path}'. "
+            "It will be ignored.",
+            PyFluentUserWarning,
+        )
     return newkwds
 
 
@@ -1660,6 +1608,7 @@ class Action(Base):
     def __getattr__(self, name: str):
         alias = self._child_aliases.get(name)
         if alias:
+            alias = alias[0]
             alias_obj = self._child_alias_objs.get(name)
             if alias_obj is None:
                 obj = self.find_object(alias)
@@ -1676,10 +1625,9 @@ class BaseCommand(Action):
 
     def _execute_command(self, *args, **kwds):
         """Execute a command with the specified positional and keyword arguments."""
-        newkwds = _get_new_keywords(self, *args, **kwds)
         if self.flproxy.is_interactive_mode():
             prompt = self.flproxy.get_command_confirmation_prompt(
-                self._parent.path, self.obj_name, **newkwds
+                self._parent.path, self.obj_name, **kwds
             )
             if prompt:
                 valid_responses = {"y": True, "yes": True, "n": False, "no": False}
@@ -1692,7 +1640,7 @@ class BaseCommand(Action):
                     else:
                         print("Please enter 'y[es]' or 'n[o]'.")
         with self._while_executing_command():
-            ret = self.flproxy.execute_cmd(self._parent.path, self.obj_name, **newkwds)
+            ret = self.flproxy.execute_cmd(self._parent.path, self.obj_name, **kwds)
             if os.getenv("PYFLUENT_NO_FIX_PARAMETER_LIST_RETURN") != "1":
                 if (self._parent.path, self.obj_name) in [
                     ("parameters/input-parameters", "list"),
@@ -1703,15 +1651,24 @@ class BaseCommand(Action):
 
     def execute_command(self, *args, **kwds):
         """Execute command."""
+        kwds = _get_new_keywords(self, *args, **kwds)
+        scmKwds = {}
         for arg, value in kwds.items():
             argument = getattr(self, arg)
-            kwds[arg] = argument.before_execute(
+            # Convert path-like values for possible file transfer
+            value = argument.before_execute(
                 command_name=self.python_name, value=value, kwargs=kwds
             )
-        ret = self._execute_command(*args, **kwds)
+            # Convert key-value to Scheme key-value
+            scmKwds[argument.fluent_name] = argument.to_scheme_keys(
+                value,
+                argument._root.__class__,
+                _get_python_path_comps(argument),
+            )
+        ret = self._execute_command(*args, **scmKwds)
         for arg, value in kwds.items():
             argument = getattr(self, arg)
-            kwds[arg] = argument.after_execute(
+            argument.after_execute(
                 command_name=self.python_name, value=value, kwargs=kwds
             )
         if (
@@ -1735,15 +1692,18 @@ class BaseCommand(Action):
             raise KeyboardInterrupt
 
 
-# TODO: Remove this after paremater list() method is fixed from Fluent side
+# TODO: Remove this after parameter list() method is fixed from Fluent side
 def _fix_parameter_list_return(val):
     if isinstance(val, dict):
         new_val = {}
         for name, v in val.items():
             value, units = v
-            if len(units) > 0:
+            if len(units) > 0 and isinstance(units[0], str):
+                # Symbols are not stripped in the command return in PyConsole.
+                # Following code will work in both PyConsole and PyFluent.
+                unit = units[0].lstrip("'")
                 unit_labels = _fix_parameter_list_return.scheme_eval(
-                    f"(units/inquire-available-label-strings-for-quantity '{units[0]})"
+                    f"(units/inquire-available-label-strings-for-quantity '{unit})"
                 )
                 unit_label = unit_labels[0] if len(unit_labels) > 0 else ""
             else:
@@ -1785,8 +1745,17 @@ class Query(Action):
 
     def __call__(self, **kwds):
         """Call a query with the specified keyword arguments."""
-        newkwds = _get_new_keywords(self, **kwds)
-        return self.flproxy.execute_query(self._parent.path, self.obj_name, **newkwds)
+        kwds = _get_new_keywords(self, **kwds)
+        scmKwds = {}
+        for arg, value in kwds.items():
+            argument = getattr(self, arg)
+            # Convert key-value to Scheme key-value
+            scmKwds[argument.fluent_name] = argument.to_scheme_keys(
+                value,
+                argument._root.__class__,
+                _get_python_path_comps(argument),
+            )
+        return self.flproxy.execute_query(self._parent.path, self.obj_name, **scmKwds)
 
 
 _baseTypes = {
@@ -1870,12 +1839,12 @@ class _ChildNamedObjectAccessorMixin(collections.abc.MutableMapping):
 
     def __len__(self):
         """Number of child named objects."""
-        l = 0
+        count = 0
         for cname in self.child_names:
             cobj = getattr(self, cname)
             if isinstance(cobj, NamedObject):
-                l += len(cobj)
-        return l
+                count += len(cobj)
+        return count
 
 
 class CreatableNamedObjectMixin(collections.abc.MutableMapping, Generic[ChildTypeT]):
@@ -2089,6 +2058,7 @@ def get_cls(name, info, parent=None, version=None, parent_taboo=None):
         commands = info.get("commands")
         if commands:
             commands.pop("exit", None)
+            commands.pop("switch-to-meshing-mode", None)
         if commands and not user_creatable:
             commands.pop("create", None)
         if commands:
@@ -2127,12 +2097,22 @@ def get_cls(name, info, parent=None, version=None, parent_taboo=None):
         child_aliases = info.get("child-aliases") or info.get("child_aliases", {})
         command_aliases = info.get("command-aliases") or info.get("command_aliases", {})
         query_aliases = info.get("query-aliases") or info.get("query_aliases", {})
-        if child_aliases or command_aliases or query_aliases:
+        argument_aliases = info.get("arguments-aliases") or info.get(
+            "arguments_aliases", {}
+        )
+        if child_aliases or command_aliases or query_aliases or argument_aliases:
             cls._child_aliases = {}
             # No need to differentiate in the Python implementation
-            for k, v in (child_aliases | command_aliases | query_aliases).items():
-                cls._child_aliases[to_python_name(k)] = "/".join(
-                    x if x == ".." else to_python_name(x) for x in v.split("/")
+            for k, v in (
+                child_aliases | command_aliases | query_aliases | argument_aliases
+            ).items():
+                # Storing the original name as we don't have any other way
+                # to recover it at runtime.
+                cls._child_aliases[to_python_name(k)] = (
+                    "/".join(
+                        x if x == ".." else to_python_name(x) for x in v.split("/")
+                    ),
+                    k,
                 )
 
     except Exception:
@@ -2172,53 +2152,45 @@ def get_root(
     version : str
         Fluent version.
 
+    Returns
+    -------
+    root object
+
     Raises
     ------
     RuntimeError
         If hash values are inconsistent.
-
-    Returns
-    -------
-    root object
     """
     from ansys.fluent.core import CODEGEN_OUTDIR, CODEGEN_ZIP_SETTINGS, utils
 
-    obj_info = flproxy.get_static_info()
-    try:
-        if os.getenv("PYFLUENT_USE_OLD_SETTINGSGEN") != "1":
+    if os.getenv("PYFLUENT_USE_OLD_SETTINGSGEN") != "1":
+        try:
             settings = utils.load_module(
                 f"settings_{version}",
                 CODEGEN_OUTDIR / "solver" / f"settings_{version}.py",
             )
+            root_cls = settings.root
+        except FileNotFoundError:
+            obj_info = flproxy.get_static_info()
+            root_cls, _ = get_cls("", obj_info, version=version)
+    else:
+        if CODEGEN_ZIP_SETTINGS:
+            importer = zipimporter(
+                str(CODEGEN_OUTDIR / "solver" / f"settings_{version}.zip")
+            )
+            settings = importer.load_module("settings")
         else:
-            if CODEGEN_ZIP_SETTINGS:
-                importer = zipimporter(
-                    str(CODEGEN_OUTDIR / "solver" / f"settings_{version}.zip")
-                )
-                settings = importer.load_module("settings")
-            else:
-                settings = utils.load_module(
-                    f"settings_{version}",
-                    CODEGEN_OUTDIR / "solver" / f"settings_{version}" / "__init__.py",
-                )
-
-        if settings.SHASH != _gethash(obj_info):
-            settings_logger.warning(
-                "Mismatch between generated file and server object "
-                "info. Dynamically created settings classes will "
-                "be used."
+            settings = utils.load_module(
+                f"settings_{version}",
+                CODEGEN_OUTDIR / "solver" / f"settings_{version}" / "__init__.py",
             )
-            raise RuntimeError("Mismatch in hash values")
-        cls = settings.root
-    except Exception:
-        cls, _ = get_cls("", obj_info, version=version)
-    root = cls()
+        root_cls = settings.root
+    root = root_cls()
     root.set_flproxy(flproxy)
     root._set_on_interrupt(interrupt)
     root._set_file_transfer_service(file_transfer_service)
     _Alias.scheme_eval = scheme_eval
     _fix_parameter_list_return.scheme_eval = scheme_eval
-    root._setattr("_static_info", obj_info)
     root._setattr("_file_transfer_service", file_transfer_service)
     return root