Return :class:`NativeModel` fully loaded into memory.

def create_model(self):
        """Return :class:`NativeModel` fully loaded into memory."""

        properties = {
            'name': self.name,
            'biomass': self.biomass_reaction,
            'extracellular': self.extracellular_compartment,
            'default_compartment': self.default_compartment,
            'default_flux_limit': self.default_flux_limit
        }

        if self.context is not None:
            git_version = util.git_try_describe(self.context.basepath)
            properties['version_string'] = git_version

        model = NativeModel(properties)

        # Load compartments into model
        compartment_iter, boundaries = self.parse_compartments()
        for compartment in compartment_iter:
            model.compartments.add_entry(compartment)
        model.compartment_boundaries.update(boundaries)

        # Load compounds into model
        for compound in self.parse_compounds():
            if compound.id in model.compounds:
                existing_entry = model.compounds[compound.id]
                common_props = set(compound.properties).intersection(
                    existing_entry.properties).difference({'id'})
                if len(common_props) > 0:
                    logger.warning(
                        'Compound entry {} at {} overrides already defined'
                        ' properties: {}'.format(
                            compound.id, compound.filemark, common_props))

                properties = dict(compound.properties)
                properties.update(existing_entry.properties)
                compound = CompoundEntry(
                    properties, filemark=compound.filemark)
            model.compounds.add_entry(compound)

        # Load reactions into model
        for reaction in self.parse_reactions():
            if reaction.id in model.reactions:
                existing_entry = model.reactions[reaction.id]
                common_props = set(reaction.properties).intersection(
                    existing_entry.properties).difference({'id'})
                if len(common_props) > 0:
                    logger.warning(
                        'Reaction entry {} at {} overrides already defined'
                        ' properties: {}'.format(
                            reaction.id, reaction.filemark, common_props))

                properties = dict(reaction.properties)
                properties.update(existing_entry.properties)
                reaction = ReactionEntry(
                    properties, filemark=reaction.filemark)
            model.reactions.add_entry(reaction)

        for exchange_def in self.parse_exchange():
            model.exchange[exchange_def[0]] = exchange_def

        for limit in self.parse_limits():
            model.limits[limit[0]] = limit

        if self.has_model_definition():
            for model_reaction in self.parse_model():
                model.model[model_reaction] = None
        else:
            for reaction in model.reactions:
                model.model[reaction.id] = None

        return model