How to use threads with sqlalchemy?

Question

my design idea is, that 'db objects' will have implemented some methods, and after querying and checking relevant values i want to pass this instance to threading.Thread() and execute some code in different thread. I wanted to use scoped_session for this.

Problem is that instance contains session object and therefore it is throwing exception:

sqlite3.ProgrammingError: SQLite objects created in a thread can only be used in that same thread. The object was created in thread id 140081404675584 and this is thread id 140081133512448.

db_alchemy/__init__.py:

from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import scoped_session, sessionmaker

Base = declarative_base()
e = create_engine("sqlite:///datafiles/data.sqlite")
Base.metadata.create_all(e)
Session = scoped_session(sessionmaker(bind=e))

db_alchemy/tables.py:

import threading

from sqlalchemy import Column, Integer, String, ForeignKey, DateTime, Time
from sqlalchemy.ext.associationproxy import association_proxy
from sqlalchemy.ext.declarative import declarative_base, declared_attr
from sqlalchemy.orm import relationship, backref

from db_alchemy import Base, Session

    class Request(Base):
        __tablename__ = 'request'
        id = Column(Integer, primary_key=True)
        scan_title = Column(String)
        status = Column(String)
        servers = association_proxy('request_servers','server')

        def print_servers(self):
            print(threading.current_thread())
            print(self.servers)

    class Server(Base):
        __tablename__ = 'server'
        ip = Column(String, primary_key=True, autoincrement=False)


    class Request2Server(Base):
        __tablename__ = 'request2server'
        request_id_fk = Column(Integer, ForeignKey('request.id'), primary_key=True)
        server_ip_fk = Column(String, ForeignKey('server.ip'), primary_key=True)
        request_rel = relationship('Request', backref=backref('request_servers',lazy='dynamic'))
        server = relationship('Server', backref=backref('server_requests',lazy='dynamic'))

        def __init__(self, server=None):
            self.server = server

runner.py:

import threading
from threading import Thread

import db_alchemy.tables as t

from db_alchemy import Session, Base, e

if __name__ == '__main__':
    Base.metadata.drop_all(e)
    Base.metadata.create_all(e)
    ses = Session()

    r1 = t.Request(scan_title='R1', status='running')
    r2 = t.Request(scan_title='R2', status='finished')
    s1 = t.Server(ip='IP1')
    s2 = t.Server(ip='IP2')

    r1.servers.append(s1)
    r1.servers.append(s2)
    r2.servers.append(s2)

    ses.add_all([r1, r2])
    ses.commit()

    for request in ses.query(t.Request).filter(t.Request.status == 'running').all():
        print(threading.current_thread())
        r1.print_servers()

        Thread(target=r1.print_servers).start()

Is it possible to avoid this error in this design? Is there some different design i should implement?