Diff Coverage

            shape: Optional logical global tensor shape.
        """
        if isinstance(local_tensor, DTensorBase):
            # Copy from existing DTensorBase — use alias_placements to preserve multi-axis ordering
            t = Tensor._make_subclass(cls, local_tensor._local_tensor, local_tensor._local_tensor.requires_grad)
            copy_placements = local_tensor.layout.alias_placements if local_tensor.layout else local_tensor.placements
            t.__init_data__(
                local_tensor._local_tensor,
                local_tensor.device_mesh,
                copy_placements,
                shape=getattr(local_tensor, "_global_shape", None),

                local_tensor.device_mesh,
                copy_placements,
                shape=getattr(local_tensor, "_global_shape", None),
            )
            return t

        if device_mesh is None:
            raise ValueError("device_mesh is None, must provide a DeviceMesh instance")
        if placements is None:
            raise ValueError("placements is None, must provide placements")

        # Create Tensor subclass instance, sharing local_tensor's underlying storage
        t = Tensor._make_subclass(cls, local_tensor, local_tensor.requires_grad)
        t.__init_data__(local_tensor, device_mesh, placements, layout, shape)

        Args:
            value (bool): True to enable gradient computation, False to disable.
        """
        self._local_tensor.requires_grad_(value)
        # Sync DTensor wrapper's requires_grad
        super().requires_grad_(value)

    def requires_grad_(self, requires_grad: bool = True):
        """
        Enable or disable gradient computation in-place.

        Returns:
            DTensorBase: Self for method chaining.
        """
        if self._local_tensor.grad is not None:
            self._local_tensor.grad.zero_()
        return self

    def detach(self):
        """
        Create a detached DTensor that does not require gradient.

        Returns:
            DTensorBase: Self for method chaining.
        """
        self._local_tensor.detach_()
        super().detach_()
        return self

    # ====================== Computation graph related overrides ======================
    @property
    def is_leaf(self) -> bool:

        Returns:
            bool: True if gradients are retained for non-leaf tensors.
        """
        return self._local_tensor.retains_grad

    @retains_grad.setter
    def retains_grad(self, value: bool) -> None:
        """

        Args:
            value (bool): True to enable gradient retention.
        """
        self._local_tensor.retains_grad_(value)

    def backward(self, gradient=None, retain_graph=None, create_graph=False) -> None:
        """
        Compute the gradients for this tensor.

            gradient (Optional[Tensor]): The gradient of the loss w.r.t. this tensor.
            retain_graph (Optional[bool]): Whether to retain the computation graph.
            create_graph (bool): Whether to create a graph of the gradient computation.
        """
        self._local_tensor.backward(gradient, retain_graph, create_graph)

    # ====================== Metadata related overrides (sync with local_tensor) ======================
    @property
    def device(self) -> torch.device:

        Returns:
            torch.Size: The shape of the tensor.
        """
        return self._local_tensor.shape

    def type(self, dtype=None, non_blocking=False):
        """
        Convert this tensor to the specified dtype.

        Returns:
            Union[str, DTensorBase]: The type string if dtype is None, otherwise a new DTensor.
        """
        if dtype is None:
            return self._local_tensor.type()
        new_local = self._local_tensor.to(dtype=dtype, non_blocking=non_blocking)
        return self.__class__(
            new_local,
            device_mesh=self._device_mesh,
            placements=self._alias_placements(),
            shape=getattr(self, "_global_shape", None),

        Returns:
            Union[torch.Size, int]: The shape or size along a specific dimension.
        """
        return self._local_tensor.size(dim)

    @property
    def ndim(self) -> int:
        """

        Returns:
            int: The number of dimensions.
        """
        return self._local_tensor.ndim

    def data_ptr(self) -> int:
        """
        Get the pointer to the data storage of the local tensor.

        Returns:
            int: The memory address of the tensor's data.
        """
        # Force return local_tensor's data pointer (ensure address consistency)
        return self._local_tensor.data_ptr()

    def numel(self) -> int:
        """
        Get the total number of elements in this tensor.

        Returns:
            int: The total number of elements.
        """
        return self._local_tensor.numel()

    # ====================== Auxiliary print ======================
    def _alias_placements(self):
        """Return alias_placements from layout, falling back to _placements."""
        if hasattr(self, '_layout') and self._layout is not None:
            return self._layout.alias_placements
        return self._placements

    def to(self, *args, **kwargs):
        """Move the DTensor to a different device or dtype.

        Returns:
            DTensorBase: A new DTensor with the converted local tensor.
        """
        new_local = self._local_tensor.to(*args, **kwargs)
        new_dt = Tensor._make_subclass(type(self), new_local, new_local.requires_grad)
        new_dt.__init_data__(
            new_local,
            self._device_mesh,
            self._alias_placements(),
            shape=getattr(self, "_global_shape", None),

            self._device_mesh,
            self._alias_placements(),
            shape=getattr(self, "_global_shape", None),
        )
        return new_dt

    def __repr__(self) -> str:
        return (
            f"DTensor(\n"
            f"  local_tensor={self._local_tensor},\n"
            f"  device_mesh={self._device_mesh},\n"
            f"  placements={self._placements},\n"

    # pylint: disable=W0212
    @staticmethod
    def update_param_data(param, data):
        """update param data"""
        param._update_data(data)

    @staticmethod
    def load_into_param(param, data):
        copy_tensor = MindSporePlatform.empty_like(data)

    @staticmethod
    def load_into_param(param, data):
        copy_tensor = MindSporePlatform.empty_like(data)
        copy_tensor.copy_(data)
        param._update(copy_tensor)

    @staticmethod
    def get_cell_construct(cell):
        return cell.construct