refactor(pretrained): lazy load at backend boundary, eager deep_eval module

- keep lazy import in deepmd/backend/pretrained.py\n- keep deepmd/pretrained/deep_eval.py as regular (non-lazy) module\n- preserve deep eval delegations for descriptor/fitting-last-layer\n- simplify resolve_model_path and adjust tests for cached path behavior\n\nAuthored by OpenClaw (model: custom-chat-jinzhezeng-group/gpt-5.3-codex)

Author: njzjz-bot

deepmd/backend/pretrained.py

@@ -10,9 +10,6 @@
 from deepmd.backend.backend import (
     Backend,
 )
-from deepmd.pretrained.deep_eval import (
-    get_pretrained_deep_eval_backend,
-)
 
 if TYPE_CHECKING:
     from argparse import (
@@ -44,7 +41,11 @@ def entry_point_hook(self) -> Callable[["Namespace"], None]:
 
     @property
     def deep_eval(self) -> type["DeepEvalBackend"]:
-        return get_pretrained_deep_eval_backend()
+        from deepmd.pretrained.deep_eval import (
+            PretrainedDeepEvalBackend,
+        )
+
+        return PretrainedDeepEvalBackend
 
     @property
     def neighbor_stat(self) -> type["NeighborStat"]:

deepmd/pretrained/deep_eval.py

@@ -1,13 +1,10 @@
 # SPDX-License-Identifier: LGPL-3.0-or-later
-"""Backend helper for `*.pretrained` model aliases."""
+"""DeepEval adapter for `*.pretrained` model aliases."""
 
 from __future__ import (
     annotations,
 )
 
-from functools import (
-    lru_cache,
-)
 from pathlib import (
     Path,
 )
@@ -16,18 +13,16 @@
     Any,
 )
 
+from deepmd.infer.deep_eval import (
+    DeepEval,
+    DeepEvalBackend,
+)
 from deepmd.pretrained.download import (
     resolve_model_path,
 )
-
 if TYPE_CHECKING:
     import numpy as np
 
-    from deepmd.infer.deep_eval import (
-        DeepEval,
-        DeepEvalBackend,
-    )
-
 
 def parse_pretrained_alias(model_file: str) -> str:
     """Extract model name from ``*.pretrained`` alias string."""
@@ -43,143 +38,133 @@ def parse_pretrained_alias(model_file: str) -> str:
     return model_name
 
 
