code: def cat_second(tensors: List[SparseTensor]) -> SparseTensor:
      rows: List[torch.Tensor] = []
      cols: List[torch.Tensor] = []
      values: List[torch.Tensor] = []
      sparse_sizes: List[int] = [0, 0]
      colptrs: List[torch.Tensor] = []
      colcounts: List[torch.Tensor] = []
  
      nnz: int = 0
      for tensor in tensors:
          row, col, value = tensor.coo()
          rows.append(row)
          cols.append(tensor.storage._col + sparse_sizes[1])
  
          if value is not None:
              values.append(value)
  
          colptr = tensor.storage._colptr
          if colptr is not None:
              colptrs.append(
                  colptr[1:] + nnz if len(colptrs) > 0 else colptr
              )
  
          colcount = tensor.storage._colcount
          if colcount is not None:
              colcounts.append(colcount)
  
          sparse_sizes[0] = max(sparse_sizes[0], tensor.sparse_size(0))
          sparse_sizes[1] += tensor.sparse_size(1)
          nnz += tensor.nnz()
  
      row = torch.cat(rows, dim=0)
      col = torch.cat(cols, dim=0)
  
      value: Optional[torch.Tensor] = None
      if len(values) == len(tensors):
          value = torch.cat(values, dim=0)
  
      colptr: Optional[torch.Tensor] = None
      if len(colptrs) == len(tensors):
          colptr = torch.cat(colptrs, dim=0)
  
      colcount: Optional[torch.Tensor] = None
      if len(colcounts) == len(tensors):
          colcount = torch.cat(colcounts, dim=0)
  
      storage = SparseStorage(
          row=row,
          rowptr=None,
          col=col,
          value=value,
          sparse_sizes=(sparse_sizes[0], sparse_sizes[1]),
          rowcount=None,
          colptr=colptr,
          colcount=colcount,
          csr2csc=None,
          csc2csr=None,
          is_sorted=False,
      )
      return tensors[0].from_storage(storage)
  
file_path: pytorch_sparse/torch_sparse/cat.py
imports: from typing import Optional, List, Tuple
  import torch
  from torch_sparse.storage import SparseStorage
  from torch_sparse.tensor import SparseTensor
label_desc: Use image node_id 6 for calling a global function with example usage: cat_second(tensors) and returns: tensors