code: def __init__(self, arg1, shape=None, dtype=None, copy=False):
      from cupyx import cusparse
  
      if shape is not None:
          if not _util.isshape(shape):
              raise ValueError(
                  "invalid shape (must be a 2-tuple of int)"
              )
          shape = int(shape[0]), int(shape[1])
  
      if _base.issparse(arg1):
          x = arg1.asformat(self.format)
          data = x.data
          indices = x.indices
          indptr = x.indptr
  
          if arg1.format != self.format:
              # When formats are differnent, all arrays are already copied
              copy = False
  
          if shape is None:
              shape = arg1.shape
  
      elif _util.isshape(arg1):
          m, n = arg1
          m, n = int(m), int(n)
          data = basic.zeros(0, dtype if dtype else "d")
          indices = basic.zeros(0, "i")
          indptr = basic.zeros(self._swap(m, n)[0] + 1, dtype="i")
          # shape and copy argument is ignored
          shape = (m, n)
          copy = False
  
      elif scipy_available and scipy.sparse.issparse(arg1):
          # Convert scipy.sparse to cupyx.scipy.sparse
          x = arg1.asformat(self.format)
          data = cupy.array(x.data)
          indices = cupy.array(x.indices, dtype="i")
          indptr = cupy.array(x.indptr, dtype="i")
          copy = False
  
          if shape is None:
              shape = arg1.shape
  
      elif isinstance(arg1, tuple) and len(arg1) == 2:
          # Note: This implementation is not efficeint, as it first
          # constructs a sparse matrix with coo format, then converts it to
          # compressed format.
          sp_coo = _coo.coo_matrix(
              arg1, shape=shape, dtype=dtype, copy=copy
          )
          sp_compressed = sp_coo.asformat(self.format)
          data = sp_compressed.data
          indices = sp_compressed.indices
          indptr = sp_compressed.indptr
  
      elif isinstance(arg1, tuple) and len(arg1) == 3:
          data, indices, indptr = arg1
          if not (
              _base.isdense(data)
              and data.ndim == 1
              and _base.isdense(indices)
              and indices.ndim == 1
              and _base.isdense(indptr)
              and indptr.ndim == 1
          ):
              raise ValueError(
                  "data, indices, and indptr should be 1-D"
              )
  
          if len(data) != len(indices):
              raise ValueError(
                  "indices and data should have the same size"
              )
  
      elif _base.isdense(arg1):
          if arg1.ndim > 2:
              raise TypeError("expected dimension <= 2 array or matrix")
          elif arg1.ndim == 1:
              arg1 = arg1[None]
          elif arg1.ndim == 0:
              arg1 = arg1[None, None]
          data, indices, indptr = self._convert_dense(arg1)
          copy = False
          if shape is None:
              shape = arg1.shape
  
      else:
          raise ValueError("Unsupported initializer format")
  
      if dtype is None:
          dtype = data.dtype
      else:
          dtype = numpy.dtype(dtype)
  
      if dtype.char not in "?fdFD":
          raise ValueError(
              "Only bool, float32, float64, complex64 and complex128 "
              "are supported"
          )
  
      data = data.astype(dtype, copy=copy)
      sparse_data._data_matrix.__init__(self, data)
  
      self.indices = indices.astype("i", copy=copy)
      self.indptr = indptr.astype("i", copy=copy)
  
      if shape is None:
          shape = self._swap(len(indptr) - 1, int(indices.max()) + 1)
  
      major, minor = self._swap(*shape)
      if len(indptr) != major + 1:
          raise ValueError(
              "index pointer size (%d) should be (%d)"
              % (len(indptr), major + 1)
          )
  
      self._descr = cusparse.MatDescriptor.create()
      self._shape = shape
  
imports: import string
  import warnings
  import numpy
  import cupy
  import cupyx
  from cupy import _core
  from cupy._core import _scalar
  from cupy._creation import basic
  from cupyx.scipy.sparse import _base
  from cupyx.scipy.sparse import _coo
  from cupyx.scipy.sparse import _data
  from cupyx.scipy.sparse import _sputils
  from cupyx.scipy.sparse import _util
  from cupyx.scipy.sparse import _index
label_desc: Use image node_id 1 to create a new _compressed_sparse_matrix object from inherited base classes: sparse_data, sparse_data, _index with example: obj = _compressed_sparse_matrix(arg1, shape, dtype, copy)