-@lru_cache(maxsize=1)
-def get_pretrained_deep_eval_backend() -> type[DeepEvalBackend]:
-    """Build and cache the concrete DeepEval adapter lazily."""
-    # Avoid circular import when deepmd backend entrypoints are loading.
-    from deepmd.infer.deep_eval import (
-        DeepEvalBackend,
-    )
-
-    class PretrainedDeepEvalBackend(DeepEvalBackend):
-        """Resolve alias and delegate to backend selected by resolved model path."""
-
-        def __init__(
-            self,
-            model_file: str,
-            output_def: object,
-            *args: object,
-            auto_batch_size: object = True,
-            neighbor_list: object | None = None,
-            **kwargs: object,
-        ) -> None:
-            model_name = parse_pretrained_alias(model_file)
-            resolved = str(resolve_model_path(model_name))
-
-            # DeepEvalBackend.__new__ dispatches by resolved suffix (.pt/.pb/.dp...)
-            self._backend = DeepEvalBackend(
-                resolved,
-                output_def,
-                *args,
-                auto_batch_size=auto_batch_size,
-                neighbor_list=neighbor_list,
-                **kwargs,
-            )
-
-        def eval(
-            self,
-            coords: np.ndarray,
-            cells: np.ndarray | None,
-            atom_types: np.ndarray,
-            atomic: bool = False,
-            fparam: np.ndarray | None = None,
-            aparam: np.ndarray | None = None,
-            **kwargs: Any,
-        ) -> dict[str, np.ndarray]:
-            return self._backend.eval(
-                coords,
-                cells,
-                atom_types,
-                atomic,
-                fparam=fparam,
-                aparam=aparam,
-                **kwargs,
-            )
-
-        def eval_descriptor(
-            self,
-            coords: np.ndarray,
-            cells: np.ndarray | None,
-            atom_types: np.ndarray,
-            fparam: np.ndarray | None = None,
-            aparam: np.ndarray | None = None,
-            efield: np.ndarray | None = None,
-            mixed_type: bool = False,
-            **kwargs: Any,
-        ) -> np.ndarray:
-            return self._backend.eval_descriptor(
-                coords,
-                cells,
-                atom_types,
-                fparam=fparam,
-                aparam=aparam,
-                efield=efield,
-                mixed_type=mixed_type,
-                **kwargs,
-            )
-
-        def eval_fitting_last_layer(
-            self,
-            coords: np.ndarray,
-            cells: np.ndarray | None,
-            atom_types: np.ndarray,
-            fparam: np.ndarray | None = None,
-            aparam: np.ndarray | None = None,
-            **kwargs: Any,
-        ) -> np.ndarray:
-            return self._backend.eval_fitting_last_layer(
-                coords,
-                cells,
-                atom_types,
-                fparam=fparam,
-                aparam=aparam,
-                **kwargs,
-            )
-
-        def get_rcut(self) -> float:
-            return self._backend.get_rcut()
-
-        def get_ntypes(self) -> int:
-            return self._backend.get_ntypes()
-
-        def get_type_map(self) -> list[str]:
-            return self._backend.get_type_map()
-
-        def get_dim_fparam(self) -> int:
-            return self._backend.get_dim_fparam()
-
-        def has_default_fparam(self) -> bool:
-            return self._backend.has_default_fparam()
-
-        def get_dim_aparam(self) -> int:
-            return self._backend.get_dim_aparam()
-
-        @property
-        def model_type(self) -> type[DeepEval]:
-            return self._backend.model_type
-
-        def get_sel_type(self) -> list[int]:
-            return self._backend.get_sel_type()
-
-        def get_numb_dos(self) -> int:
-            return self._backend.get_numb_dos()
-
-        def get_has_efield(self) -> bool:
-            return self._backend.get_has_efield()
-
-        def get_has_spin(self) -> bool:
-            return self._backend.get_has_spin()
-
-        def get_has_hessian(self) -> bool:
-            return self._backend.get_has_hessian()
-
-        def get_var_name(self) -> str:
-            return self._backend.get_var_name()
-
-        def get_ntypes_spin(self) -> int:
-            return self._backend.get_ntypes_spin()
-
-        def get_model(self) -> Any:
-            return self._backend.get_model()
-
-    return PretrainedDeepEvalBackend
+class PretrainedDeepEvalBackend(DeepEvalBackend):
+    """Resolve alias and delegate to backend selected by resolved model path."""
+
+    def __init__(
+        self,
+        model_file: str,
+        output_def: object,
+        *args: object,
+        auto_batch_size: object = True,
+        neighbor_list: object | None = None,
+        **kwargs: object,
+    ) -> None:
+        model_name = parse_pretrained_alias(model_file)
+        resolved = str(resolve_model_path(model_name))
+
+        # DeepEvalBackend.__new__ dispatches by resolved suffix (.pt/.pb/.dp...)
+        self._backend = DeepEvalBackend(
+            resolved,
+            output_def,
+            *args,
+            auto_batch_size=auto_batch_size,
+            neighbor_list=neighbor_list,
+            **kwargs,
+        )
+
+    def eval(
+        self,
+        coords: np.ndarray,
+        cells: np.ndarray | None,
+        atom_types: np.ndarray,
+        atomic: bool = False,
+        fparam: np.ndarray | None = None,
+        aparam: np.ndarray | None = None,
+        **kwargs: Any,
+    ) -> dict[str, np.ndarray]:
+        return self._backend.eval(
+            coords,
+            cells,
+            atom_types,
+            atomic,
+            fparam=fparam,
+            aparam=aparam,
+            **kwargs,
+        )
+
+    def eval_descriptor(
+        self,
+        coords: np.ndarray,
+        cells: np.ndarray | None,
+        atom_types: np.ndarray,
+        fparam: np.ndarray | None = None,
+        aparam: np.ndarray | None = None,
+        efield: np.ndarray | None = None,
+        mixed_type: bool = False,
+        **kwargs: Any,
+    ) -> np.ndarray:
+        return self._backend.eval_descriptor(
+            coords,
+            cells,
+            atom_types,
+            fparam=fparam,
+            aparam=aparam,
+            efield=efield,
+            mixed_type=mixed_type,
+            **kwargs,
+        )
+
+    def eval_fitting_last_layer(
+        self,
+        coords: np.ndarray,
+        cells: np.ndarray | None,
+        atom_types: np.ndarray,
+        fparam: np.ndarray | None = None,
+        aparam: np.ndarray | None = None,
+        **kwargs: Any,
+    ) -> np.ndarray:
+        return self._backend.eval_fitting_last_layer(
+            coords,
+            cells,
+            atom_types,
+            fparam=fparam,
+            aparam=aparam,
+            **kwargs,
+        )
+
+    def get_rcut(self) -> float:
+        return self._backend.get_rcut()
+
+    def get_ntypes(self) -> int:
+        return self._backend.get_ntypes()
+
+    def get_type_map(self) -> list[str]:
+        return self._backend.get_type_map()
+
+    def get_dim_fparam(self) -> int:
+        return self._backend.get_dim_fparam()
+
+    def has_default_fparam(self) -> bool:
+        return self._backend.has_default_fparam()
+
+    def get_dim_aparam(self) -> int:
+        return self._backend.get_dim_aparam()
+
+    @property
+    def model_type(self) -> type[DeepEval]:
+        return self._backend.model_type
+
+    def get_sel_type(self) -> list[int]:
+        return self._backend.get_sel_type()
+
+    def get_numb_dos(self) -> int:
+        return self._backend.get_numb_dos()
+
+    def get_has_efield(self) -> bool:
+        return self._backend.get_has_efield()
+
+    def get_has_spin(self) -> bool:
+        return self._backend.get_has_spin()
+
+    def get_has_hessian(self) -> bool:
+        return self._backend.get_has_hessian()
+
+    def get_var_name(self) -> str:
+        return self._backend.get_var_name()
+
+    def get_ntypes_spin(self) -> int:
+        return self._backend.get_ntypes_spin()
+
+    def get_model(self) -> Any:
+        return self._backend.get_model()

source/tests/common/test_pretrained_backend.py

@@ -38,4 +38,8 @@ def test_parse_pretrained_alias_invalid(self) -> None:
             parse_pretrained_alias("DPA-3.2-5M.pt")
 
     def test_deep_eval_property(self) -> None:
-        self.assertIsNotNone(PretrainedBackend().deep_eval)
+        from deepmd.pretrained.deep_eval import (
+            PretrainedDeepEvalBackend,
+        )
+
+        self.assertIs(PretrainedBackend().deep_eval, PretrainedDeepEvalBackend)