Join related table of related table in SQLAlchemy

I have a table, dna_extraction_protocols which contains data about DNA extraction protocols. A number of keys are occupied by Incubation objects stored on the incubations table. The incubations have a duration_unit key which contains a MeasurementUnit object, which is contained in the measurement_units table.

These tables are created like so:

class DNAExtractionProtocol(Protocol):
    __tablename__ = 'dna_extraction_protocols'
    __mapper_args__ = {'polymorphic_identity': 'dna_extraction'}
    id = Column(Integer, ForeignKey('protocols.id'), primary_key=True)
    sample_mass = Column(Float)
    mass_unit_id = Column(String, ForeignKey('measurement_units.id'))
    mass_unit = relationship("MeasurementUnit", foreign_keys=[mass_unit_id])
    digestion_buffer_id = Column(String, ForeignKey("solutions.id"))
    digestion_buffer = relationship("Solution", foreign_keys=[digestion_buffer_id])
    digestion_buffer_volume = Column(Float)
    digestion_id = Column(Integer, ForeignKey("incubations.id"))
    digestion = relationship("Incubation", foreign_keys=[digestion_id])
    lysis_buffer_id = Column(String, ForeignKey("solutions.id"))
    lysis_buffer = relationship("Solution", foreign_keys=[lysis_buffer_id])
    lysis_buffer_volume = Column(Float)
    lysis_id = Column(Integer, ForeignKey("incubations.id"))
    lysis = relationship("Incubation", foreign_keys=[lysis_id])
    proteinase_id = Column(String, ForeignKey("solutions.id"))
    proteinase = relationship("Solution", foreign_keys=[proteinase_id])
    proteinase_volume = Column(Float)
    inactivation_id = Column(Integer, ForeignKey("incubations.id"))
    inactivation = relationship("Incubation", foreign_keys=[inactivation_id])
    cooling_id = Column(Integer, ForeignKey("incubations.id"))
    cooling = relationship("Incubation", foreign_keys=[cooling_id])
    centrifugation_id = Column(Integer, ForeignKey("incubations.id"))
    centrifugation = relationship("Incubation", foreign_keys=[centrifugation_id])

    volume_unit_id = Column(String, ForeignKey('measurement_units.id'))
    volume_unit = relationship("MeasurementUnit", foreign_keys=[volume_unit_id])

class Incubation(Base):
    __tablename__ = "incubations"
    id = Column(Integer, primary_key=True)
    speed = Column(Float)
    duration = Column(Float)
    temperature = Column(Float)
    movement = Column(String) # "centrifuge" or "shake"

    #speed - usually in RPM - will refer to either centrifugation or shaking (See above)
    speed_unit_id = Column(String, ForeignKey('measurement_units.id'))
    speed_unit = relationship("MeasurementUnit", foreign_keys=[speed_unit_id])
    duration_unit_id = Column(String, ForeignKey('measurement_units.id'))
    duration_unit = relationship("MeasurementUnit", foreign_keys=[duration_unit_id])
    temperature_unit_id = Column(String, ForeignKey('measurement_units.id'))
    temperature_unit = relationship("MeasurementUnit", foreign_keys=[temperature_unit_id]

class MeasurementUnit(Base):
    __tablename__ = "measurement_units"
    id = Column(Integer, primary_key=True)
    code = Column(String, unique=True)
    long_name = Column(String)
    siunitx = Column(String)

Now, I would like to extract a Pandas dataframe, where I can get all the attributes of the DNAPurificationProtocol object, of a linked Incubation object, and of a linked MeasurementUnit object.

I have tried a number of approaches, and this one seems to work nicely for the first relationship:

sql_query = session.query(DNAExtractionProtocol, MeasurementUnit, Incubation) \
    .join(MeasurementUnit, MeasurementUnit.id == DNAExtractionProtocol.volume_unit_id) \
    .join(Incubation, Incubation.id == DNAExtractionProtocol.lysis_id) \
    .filter(tables[table].code == code)

But what to me felt like a logical extension:

sql_query = session.query(DNAExtractionProtocol, MeasurementUnit, Incubation) \
    .join(MeasurementUnit, MeasurementUnit.id == DNAExtractionProtocol.volume_unit_id) \
    .join(Incubation, Incubation.id == DNAExtractionProtocol.lysis_id) \
    .join(MeasurementUnit, MeasurementUnit.id == Incubation.temperature_unit_id) \
    .filter(tables[table].code == code)

Fails with:

sqlalchemy.exc.OperationalError: (sqlite3.OperationalError) ambiguous column name: measurement_units.id [SQL: u'SELECT protocols.type, dna_extraction_protocols.id, protocols.id, protocols.code, protocols.name, dna_extraction_protocols.sample_mass, dna_extraction_protocols.mass_unit_id, dna_extraction_protocols.digestion_buffer_id, dna_extraction_protocols.digestion_buffer_volume, dna_extraction_protocols.digestion_id, dna_extraction_protocols.lysis_buffer_id, dna_extraction_protocols.lysis_buffer_volume, dna_extraction_protocols.lysis_id, dna_extraction_protocols.proteinase_id, dna_extraction_protocols.proteinase_volume, dna_extraction_protocols.inactivation_id, dna_extraction_protocols.cooling_id, dna_extraction_protocols.centrifugation_id, dna_extraction_protocols.volume_unit_id, measurement_units.id, measurement_units.code, measurement_units.long_name, measurement_units.siunitx, incubations.id, incubations.speed, incubations.duration, incubations.temperature, incubations.movement, incubations.speed_unit_id, incubations.duration_unit_id, incubations.temperature_unit_id \nFROM protocols JOIN dna_extraction_protocols ON protocols.id = dna_extraction_protocols.id JOIN measurement_units ON measurement_units.id = dna_extraction_protocols.volume_unit_id JOIN incubations ON incubations.id = dna_extraction_protocols.lysis_id JOIN measurement_units ON measurement_units.id = incubations.temperature_unit_id \nWHERE protocols.code = ?'] [parameters: ('EPDqEP',)]

Any idea how else I can get what I am looking for?