Python sqlalchemy无法更新我的模型

我正在尝试更新数据库模型。所以我尝试了下面的代码

if not sell_requests:
   request.r_quantity = request.quantity
   request.status = StatusEnum.opened

   print request
   print request.quantity
   print request.r_quantity
   con = session.commit()
   print con

请看，我进行了一次提交，但在打印所有db行时，原始行没有得到更新<代码>请求是一个sqlalchemy模型实例。上面代码的输出是

<models.RequestModel object at 0x323...>
12
12
None

我的整个文件看起来像这样

from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

# model base class
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from models import CompanyModel, RequestModel


Base = declarative_base()
engine = create_engine('sqlite:///sqlalchemy_test.db')
# Bind the engine to the metadata of the Base class so that the
# declaratives can be accessed through a DBSession instance
Base.metadata.bind = engine

DBSession = sessionmaker(bind=engine)
session = DBSession()

class Side:
    """
    ENUM class forstoring the request type
    """

    BUY = 1
    SELL = 2

    @classmethod
    def get_type_by_value(cls, value):
        return  next(k for k, v in cls.__dict__.items() if v == value)


class StatusEnum:
    opened = 1
    closed = 0

    @classmethod
    def get_type_by_value(cls, value):
        return  next(k for k, v in cls.__dict__.items() if v == value)


class RequestHelper:
    @classmethod
    def get_previous_buy_requests(cls, company):
        return session.query(RequestModel).filter(RequestModel.company == company.id, RequestModel.type == Side.BUY).all()

    @classmethod
    def get_previous_sell_requests(cls, company):
        return session.query(RequestModel).filter(RequestModel.company == company.id, RequestModel.type == Side.SELL).all()

    @classmethod
    def calc_r_quantity_and_status(cls, request):
        company = Company.get_by_id(request.company)

        if request.type == Side.BUY:

            # add buy quantity to the company's buy quantity
            company.buy_quantity += request.quantity

            sell_requests = cls.get_previous_sell_requests(company)

            # if not previous sell requests then r_quantity is same as quantity
            if not sell_requests:
                request.r_quantity = request.quantity
                request.status = StatusEnum.opened

                # print request
                # print request.quantity
                # print request.r_quantity
                session.commit()


                # close the previous buy request if opened
                prev_buy_requests = cls.get_previous_buy_requests(company)
                for req in prev_buy_requests:
                    if req.status == StatusEnum.opened:
                        req.r_quantity = 0
                        req.status = StatusEnum.closed
                        # session.add(req)

                session.commit()

            # any sell requests
            else:
                for sell in sell_requests:
                    if sell.status == StatusEnum.opened:

                        # check whether the sell quan is greater than current buy request quantity
                        # if greater then add the current buy req quantity with the existsing buy quantity else 
                        if sell.r_quantity < request.quantity:
                            company.buy_quantity += request.quantity
                            request.r_quantity = request.quantity - sell.r_quantity
                            request.status = StatusEnum.opened
                            sell.r_quantity = 0
                            sell.status = StatusEnum.closed
                        else:
                            sell.r_quantity -= request.quantity
                            company.sell_quantity = sell.r_quantity
                            request.r_quantity = 0
                            request.status = StatusEnum.closed
                        # session.add(request)
                        # session.add(sell)

                session.commit()

        elif request.type == Side.SELL:
            # add sell quantity to the company's sell quantity
            company.sell_quantity += request.quantity

            buy_requests = cls.get_previous_buy_requests(company)

            if not buy_requests:
                request.r_quantity = request.quantity
                request.status = StatusEnum.opened
                # session.add(request)

                prev_sell_requests = cls.get_previous_sell_requests(company)
                for req in prev_sell_requests:
                    if req.status == StatusEnum.opened:
                        req.r_quantity = 0
                        req.status = StatusEnum.closed
                        # session.add(req)

                session.commit()

            else:
                for buy in buy_requests:
                    if buy.status == StatusEnum.opened:
                        if buy.r_quantity > request.quantity:
                            company.buy_quantity = buy.r_quantity - request.quantity
                            request.r_quantity = 0
                            buy.r_quantity = company.buy_quantity

                            request.status = StatusEnum.closed

                        else:
                            request.r_quantity = request.quantity - buy.r_quantity
                            buy.r_quantity = 0
                            buy.status = StatusEnum.closed
                            request.status = StatusEnum.opened
                        # session.add(request)
                        # session.add(buy)
                session.commit()



class Company(object):
    @classmethod
    def get_or_create_company(cls, name):

        company = session.query(CompanyModel).filter(CompanyModel.name == name).all()
        if not company:
            company = CompanyModel(name=name, buy_quantity=0, sell_quantity=0)
            session.add(company)
            session.commit()
            return company

        return company[0]

    @classmethod
    def get_by_id(cls, id):
        com = session.query(CompanyModel).filter(CompanyModel.id == id)
        if com:
            return com.one()
        return None





