code: def __call__(self, a):
      import scipy.linalg
  
      a = astensor(a)
      if a.ndim != 2:
          raise LinAlgError(
              f"{a.ndim}-dimensional array given. Tensor must be two-dimensional"
          )
  
      if a.shape[0] > a.shape[1]:
          p_shape = (a.shape[0],) * 2
          l_shape = a.shape
          u_shape = (a.shape[1],) * 2
      elif a.shape[0] < a.shape[1]:
          p_shape = (a.shape[0],) * 2
          l_shape = (a.shape[0],) * 2
          u_shape = a.shape
      else:
          p_shape, l_shape, u_shape = (a.shape,) * 3
  
      tiny_p, tiny_l, tiny_u = scipy.linalg.lu(
          np.array([[1, 2], [2, 5]], dtype=a.dtype)
      )
  
      order = a.order
      p, l, u = self.new_tensors(
          [a],
          kws=[
              {
                  "side": "p",
                  "dtype": tiny_p.dtype,
                  "shape": p_shape,
                  "order": order,
              },
              {
                  "side": "l",
                  "dtype": tiny_l.dtype,
                  "shape": l_shape,
                  "order": order,
              },
              {
                  "side": "u",
                  "dtype": tiny_u.dtype,
                  "shape": u_shape,
                  "order": order,
              },
          ],
      )
      return ExecutableTuple([p, l, u])
  
file_path: mars/mars/tensor/linalg/lu.py
imports: import numpy
  from numpy.linalg import LinAlgError
  from ...None import opcodes
  from ...core import ExecutableTuple, recursive_tile
  from ...serialization.serializables import KeyField
  from ...utils import has_unknown_shape
  from ..array_utils import device, as_same_device, is_sparse_module
  from ..operands import TensorHasInput, TensorOperandMixin
  from ..datasource import tensor
label_desc: Use image node_id 2 for calling the TensorLU obj's underlying member method code with example usage: obj.__call__(a) and returns: ExecutableTuple