docs: def _process_pheno_enviro(self, limit=None):
          """
          The pheno_environment.txt (became pheno_environment_fish.txt?)
          file ties experimental conditions
          to an environment ID.
          An environment ID may have one or more associated conditions.
          Condition groups present:
          * chemical, physical, physiological,
          * salinity, temperature, _Generic-control
  
          First, we build a nice human-readable label
          of all of the components of the environment.
          This is added to our global id-label hash.
          TODO
          Eventually, we will add each component of the environment
          to an environmental object, but needs to be modeled first
  
          Triples created:
          <environment_id> is an Individual
          <environment_id> rdfs:label <environment_label>
          <environment_id> has type GENO:environment
  
          :param limit:
          :return:
  
          """
  
          LOG.info("Processing environments")
          if self.test_mode:
              graph = self.testgraph
          else:
              graph = self.graph
          line_counter = 0
          env_hash = {}
          envo = Environment(graph)
          # pp = pprint.PrettyPrinter(indent=4)
  
          raw = '/'.join((self.rawdir, self.files['enviro']['file']))
          with open(raw, 'r', encoding="iso-8859-1") as csvfile:
              filereader = csv.reader(csvfile, delimiter='\t', quotechar='\"')
              for row in filereader:
                  line_counter += 1
  
                  # (environment_num, condition_group,
                  #  condition, description, blank) = row
                  (environment_id,
                   zeco_term_name, zeco_term_id,
                   chebi_term_name, chebi_term_id,
                   zfa_term_name, zfa_term_id,
                   altered_structure_name, altered_structure_id,
                   ncbi_taxon_name, ncbi_taxon_id) = row
  
                  environment_id = 'ZFIN:' + environment_id.strip()
                  if self.test_mode and environment_id not in self.test_ids['environment']:
                      continue
  
                  # We can start to build the extrinsic genotype using this file.
                  # A single environment can have >1 row in the file,
                  # so we build a hash to store all the components of
                  # the environment first.
                  # Then we can build a label containing all the parts.
                  # Using a strategy similar to what is used for genotypes
                  # to get the VSLCs and GVCs.
  
                  if environment_id not in env_hash:
                      env_hash[environment_id] = []
  
                  # create environmental components, and add to the hash
                  # cleanup the "condition" to remove non-id-friendly chars
                  cond_id = zeco_term_id.strip()
                  cond_id = re.sub(r'\W+', '-', cond_id)
  
                  # TODO  Matt re model
                  # description is gone
                  # condition is gone
                  # condition_group is gone
                  # subcond_id = description.strip()
                  # subcond_id = re.sub(r'\W+', '-', subcond_id)
                  # env_component_id = '-'.join((condition_group.strip(),
                  #                             cond_id.strip()))
                  # if subcond_id != '':
                  #   env_component_id = '-'.join((env_component_id, subcond_id))
                  # make them blank nodes
                  # env_component_id = '_:' + env_component_id
                  # env_condition = condition.strip()
                  # env_component_label = condition_group + '[' + condition + ']'
                  # if description != '':
                  #    env_component_label += ': ' + description
  
                  # self.id_label_map[env_component_id] = env_component_label
                  # env_hash[environment_id] += [env_component_id]
  
                  # if environment_id not in enviro_label_hash:
                  #   enviro_label_hash[environment_id] = [env_component_id]
                  # else:
                  #    enviro_label_hash[environment_id].append(env_component_id)
  
                  # add each component to the environment as a part
                  # envo.addEnvironmentalCondition(
                  #    env_component_id, env_component_label)
  
                  if not self.test_mode and limit is not None and line_counter > limit:
                      break
  
                  # End of loop through pheno_env file
  
          csvfile.close()
  
          LOG.info("Building complex environments from components")
  
          self.environment_hash = env_hash
  
          # iterate through the env hash to build the full environment label
          for env_id in env_hash:
              environment_labels = []
              env_hash[env_id].sort()
              env_component_list = env_hash[env_id]
              for env_comp_id in env_component_list:
                  env_comp_label = self.id_label_map[env_comp_id]
                  environment_labels += [env_comp_label]
                  envo.addComponentToEnvironment(env_id, env_comp_id)
              environment_labels.sort()
              env_label = 'Environment that includes: ' + '; '.join(environment_labels)
              envo.addEnvironment(env_id, env_label)
              self.id_label_map[env_id] = env_label
  
          LOG.info("Done with environments")
  
          return