content: from typing import *
  
  BACKEND = 'spconv' 
  DEBUG = False
  ATTN = 'xformers'
  
  def __from_env():
      import os
      
      global BACKEND
      global DEBUG
      global ATTN
      
      env_sparse_backend = os.environ.get('SPARSE_BACKEND')
      env_sparse_debug = os.environ.get('SPARSE_DEBUG')
      env_sparse_attn = os.environ.get('SPARSE_ATTN_BACKEND')
      if env_sparse_attn is None:
          env_sparse_attn = os.environ.get('ATTN_BACKEND')
  
      if env_sparse_backend is not None and env_sparse_backend in ['spconv', 'torchsparse']:
          BACKEND = env_sparse_backend
      if env_sparse_debug is not None:
          DEBUG = env_sparse_debug == '1'
      if env_sparse_attn is not None and env_sparse_attn in ['xformers', 'flash_attn']:
          ATTN = env_sparse_attn
          
      print(f"[SPARSE] Backend: {BACKEND}, Attention: {ATTN}")
          
  
  __from_env()
      
  
  def set_backend(backend: Literal['spconv', 'torchsparse']):
      global BACKEND
      BACKEND = backend
  
  def set_debug(debug: bool):
      global DEBUG
      DEBUG = debug
  
  def set_attn(attn: Literal['xformers', 'flash_attn']):
      global ATTN
      ATTN = attn
      
      
  import importlib
  
  __attributes = {
      'SparseTensor': 'basic',
      'sparse_batch_broadcast': 'basic',
      'sparse_batch_op': 'basic',
      'sparse_cat': 'basic',
      'sparse_unbind': 'basic',
      'SparseGroupNorm': 'norm',
      'SparseLayerNorm': 'norm',
      'SparseGroupNorm32': 'norm',
      'SparseLayerNorm32': 'norm',
      'SparseReLU': 'nonlinearity',
      'SparseSiLU': 'nonlinearity',
      'SparseGELU': 'nonlinearity',
      'SparseActivation': 'nonlinearity',
      'SparseLinear': 'linear',
      'sparse_scaled_dot_product_attention': 'attention',
      'SerializeMode': 'attention',
      'sparse_serialized_scaled_dot_product_self_attention': 'attention',
      'sparse_windowed_scaled_dot_product_self_attention': 'attention',
      'SparseMultiHeadAttention': 'attention',
      'SparseConv3d': 'conv',
      'SparseInverseConv3d': 'conv',
      'SparseDownsample': 'spatial',
      'SparseUpsample': 'spatial',
      'SparseSubdivide' : 'spatial'
  }
  
  __submodules = ['transformer']
  
  __all__ = list(__attributes.keys()) + __submodules
  
  def __getattr__(name):
      if name not in globals():
          if name in __attributes:
              module_name = __attributes[name]
              module = importlib.import_module(f".{module_name}", __name__)
              globals()[name] = getattr(module, name)
          elif name in __submodules:
              module = importlib.import_module(f".{name}", __name__)
              globals()[name] = module
          else:
              raise AttributeError(f"module {__name__} has no attribute {name}")
      return globals()[name]
  
  
  # For Pylance
  if __name__ == '__main__':
      from .basic import *
      from .norm import *
      from .nonlinearity import *
      from .linear import *
      from .attention import *
      from .conv import *
      from .spatial import *
      import transformer
  