code: def infer_data_type(data_container):
      
      # Defensive programming checks.
      # 0. Ensure that we are dealing with lists or tuples, and nothing else.
      assert isinstance(data_container, list) or isinstance(
          data_container, tuple
      ), "data_container should be a list or tuple."
      # 1. Don't want to deal with only single values.
      assert (
          len(set(data_container)) > 1
      ), "There should be more than one value in the data container."
      # 2. Don't want to deal with mixed data.
      assert is_data_homogenous(
          data_container
      ), "Data are not of a homogenous type!"
  
      # Once we check that the data type of the container is homogenous, we only
      # need to check the first element in the data container for its type.
      datum = data_container[0]
  
      # Return statements below
      # treat binomial data as categorical
      # TODO: make tests for this.
      if len(set(data_container)) == 2:
          return "categorical"
  
      elif isinstance(datum, str):
          return "categorical"
  
      elif isinstance(datum, int):
          return "ordinal"
  
      elif isinstance(datum, float):
          return "continuous"
  
      else:
          raise ValueError("Not possible to tell what the data type is.")
docs: For a given container of data, infer the type of data as one of
      continuous, categorical, or ordinal.
  
      For now, it is a one-to-one mapping as such:
  
      - str:   categorical
      - int:   ordinal
      - float: continuous
  
      There may be better ways that are not currently implemented below. For
      example, with a list of numbers, we can check whether the number of unique
      entries is less than or equal to 12, but has over 10000+ entries. This
      would be a good candidate for floats being categorical.
  
      :param data_container: A generic container of data points.
      :type data_container: `iterable`