code: def use_np_default_dtype(func):
      """A decorator wrapping a function or class with activated NumPy-default_dtype semantics.
      When `func` is a function, this ensures that the execution of the function is scoped with NumPy
      default dtype semantics, with the support for float64 as default dtype.
      When`func` is a class, it ensures that all the methods, static functions, and properties
      of the class are executed with the NumPy-default_dtype semantics.
  
      .. code-block:: python
  
          import mxnet as mx
          @mx.use_np_default_dtype
          def float64_one():
              return mx.nd.ones(()).dtype
          print(float64_one())
  
          @np.use_np_default_dtype
          class Float64Tensor(object):
              def __init__(self, data=None):
                  if data is None:
                      data = Float64Tensor.random().data
                  self._data = data
  
              def __repr__(self):
                  print("Is __repr__ in np_default_dtype semantics? {}!".format(str(np.is_np_deafult_dtype())))
                  return str(self._data.asnumpy())
  
              @staticmethod
              def random():
                  data = mx.nd.random.uniform(shape=(2,2))
                  return ScalarTensor(data)
  
              @property
              def value(self):
                  print("Is value property in np_dafault_dtype semantics? {}!".format(str(np.is_np_default_dtype())))
                  return self._data.asnumpy()
  
          print("Is global scope of np_default_dtype activated? {}!".format(str(np.is_np_default_dtype())))
          float64_tensor = Float64Tensor()
          print(float64_tensor)
  
  
      Parameters
      ----------
      func : a user-provided callable function or class to be scoped by the NumPy-default_dtype semantics.
  
      Returns
      -------
      Function or class
          A function or class wrapped in the NumPy-default_dtype scope.
      """
      if inspect.isclass(func):
          for name, method in inspect.getmembers(
              func,
              predicate=lambda f: inspect.isfunction(f)
              or inspect.ismethod(f)
              or isinstance(f, property),
          ):
              if isinstance(method, property):
                  setattr(
                      func,
                      name,
                      property(
                          use_np_default_dtype(method.__get__),
                          method.__set__,
                          method.__delattr__,
                          method.__doc__,
                      ),
                  )
              else:
                  setattr(func, name, use_np_default_dtype(method))
          return func
      elif callable(func):
  
          @functools.wraps(func)
          def _with_np_default_dtype(*args, **kwargs):
              with np_default_dtype(active=True):
                  return func(*args, **kwargs)
  
          return _with_np_default_dtype
      else:
          raise TypeError(
              "use_np_default_dtype can only decorate classes and callable objects, "
              "while received a {}".format(str(type(func)))
          )
  
imports: import ctypes
  import functools
  import inspect
  import threading
  import tempfile
  import platform
  from contextlib import contextmanager
  from struct import calcsize
  from .base import _LIB, check_call, c_str, py_str, numeric_types, integer_types, long, _MAX_VALUE_64_BIT_UNSIGNED_, _MAX_VALUE_64_BIT_SIGNED_, _MAX_VALUE_FLOAT32_REPRESENT_
label_desc: Use image node_id 27 for calling a global function with example usage: use_np_default_dtype(func) and returns: func, _with_np_default_dtype, func