sqlalchemy : obtenir nom plutot que id dans le cas de tables jointes

Question

J'ai un robot qui est "composé" entre autre d'un moteur et d'un capteur.
lorsque je veux afficher les robots, j' obtiens l' id du moteur et du capteur plutot que leurs noms.
J' aimerai le nom à la place.
La bdd va provenir de model.py , et j' obtiens une vue sur v_robots.py

model.py

class Engine(Base):

    __tablename__ = 'Engines'
    Engine_id = Column(Integer, primary_key=True)
    name = Column(String)
    power = Column(Integer)
    thermic = Column(Boolean, default=False, nullable=False)
    heat = Column(Integer)

    def __init__(self, name, power, thermic, heat):

        self.name = name
        self.power = power
        self.thermic = thermic
        self.heat = heat

    def __str__(self):
        return ("Engine {} has power {} , thermic is {}, heat is {}".format(self.name, self.power, self.thermic, self.heat))

    def give_power(self, target):

        target.power += self.power
        if self.thermic is True:
            self.heat += power


class Captor(Base):

    __tablename__ = 'Captors'
    Captor_id = Column(Integer, primary_key=True)
    name = Column(String)
    purpose = Column(String)
    conso = Column(Integer)
    is_active = Column(Boolean, default=False, nullable=False)

    def __init__(self, name, purpose, conso, is_active):

        self.name = name
        self.purpose = purpose
        self.conso = conso
        self.is_active = is_active

class Robot(Base):

    __tablename__ = 'Robots'
    Robot_id = Column(Integer, primary_key=True)
    name = Column(String)

    Engine_id = Column(Integer(), ForeignKey('Engines.Engine_id'))
    Captor_id = Column(Integer(), ForeignKey('Captors.Captor_id'))

    Engine = relationship("Engine", backref=backref('Robots', order_by=Robot_id))
    Captor = relationship("Captor", backref=backref('Robots', order_by=Robot_id))

    def __init__(self, **dico): 

        self.name = dico["name"]

        self.Engine = dico["Engine"]
        self.Captor = dico["Captor"]

    def __str__(self):
        return (
            " Robot {} has engine {} and captor {} ".
            format(self.name, self.Engine, self.Captor))

Base.metadata.create_all(engine)

from marshmallow_sqlalchemy import ModelSchema


class EngineSchema(ModelSchema):
    class Meta:
        model = Engine

class CaptorSchema(ModelSchema):
    class Meta:
        model = Captor

class RobotSchema(ModelSchema):
    class Meta:
        model = Robot


def ask_marsh(tablette):
    """
    permet de renvoyer les infos pour produire la vue vers v_robots.py , v_engines.py ou v_captors.py
    """

    Engines_q = session.query(Engine)
    Captors_q = session.query(Captor)
    Robots_q = session.query(Robot) # ici j'ai le probleme des id de engine et captor car en table jointe


    output_Engines = EngineSchema(many=True).dump(Engines_q).data
    output_Captors = CaptorSchema(many=True).dump(Captors_q).data
    output_Robots = RobotSchema(many=True).dump(Robots_q).data    

    if tablette == 'v_Engines':
        return json.dumps({'Engines' : output_Engines})

    elif tablette == 'v_Captors':
        return json.dumps({'Captors' : output_Captors})

    elif tablette == 'v_Robots':
        return json.dumps({'Robots' : output_Robots})

v_robots.py

def create(parent):
    return v_Robots(parent)

class v_Robots(wx.Frame):
    def __init__(self, parent):
        wx.Frame.__init__(self, id=-1, name='', parent=parent, size=wx.Size(1000, 900), title='v_Robots')
        self.panel1 = wx.Panel(self, id=-1, size=wx.Size(1000, 900))
        wx.StaticText(self.panel1, id=-1, label='Hello from v_Robots', pos=wx.Point(12, 10))

        self.name = "v_Robots"

        self.datajson = model.ask_marsh(self.name)
        self.data = json.loads(self.datajson)

        iy= 0
        starty = 50

        for bidul in self.data["Robots"]:           

            print("\n ->->->  ",bidul["name"],"   ",bidul["Captor"],"   ",bidul["Engine"])