docs: def create_model(self):
          """Create model from reader.
  
          Returns:
              :class:`psamm.datasource.native.NativeModel`.
          """
          properties = {
              'name': self.name,
              'default_flux_limit': 1000
          }
  
          # Load objective as biomass reaction
          objective = self.get_active_objective()
          if objective is not None:
              reactions = dict(objective.reactions)
              if len(reactions) == 1:
                  reaction, value = next(iteritems(reactions))
                  if ((value < 0 and objective.type == 'minimize') or
                          (value > 0 and objective.type == 'maximize')):
                      properties['biomass'] = reaction
  
          model = NativeModel(properties)
  
          # Load compartments into model
          for compartment in self.compartments:
              model.compartments.add_entry(compartment)
  
          # Load compounds into model
          for compound in self.species:
              model.compounds.add_entry(compound)
  
          # Load reactions into model
          for reaction in self.reactions:
              model.reactions.add_entry(reaction)
  
          # Create model reaction set
          for reaction in model.reactions:
              model.model[reaction.id] = None
  
          # Convert reaction limits properties to proper limits
          for reaction in model.reactions:
              props = reaction.properties
              if 'lower_flux' in props or 'upper_flux' in props:
                  lower = props.get('lower_flux')
                  upper = props.get('upper_flux')
                  model.limits[reaction.id] = reaction.id, lower, upper
  
          # Load model limits from FBC V1 bounds if present, i.e. if FBC V1 is
          # used instead of V2.
          limits_lower = {}
          limits_upper = {}
          for bounds in self.flux_bounds:
              reaction = bounds.reaction
              if reaction in model.limits:
                  continue
  
              if bounds.operation == SBMLFluxBoundEntry.LESS_EQUAL:
                  if reaction not in limits_upper:
                      limits_upper[reaction] = bounds.value
                  else:
                      raise ParseError(
                          'Conflicting bounds for {}'.format(reaction))
              elif bounds.operation == SBMLFluxBoundEntry.GREATER_EQUAL:
                  if reaction not in limits_lower:
                      limits_lower[reaction] = bounds.value
                  else:
                      raise ParseError(
                          'Conflicting bounds for {}'.format(reaction))
              elif bounds.operation == SBMLFluxBoundEntry.EQUAL:
                  if (reaction not in limits_lower and
                          reaction not in limits_upper):
                      limits_lower[reaction] = bounds.value
                      limits_upper[reaction] = bounds.value
                  else:
                      raise ParseError(
                          'Conflicting bounds for {}'.format(reaction))
  
          for reaction in model.reactions:
              if reaction.id in limits_lower or reaction.id in limits_upper:
                  lower = limits_lower.get(reaction.id, None)
                  upper = limits_upper.get(reaction.id, None)
                  model.limits[reaction.id] = reaction.id, lower, upper
  
          return model