class Requests(object):
    template_lines = []
    template_header =  'Side    |     Company   |  Quantity   |  RemaingQty |  Status'
    template_line_format = '{}    |    {}    |    {}     |    {}    |    {}'



    @classmethod
    def do_validation(cls, request_type, company, quantity):
        if request_type.upper() not in dir(Side):
            raise ValueError('Request type must be either buy or sell')

        if not company:
            raise ValueError('You must enter the company name')

        if not quantity or not quantity.isdigit():
            raise ValueError('You should enter integer value for quantity field')

    @classmethod
    def create_request(cls, request_type, company, quantity):
        new_request = RequestModel(type=request_type, company=company.id, quantity=quantity, r_quantity=0, status=0)
        session.add(new_request)
        session.commit()
        new_request.r_quantity = 2
        session.commit()

        print new_request.r_quantity

        return new_request



    @classmethod
    def generate_output(cls):
        requests = session.query(RequestModel).all()
        for ins in requests:
            print ins.r_quantity
            Requests.template_lines.append(Requests.template_line_format.format(Side.get_type_by_value(ins.type), Company.get_by_id(ins.company).name, ins.quantity, ins.r_quantity, StatusEnum.get_type_by_value(ins.status)))

        print Requests.template_header
        print '\r\n'.join(Requests.template_lines)


def main():
    # truncating models
    session.query(CompanyModel).delete()
    session.query(RequestModel).delete()


    while True:
        side = raw_input('Enter the side (buy/sell):\n')
        company = raw_input('Enter the company:\n')
        quantity = raw_input('Enter the quantity:\n')

        com = Company.get_or_create_company(company)

        # store the order request in db
        try:
            Requests.do_validation(side, com, quantity)
        except ValueError:
            continue

        new_request = Requests.create_request(getattr(Side, side.upper()), com, quantity)
        RequestHelper.calc_r_quantity_and_status(new_request)


        out = raw_input('Do you want to continue (Y/n)?\n')
        if out.lower() == 'n':
            Requests.generate_output()

            # truncating models
            session.query(CompanyModel).delete()
            session.query(RequestModel).delete()

            break

        continue



if __name__ == '__main__':
    main()

来自sqlalchemy.ext.declarative import declarative\u base
从sqlalchemy导入列，整数，字符串
从sqlalchemy.ext.declarative导入声明性基础
#模型基类
从sqlalchemy导入创建引擎
从sqlalchemy.orm导入sessionmaker
从模型导入公司模型，请求模型
Base=声明性_Base（）
引擎=创建引擎（'sqlite:///sqlalchemy_test.db')
#将引擎绑定到基类的元数据，以便
#可以通过DBSession实例访问声明
Base.metadata.bind=引擎
DBSession=sessionmaker（bind=engine）
session=DBSession（）
班级方面：
"""
用于保存请求类型的枚举类
"""
购买=1
卖出=2
@类方法
def按值获取类型（cls，值）：
返回next（k表示k，如果v==值，则在cls.\u dict\uu.items（）中为v）
类状态枚举：
打开=1
关闭=0
@类方法
def按值获取类型（cls，值）：
返回next（k表示k，如果v==值，则在cls.\u dict\uu.items（）中为v）
类RequestHelper：
@类方法
def获取以前的购买请求（cls、公司）：
return session.query（RequestModel）.filter（RequestModel.company==company.id，RequestModel.type==Side.BUY）.all（）
@类方法
def get_先前的_sell_请求（cls、公司）：
return session.query（RequestModel）.filter（RequestModel.company==company.id，RequestModel.type==Side.SELL）.all（）
@类方法
def校准数量和状态（cls、请求）：
company=company.get\u by\u id（request.company）
如果request.type==Side.BUY：
#将购买数量添加到公司的购买数量中
company.buy_数量+=request.quantity
销售请求=cls。获取以前的销售请求（公司）
#如果不是以前的销售请求，则r_数量与数量相同
如果不是销售申请：
request.r\u数量=request.quantity
request.status=StatusEnum.opened
#打印请求
#打印请求数量
#打印请求。r\u数量
session.commit（）
#如果打开，请关闭以前的购买请求
prev\u buy\u requests=cls.get\u previous\u buy\u requests（公司）
对于上一次购买请求中的请求：
如果req.status==StatusEnum.opened：
需求数量=0
req.status=状态ENUM.closed
#会话添加（req）
session.commit（）
#有任何销售要求吗
其他：
对于卖出请求：
如果sell.status==StatusEnum.opened：
#检查销售数量是否大于当前购买请求数量
#如果大于，则将当前购买请求数量与现有购买数量相加
如果销售数量<请求数量：
company.buy_数量+=request.quantity
request.r\u数量=request.quantity-sell.r\u数量
request.status=StatusEnum.opened
销售数量=0
sell.status=StatusEnum.closed
其他：
sell.r_数量-=request.quantity
company.sell\u数量=sell.r\u数量
request.r\u数量=0
request.status=StatusEnum.closed
#会话.添加（请求）
#会话.添加（出售）
session.commit（）
elif request.type==Side.SELL:
#将销售数量添加到公司的销售数量中
company.sell_数量+=request.quantity
购买请求=cls。获取以前的购买请求（公司）
如果不是购买请求：
request.r\u数量=request.quantity
request.status=StatusEnum.opened
#会话.添加（请求）
prev\u sell\u requests=cls.get\u previous\u sell\u requests（公司）
对于上一次销售请求中的请求：
如果req.status==StatusEnum.opened：
需求数量=0
req.status=状态ENUM.closed
#会话添加（req）
session.commit（）
其他：
对于buy-in buy_请求：
如果buy.status==StatusEnum.opened：
如果购买数量>请求数量：
company.buy\u数量=buy.r\u数量-request.quantity
request.r\u数量=0
buy.r\u数量=company.buy\u数量
request.status=StatusEnum.closed
其他：
request.r\u数量=request.quantity-buy.r\u数量
购买数量=0
buy.status=StatusEnum.closed
request.status=StatusEnum.opened
#会话.添加（请求）
#会话。添加（购买）
session.commit（）
类别公司（对象）：
@类方法
def get_或_create_公司（cls，名称）：
company=session.query（CompanyModel）.filter（CompanyModel.name==name）.all（）
如果不是公司：
公司=公司模型（名称=名称，购买数量=0，出售数量=0）
会话.添加（公司）
session.commit（）
退货公司
退货公司[0]
@类方法
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

# model base class
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

from models import CompanyModel, RequestModel


Base = declarative_base()
engine = create_engine('sqlite:///sqlalchemy_test.db')
# Bind the engine to the metadata of the Base class so that the
# declaratives can be accessed through a DBSession instance
Base.metadata.bind = engine

DBSession = sessionmaker(bind=engine)
session = DBSession()

class Side:
    """
    ENUM class forstoring the request type
    """

    BUY = 1
    SELL = 2

    @classmethod
    def get_type_by_value(cls, value):
        return  next(k for k, v in cls.__dict__.items() if v == value)


class StatusEnum:
    opened = 1
    closed = 0

    @classmethod
    def get_type_by_value(cls, value):
        return  next(k for k, v in cls.__dict__.items() if v == value)


class RequestHelper:
    @classmethod
    def get_previous_buy_requests(cls, company):
        return session.query(RequestModel).filter(RequestModel.company == company.id, RequestModel.type == Side.BUY).all()

    @classmethod
    def get_previous_sell_requests(cls, company):
        return session.query(RequestModel).filter(RequestModel.company == company.id, RequestModel.type == Side.SELL).all()

    @classmethod
    def calc_r_quantity_and_status(cls, request):
        company = Company.get_by_id(request.company)

        if request.type == Side.BUY:

            # add buy quantity to the company's buy quantity
            company.buy_quantity += request.quantity

            sell_requests = cls.get_previous_sell_requests(company)

            # if not previous sell requests then r_quantity is same as quantity
            if not sell_requests:
                request.r_quantity = request.quantity
                request.status = StatusEnum.opened

                # print request
                # print request.quantity
                # print request.r_quantity
                session.commit()


                # close the previous buy request if opened
                prev_buy_requests = cls.get_previous_buy_requests(company)
                for req in prev_buy_requests:
                    if req.status == StatusEnum.opened:
                        req.r_quantity = 0
                        req.status = StatusEnum.closed
                        # session.add(req)

                session.commit()

            # any sell requests
            else:
                for sell in sell_requests:
                    if sell.status == StatusEnum.opened:

                        # check whether the sell quan is greater than current buy request quantity
                        # if greater then add the current buy req quantity with the existsing buy quantity else 
                        if sell.r_quantity < request.quantity:
                            company.buy_quantity += request.quantity
                            request.r_quantity = request.quantity - sell.r_quantity
                            request.status = StatusEnum.opened
                            sell.r_quantity = 0
                            sell.status = StatusEnum.closed
                        else:
                            sell.r_quantity -= request.quantity
                            company.sell_quantity = sell.r_quantity
                            request.r_quantity = 0
                            request.status = StatusEnum.closed
                        # session.add(request)
                        # session.add(sell)

                session.commit()

        elif request.type == Side.SELL:
            # add sell quantity to the company's sell quantity
            company.sell_quantity += request.quantity

            buy_requests = cls.get_previous_buy_requests(company)

            if not buy_requests:
                request.r_quantity = request.quantity
                request.status = StatusEnum.opened
                # session.add(request)

                prev_sell_requests = cls.get_previous_sell_requests(company)
                for req in prev_sell_requests:
                    if req.status == StatusEnum.opened:
                        req.r_quantity = 0
                        req.status = StatusEnum.closed
                        # session.add(req)

                session.commit()

            else:
                for buy in buy_requests:
                    if buy.status == StatusEnum.opened:
                        if buy.r_quantity > request.quantity:
                            company.buy_quantity = buy.r_quantity - request.quantity
                            request.r_quantity = 0
                            buy.r_quantity = company.buy_quantity

                            request.status = StatusEnum.closed

                        else:
                            request.r_quantity = request.quantity - buy.r_quantity
                            buy.r_quantity = 0
                            buy.status = StatusEnum.closed
                            request.status = StatusEnum.opened
                        # session.add(request)
                        # session.add(buy)
                session.commit()



class Company(object):
    @classmethod
    def get_or_create_company(cls, name):

        company = session.query(CompanyModel).filter(CompanyModel.name == name).all()
        if not company:
            company = CompanyModel(name=name, buy_quantity=0, sell_quantity=0)
            session.add(company)
            session.commit()
            return company

        return company[0]

    @classmethod
    def get_by_id(cls, id):
        com = session.query(CompanyModel).filter(CompanyModel.id == id)
        if com:
            return com.one()
        return None





class Requests(object):
    template_lines = []
    template_header =  'Side    |     Company   |  Quantity   |  RemaingQty |  Status'
    template_line_format = '{}    |    {}    |    {}     |    {}    |    {}'



    @classmethod
    def do_validation(cls, request_type, company, quantity):
        if request_type.upper() not in dir(Side):
            raise ValueError('Request type must be either buy or sell')

        if not company:
            raise ValueError('You must enter the company name')

        if not quantity or not quantity.isdigit():
            raise ValueError('You should enter integer value for quantity field')

    @classmethod
    def create_request(cls, request_type, company, quantity):
        new_request = RequestModel(type=request_type, company=company.id, quantity=quantity, r_quantity=0, status=0)
        session.add(new_request)
        session.commit()
        new_request.r_quantity = 2
        session.commit()

        print new_request.r_quantity

        return new_request



    @classmethod
    def generate_output(cls):
        requests = session.query(RequestModel).all()
        for ins in requests:
            print ins.r_quantity
            Requests.template_lines.append(Requests.template_line_format.format(Side.get_type_by_value(ins.type), Company.get_by_id(ins.company).name, ins.quantity, ins.r_quantity, StatusEnum.get_type_by_value(ins.status)))

        print Requests.template_header
        print '\r\n'.join(Requests.template_lines)


def main():
    # truncating models
    session.query(CompanyModel).delete()
    session.query(RequestModel).delete()


    while True:
        side = raw_input('Enter the side (buy/sell):\n')
        company = raw_input('Enter the company:\n')
        quantity = raw_input('Enter the quantity:\n')

        com = Company.get_or_create_company(company)

        # store the order request in db
        try:
            Requests.do_validation(side, com, quantity)
        except ValueError:
            continue

        new_request = Requests.create_request(getattr(Side, side.upper()), com, quantity)
        RequestHelper.calc_r_quantity_and_status(new_request)


        out = raw_input('Do you want to continue (Y/n)?\n')
        if out.lower() == 'n':
            Requests.generate_output()

            # truncating models
            session.query(CompanyModel).delete()
            session.query(RequestModel).delete()

            break

        continue



if __name__ == '__main__':
    main()

@classmethod
def calc_r_quantity_and_status(cls, request):
    company = Company.get_by_id(request.company)

    if request.type == Side.BUY:

        # add buy quantity to the company's buy quantity
        company.buy_quantity += request.quantity

        sell_requests = cls.get_previous_sell_requests(company)

        # if not previous sell requests then r_quantity is same as quantity
        if not sell_requests:
            request.r_quantity = request.quantity
            request.status = StatusEnum.opened

            # print request
            # print request.quantity
            # print request.r_quantity
            session.commit()


            # close the previous buy request if opened
            prev_buy_requests = cls.get_previous_buy_requests(company)
            for req in prev_buy_requests:
                if req.status == StatusEnum.opened:
                    req.r_quantity = 0
                    req.status = StatusEnum.closed
                    # session.add(req)

            session.commit()

        if not sell_requests:
            request.r_quantity = request.quantity

            # close the previous buy request if opened
            prev_buy_requests = cls.get_previous_buy_requests(company)
            for req in prev_buy_requests:
                if req.status == StatusEnum.opened:
                    req.r_quantity = 0
                    req.status = StatusEnum.closed
                    # session.add(req)