code: def get_compaction_options(model):
      
      if not model.__compaction__:
          return {}
  
      result = {'class':model.__compaction__}
  
      def setter(key, limited_to_strategy = None):
          """
          sets key in result, checking if the key is limited to either SizeTiered or Leveled
          :param key: one of the compaction options, like "bucket_high"
          :param limited_to_strategy: SizeTieredCompactionStrategy, LeveledCompactionStrategy
          :return:
          """
          mkey = "__compaction_{}__".format(key)
          tmp = getattr(model, mkey)
          if tmp and limited_to_strategy and limited_to_strategy != model.__compaction__:
              raise CQLEngineException("{} is limited to {}".format(key, limited_to_strategy))
  
          if tmp:
              # Explicitly cast the values to strings to be able to compare the
              # values against introspected values from Cassandra.
              result[key] = str(tmp)
  
      setter('tombstone_compaction_interval')
      setter('tombstone_threshold')
  
      setter('bucket_high', SizeTieredCompactionStrategy)
      setter('bucket_low', SizeTieredCompactionStrategy)
      setter('max_threshold', SizeTieredCompactionStrategy)
      setter('min_threshold', SizeTieredCompactionStrategy)
      setter('min_sstable_size', SizeTieredCompactionStrategy)
  
      setter('sstable_size_in_mb', LeveledCompactionStrategy)
  
      return result
docs: Generates dictionary (later converted to a string) for creating and altering
      tables with compaction strategy
  
      :param model:
      :return: