def delete_account(user_data):
"""Delete user transaction"""
session = Session()
response = None
try:
user = session.query(User).filter(User.email == user_data['email'] ).first()
if user is not None:
if __hash_pass(user_data['password']) == user.password:
session.delete(user)
session.commit()
# TRANSACTION SUCCESSFUL
response = success_response(user, 'delete')
else:
response = error_response(err_concept='bad_credentials')
else:
response = error_response(err_concept='non_user')
except exc.DBAPIError as e:
session.rollback()
response = error_response(e.code, e.orig, 'transaction')
finally:
if response is not None:
return response
def _prune_dir(path, prune_modified=False):
"""Prunes songs in directory and returns set of remaining songs."""
session = Session()
songs = session.query(Song).filter(Song.path.like(path + '%')).all()
remaining_paths = set()
for song in songs:
if not isfile(song.path):
session.delete(song)
print 'Pruned (deleted): ' + song.path
continue
if prune_modified:
with open(song.path, 'rb') as f:
if song.checksum != md5_for_file(f):
session.delete(song)
print 'Pruned (modified or no checksum): ' + song.path
continue
else:
remaining_paths.add(song.path)
else:
remaining_paths.add(song.path)
session.commit()
return remaining_paths
def _prune_dir(path, prune_modified=False):
"""Prunes songs in directory and returns set of remaining songs."""
session = Session()
songs = session.query(Song).filter(Song.path.like(path + '%')).all()
remaining_paths = set()
for song in songs:
if not isfile(song.path):
session.delete(song)
print 'Pruned (deleted): ' + song.path
continue
if prune_modified:
with open(song.path, 'rb') as f:
if song.checksum != md5_for_file(f):
session.delete(song)
print 'Pruned (modified or no checksum): ' + song.path
continue
else:
remaining_paths.add(song.path)
else:
remaining_paths.add(song.path)
session.commit()
return remaining_paths
def deleteShiftDutyRecord(shift_duty_date,
shift_duty_period=DutyPeriod.NightDuty):
session = Session()
duty_shift_chain = DBOperation.getDutyShiftChain(
shift_duty_date, shift_duty_period)
if duty_shift_chain is None:
print("无日期为{}的值班记录".format(shift_duty_date))
return
shift_chain_list = duty_shift_chain.shift_chain
shift_count = len(shift_chain_list) - 1
try:
if shift_count == 0:
print("can not delete origin duty.")
return
elif shift_count == 1:
session.query(OriginDuty).filter(
OriginDuty == shift_chain_list[-2]).update(
{OriginDuty.shift_duty_id: None})
else:
session.query(ShiftDuty).filter(
ShiftDuty == shift_chain_list[-2]).update(
{ShiftDuty.next_shift_duty_id: None})
session.delete(shift_chain_list[-1])
session.commit()
except Exception as e:
print(e)
session.rollback()
finally:
session.close()
def delete_report_card():
#call this so the records are fetched to show to the user
result = view_report_card(mode='delete')
no_of_records = len(result)
if no_of_records == 0:
print("No Records Found To Delete")
return
choice = pyip.inputYesNo(
prompt=
f"Found { no_of_records }. Are you sure you want to delete all of the above? (yes/no)"
)
if choice == 'no':
print("Skipping Delete...")
return
session = Session()
for card in result:
session.delete(card)
session.commit()
print(f"Deleted { no_of_records } records")
return
def remove(file_id):
try:
session_obj = Session()
ret = session_obj.query(file_list).filter_by(id=file_id).first()
if not ret:
Session.remove()
return -1
tmp = session_obj.query(file_list).get(ret.id)
folder_path = config.ROOTDIR + tmp.user.username + config.BLACKBOXFOLDER
file_path = os.path.join(folder_path, tmp.file_name)
if os.path.exists(file_path):
try:
os.remove(file_path)
except Exception as e:
Session.remove()
Logger().get_logger().error(str(e))
session_obj.rollback()
return -2
session_obj.delete(tmp)
session_obj.commit()
Session.remove()
return 0
except Exception as e:
Logger().get_logger().error(str(e))
session_obj.rollback()
return -2
def cleaning_del(message, user_name, day_of_week):
"""指定した曜日の掃除当番からユーザーを削除する
:param message: slackbot.dispatcher.Message
:param str user_name: 掃除当番から削除するユーザー名
:param str day_of_week: 削除する掃除当番が登録されている曜日
"""
if day_of_week not in DAY_OF_WEEK:
botsend(message, '曜日には `月` 、 `火` 、 `水` 、 `木` 、 `金` のいずれかを指定してください')
return
s = Session()
slack_id = get_slack_id(s, user_name)
if not slack_id:
botsend(message, '{}はSlackのユーザーとして存在しません'.format(user_name))
return
cleaning_user = (s.query(Cleaning).filter(
Cleaning.slack_id == slack_id).filter(
Cleaning.day_of_week == DAY_OF_WEEK.index(
day_of_week)).one_or_none())
if cleaning_user:
s.delete(cleaning_user)
s.commit()
botsend(message, '{}を{}曜日の掃除当番から削除しました'.format(user_name, day_of_week))
else:
botsend(message,
'{}は{}曜日の掃除当番に登録されていません'.format(user_name, day_of_week))
def unalias_name(message, user_name, alias_name=None):
"""ユーザーに紐づくエイリアス名を削除する
:param message: slackbotの各種パラメータを保持したclass
:param str user_name: 削除するエイリアス名を持つSlackユーザー
:param str alias_name: 削除するエイリアス名
alias_nameがNoneの場合、user_nameをalias_nameとして扱う
上記の場合user_nameは投稿者となる
"""
if alias_name:
# ユーザー名とエイリアス名が指定されているパターン
slack_id = get_slack_id_by_name(user_name)
else:
# 投稿者のエイリアス名を更新するパターン
alias_name = user_name
slack_id = message.body['user']
user_name = get_user_name(slack_id)
if not slack_id:
botsend(message, '{}に紐づくSlackのuser_idは存在しません'.format(user_name))
return
s = Session()
alias_user_name = (s.query(UserAliasName).filter(
UserAliasName.slack_id == slack_id).filter(
UserAliasName.alias_name == alias_name).one_or_none())
if alias_user_name:
s.delete(alias_user_name)
s.commit()
botsend(message,
'{}のエイリアス名から `{}` を削除しました'.format(user_name, alias_name))
else:
botsend(message,
'{}のエイリアス名 `{}` は登録されていません'.format(user_name, alias_name))
def upload(user_id, package_name, version, time, remark):
try:
session_obj = Session()
tmp = session_obj.query(user_info).filter_by(id=user_id).first()
if (tmp == None):
Session.remove()
return -1
tmp = session_obj.query(package_info).options(
subqueryload(package_info.user)).filter_by(
package_name=package_name).filter_by(
user_id=user_id).first()
if tmp is not None:
tmp = session_obj.query(package_info).get(tmp.id)
session_obj.delete(tmp)
session_obj.commit()
package_obj = package_info(user_id=user_id,
package_name=package_name,
version=version,
time=time,
remarks=remark)
session_obj.add(package_obj)
session_obj.commit()
Session.remove()
return 0
except Exception as e:
Logger().get_logger().error(str(e))
session_obj.rollback()
return -2
class TestItem(TestCase):
def setUp(self):
reset_db()
self.sess = Session()
def tearDown(self):
self.sess.close()
def test_crud(self):
store = StoreModel('testStore')
item = ItemModel(name='test', price=12.99, store_id=1)
self.assertEqual(
self.sess.query(ItemModel).filter(
ItemModel.name == 'test').count(), 0)
self.sess.add(store)
self.sess.add(item)
self.sess.commit()
self.assertEqual(
self.sess.query(ItemModel).filter(
ItemModel.name == 'test').count(), 1)
self.sess.delete(item)
self.sess.commit()
self.assertEqual(
self.sess.query(ItemModel).filter(
ItemModel.name == 'test').count(), 0)
self.sess.delete(store)
self.sess.commit()
def remove(package_id):
try:
session_obj = Session()
ret = session_obj.query(package_info).filter_by(
id=package_id).first()
if not ret:
Session.remove()
return -1
tmp = session_obj.query(package_info).get(ret.id)
folder_path = config.ROOTDIR + tmp.user.username + config.PATCHFOLDER
file_path = os.path.join(folder_path, tmp.package_name)
if is_file_open(file_path) or is_package_in_task(package_id):
Session.remove()
return -4
if os.path.exists(file_path):
try:
os.remove(file_path)
except Exception as e:
Logger().get_logger().error(str(e))
session_obj.rollback()
Session.remove()
return -2
session_obj.delete(tmp)
session_obj.commit()
Session.remove()
return 0
except Exception as e:
Logger().get_logger().error(str(e))
session_obj.rollback()
return -3
def delete(self, id):
rack = Session.query(Rack).filter(Rack.id == id).first()
if not rack:
abort(404, message="Rack id={} doesn't exist".format(id))
Session.delete(rack)
Session.commit()
log.info("Rack id={} deleted".format(id))
return {}, 204
def delete(self, id):
server = Session.query(Server).filter(Server.id == id).first()
if not server:
abort(404, message="Server {} doesn't exist".format(id))
Session.delete(server)
Session.commit()
log.info("Server id={} deleted".format(id))
return {}, 204
def remove_beer(beer_name):
session = Session()
beer = session.query(Beer).filter_by(name=beer_name.lower()).one()
session.delete(beer)
session.commit()
response = jsonify()
response.status_code = 201
return response
def delete(self, model, id):
s = Session()
m = s.query(model).filter(model.id == id).one()
s.delete(m)
s.commit()
s.close()
def on_post(self, req, resp):
doc = req.context['doc']
users=Session.query(User).all()
unique=True
for user in users:
if doc['email'] == user.email:
unique=False
if unique:
user = User(name=doc['name'], email=doc['email'].lower(), signedin=False,registerTime=datetime.datetime.today())
print(datetime.datetime.today())
user.salt = bcrypt.gensalt()
user.pw_hash = bcrypt.hashpw(doc['password'].encode('utf-8'), user.salt)
s=smtplib.SMTP_SSL('smtp.gmail.com',465)
s.ehlo()
s.login('*****@*****.**','helloworld@ppclub')
code=randint(1000000,10000000)
user.code=code
msg=MIMEText('Hi '+user.name+', your verification URL is: '+'http://192.168.1.127:8000/confirmation/'+str(code))
msg['From']='*****@*****.**'
msg['To']=user.email
msg['Subject']='PhoenixNow Account Confirmation'
s.send_message(msg)
s.close()
Session.add(user)
Session.flush()
Session.commit()
req.context['user'] = user.id
req.context['result'] = {"result": "success", "action": "register"}
else:
user=get_user(req,resp)
td=datetime.timedelta(minutes=30)
if datetime.datetime.today()-td<user.registerTime or user.emailVerified==True:
description = "User was already made"
title = "User creation conflict"
raise falcon.HTTPConflict(title=title, description=description)
else:
Session.delete(user)
Session.flush()
user = User(name=doc['name'], email=doc['email'], signedin=False,registerTime=datetime.datetime.today())
print(datetime.datetime.today())
user.salt = bcrypt.gensalt()
user.pw_hash = bcrypt.hashpw(doc['password'].encode('utf-8'), user.salt)
s=smtplib.SMTP_SSL('smtp.gmail.com',465)
s.ehlo()
s.login('*****@*****.**','helloworld@ppclub')
code=randint(1000000,10000000)
user.code=code
msg=MIMEText('Hi '+user.name+', your verification URL is: '+'http://192.168.1.127:8000/confirmation/'+str(code))
msg['From']='*****@*****.**'
msg['To']=user.email
msg['Subject']='PhoenixNow Account Confirmation'
s.send_message(msg)
s.close()
Session.add(user)
Session.flush()
Session.commit()
req.context['user'] = user.id
req.context['result'] = {"result": "success", "action": "register"}
def note_remove(note_id=None):
s = get_session()
if not s.get('authenticated') or not note_id:
return bottle.redirect('/login')
db_session = Session()
note = db_session.query(Note).get(note_id)
db_session.delete(note)
db_session.commit()
bottle.redirect(bottle.url('note-list'))
def note_remove(note_id=None):
s = get_session()
if not s.get('authenticated') or not note_id:
return bottle.redirect('/login')
db_session = Session()
note = db_session.query(Note).get(note_id)
db_session.delete(note)
db_session.commit()
bottle.redirect(bottle.url('note-list'))
def deletePost():
print 'Method=' + request.method
id = request.form.get('id')
session = Session()
movies = session.query(Movie).filter(Movie.id == id).first()
print movies.id
session.delete(movies)
session.commit()
return redirect('/')
def remove(self, alias):
try:
suite = Session.query(TestSuite).get(alias)
if suite:
Session.delete(suite)
Session.commit()
except:
Session.rollback()
Session.commit()
def remove(self, hostname):
try:
agent = Session.query(Agent).get(hostname)
if not agent:
raise KeyError("%s not found" % hostname)
Session.delete(agent)
Session.commit()
except:
Session.rollback()
raise
def remove_song(self, song_id, skip=False):
"""Removes the packet with the given id"""
session = Session()
packet = session.query(Packet).filter_by(song_id=song_id).first()
if isinstance(player.now_playing, Song) and player.now_playing.id == song_id:
player.stop()
if skip:
self.virtual_time = packet.finish_time
session.delete(packet)
session.commit()
self._update_active_sessions()
return self.get_queue()
def remove_video(self, url, skip=False):
"""Removes the packet with the given video_url"""
session = Session()
packet = session.query(Packet).filter_by(video_url=url).first()
if isinstance(player.now_playing, YouTubeVideo) and player.now_playing.url == url:
player.stop()
if skip:
self.virtual_time = packet.finish_time
session.delete(packet)
session.commit()
self._update_active_sessions()
return self.get_queue()
def deleteUser(cookie, uid):
session = Session()
u = usermanagment.getUser(cookie)
if not u.admin:
raise Exception("Invalid access %s %s" % (uid, u.id))
q = session.query(User).filter_by(id=uid)
if q.count() == 0:
raise Exception("User not found")
cu = q.one()
session.delete(cu)
session.commit()
def rmpost(pid):
try:
if escape(session["username"]) != config.username or escape(session["password"]) != config.password:
raise
except:
abort(404)
s = Session()
try:
s.delete(s.query(Blog).filter_by(pid = pid).first())
s.commit()
except:
abort(404)
return redirect(url_for("blog.blogindex"))
def remove_song(self, song_id, skip=False):
"""Removes the packet with the given id"""
session = Session()
packet = session.query(Packet).filter_by(
song_id=song_id, player_name=PLAYER_NAME).first()
if (isinstance(player.now_playing, Song)
and player.now_playing.id == song_id):
player.stop()
if skip:
self.virtual_time = packet.finish_time
session.delete(packet)
session.commit()
self._update_active_sessions()
return self.get_queue()
class TestStore(TestCase):
def setUp(self):
reset_db()
self.sess = Session()
def tearDown(self):
self.sess.close()
def test_create_store(self):
store = StoreModel('testStore')
self.assertEqual(store.items.count(), 0)
def test_crud(self):
store = StoreModel('testStore')
self.assertEqual(
self.sess.query(StoreModel).filter(
StoreModel.name == 'testStore').count(), 0)
self.sess.add(store)
self.sess.commit()
self.assertEqual(
self.sess.query(StoreModel).filter(
StoreModel.name == 'testStore').count(), 1)
self.sess.delete(store)
self.sess.commit()
self.assertEqual(
self.sess.query(StoreModel).filter(
StoreModel.name == 'testStore').count(), 0)
def test_store_relationship(self):
store = StoreModel('testStore')
item = ItemModel('testItem', 12.99, 1)
self.sess.add(store)
self.sess.add(item)
self.sess.commit()
items = self.sess.query(ItemModel).filter(
ItemModel.store_id == 1).all()
self.assertEqual(len(items), 1)
self.assertEqual(items[0].name, 'testItem')
def test_store_json(self):
store = StoreModel('testStore')
expected = {
'name': 'testStore',
'items': [],
}
self.assertEqual(store.json(), expected)
def delete_item(item_id, redirect_url):
"""Delete an item from database"""
# Create DB session
db_session = Session()
# Delete corresponding item
try:
item = db_session.query(Item).filter_by(id=item_id).one()
db_session.delete(item)
db_session.commit()
except exc.SQLAlchemyError:
flash("There was an error. Please try again.", "danger")
return redirect(redirect_url)
# Close DB session
db_session.close()
def del_term(message, command, word):
"""コマンドから語録を削除する
:param message: slackbot.dispatcher.Message
:param str command: 登録済のコマンド名
:param str word: 削除する語録
"""
s = Session()
term = (s.query(Term).filter(Term.create_command == command.id).filter(
Term.word == word).one_or_none())
name = command.name
if term:
s.delete(term)
s.commit()
botsend(message, 'コマンド `${}` から「{}」を削除しました'.format(name, word))
else:
botsend(message, 'コマンド `${}` に「{}」は登録されていません'.format(name, word))
def on_delete(self, req, resp, item_id):
event = Session.query(Event).get(item_id)
from_date = event.from_date.strftime("%Y-%m-%d")
to_date = event.to_date.strftime("%Y-%m-%d")
req.context['result'] = {
'action': 'delete event',
'result': 'success',
'event': {
'id': event.id,
'from_date': from_date,
'to_date': to_date,
'title': event.title,
'description': event.description
}
}
resp.status = falcon.HTTP_200
Session.delete(event)
Session.commit()
def remove_resource(message, _, name):
"""リソースの削除
:param message: slackbot.dispatcher.Message
:param str name: リソース名
"""
channel_id = message.body["channel"]
s = Session()
resource = s.query(Resource).filter(
Resource.channel_id == channel_id,
Resource.name == name,
).one_or_none()
if resource:
s.delete(resource)
s.commit()
show_resources(message)
def remove(user_id) -> int:
try:
session_obj = Session()
ret = session_obj.query(user_info).filter_by(id=user_id).first()
if not ret:
Session.remove()
return -1
#删除用户
tmp = session_obj.query(user_info).get(ret.id)
session_obj.delete(tmp)
session_obj.commit()
Session.remove()
except Exception as e:
Logger().get_logger().error(str(e))
session_obj.rollback()
return -2
return 0
class TestUser(TestCase):
def setUp(self):
reset_db()
self.sess = Session()
def tearDown(self):
self.sess.close()
def test_crud(self):
user = UserModel(name='testUser', password='******')
self.assertEqual(self.sess.query(UserModel).count(), 0)
self.sess.add(user)
self.sess.commit()
self.assertEqual(self.sess.query(UserModel).count(), 1)
self.sess.delete(user)
self.sess.commit()
self.assertEqual(self.sess.query(UserModel).count(), 0)
def pop_term(message, command):
"""用語コマンドで最後に登録された応答を削除する
:param message: slackbot.dispatcher.Message
:param str command: 登録済のコマンド名
"""
s = Session()
term = (s.query(Term).filter(Term.create_command == command.id).filter(
Term.creator == message.body['user']).order_by(Term.id.desc()).first())
name = command.name
if term:
s.delete(term)
s.commit()
botsend(message, 'コマンド `${}` から「{}」を削除しました'.format(name, term.word))
else:
msg = ('コマンド `${0}` にあなたは語録を登録していません\n'
'`${0} add (語録)` で語録を登録してください'.format(name))
botsend(message, msg)
def remove_temps(temps_id):
try:
session_obj = Session()
ret = session_obj.query(blackbox_temps).filter_by(
id=temps_id).first()
if not ret:
Session.remove()
return -1
tmp = session_obj.query(blackbox_temps).get(ret.id)
session_obj.delete(tmp)
session_obj.commit()
Session.remove()
return 0
except Exception as e:
Logger().get_logger().error(str(e))
session_obj.rollback()
return -2
def remove_video(self, url, skip=False):
"""Removes the packet with the given stream_url"""
session = Session()
packet = session.query(Packet).filter_by(
stream_url=url, player_name=PLAYER_NAME).first()
if (isinstance(player.now_playing, YouTubeVideo)
and player.now_playing.url == url):
player.stop()
if skip:
self.virtual_time = packet.finish_time
elif (isinstance(player.now_playing, SoundCloudMusic)
and player.now_playing.url == url):
player.stop()
if skip:
self.virtual_time = packet.finish_time
session.delete(packet)
session.commit()
self._update_active_sessions()
return self.get_queue()
async def unsubscribe(message: types.Message):
session = Session()
if "reply_to_message" in message:
res = session.query(BD_Subs_SMS).filter_by(sms_id=message["reply_to_message"]["message_id"]).all()
if len(res) > 0:
row_1 = res[0]
print("Result subs_id:", row_1.subs_id)
row_2 = session.query(BD_Subs).filter_by(id=row_1.subs_id).all()[0]
await message.answer("Удалил подписку: "+row_2.sub_name)
session.delete(row_2)
session.delete(row_1)
else:
await message.answer("Я не нашёл подписку")
else:
txt = ""
for (sub_name,) in session.query(BD_Subs.sub_name).filter_by(user_id=message.from_user.id):
txt += "\n" + str(sub_name)
await message.answer("Вы успешно отписаны от рассылки сайта:" + txt)
q = session.query(BD_Subs).filter(BD_Subs.user_id == message.from_user.id)\
.delete()
session.commit()
await message.reply("Ну и ладно!")
def merge_organisations(this_id, that_id):
"""remove organisation with that_id"""
success = True
s = Session()
this = _get_organisation(s, this_id)
if not this:
return False
that = _get_organisation(s, that_id)
if not that:
return False
# name, org_type, core
if not is_blank(that.name) and len(that.name) < len(this.name):
this.name = that.name
# if this.org_type and that.org_type and this.org_type != that.org_type:
# print("Organisation %s with different type: old: '%s'; new: '%s'"\
# %(this.name, this.org_type, that.org_type))
# success = False
# else:
# this.org_type = this.org_type or that.org_type
if this.core and that.core and this.core != that.core:
print("Organisation %s with different core: old: '%s'; new: '%s'"\
%(this.name, this.core, that.core))
success = False
else:
this.core = this.core or that.core
# accounts, aliases
#this.aliases = this.aliases + that.aliases
this.aliases = _merge_aliases(s, this.aliases, that.aliases)
this.accounts = this.accounts + that.accounts
s.delete(that)
s.commit()
s.close()
return success
os.unlink(
os.path.join(DATA_DIR,
'additional/%s_changes.json-lines' % crawl_id))
except OSError:
pass
try:
os.unlink(os.path.join(DATA_DIR, '%s_errors.csv' % crawl_id))
except OSError:
pass
db_session = Session()
accounts = db_session.query(Account).filter(Account.enabled == False).all()
print str(len(accounts)), "disabled accounts to clean"
for a in accounts:
print "Account", a.name
spiders = db_session.query(Spider).filter(Spider.account_id == a.id).all()
for spider in spiders:
print "Spider", spider.name
last_crawl = db_session.query(Crawl).filter(
Crawl.spider_id == spider.id).order_by(desc(
Crawl.crawl_date)).first()
if last_crawl and last_crawl.crawl_date.year < 2014:
print "Removing crawls"
crawls = db_session.query(Crawl).filter(
Crawl.spider_id == spider.id).all()
for crawl in crawls:
_delete_crawl_files(crawl.id)
db_session.delete(crawl)
class ChannelManager:
def __init__(self):
self.session = Session()
def add_channel(self, id, parent=None, name=None, links=None,
description=None, links_add=None, links_remove=None,
temporary=None, position=None, description_hash=None):
c = self.session.query(Channel).get(id)
if c:
debug("Updating channel {} ({})".format(c.name, id))
self.update_channel(id, parent, name, links, description, links_add,
links_remove, temporary, position,
description_hash)
else:
c = Channel(id=id,
parent_id=parent, name=name, links="", description=description,
links_add="",links_remove="",
temporary=temporary, position=position,
description_hash=description_hash)
self.session.add(c)
if parent is not None and parent != 0:
p = self.session.query(Channel).get(parent)
if p is None:
raise KeyError("Got a child channel without a root channel (?)")
def del_channel(self, id):
try:
c = self.session.query(Channel).get(id)
self.session.delete(c)
info("Deleted channel with ID {0}", id)
except KeyError:
warning("Server removed channel with ID {}, "
"but we haven't seen it before!", id)
except:
pass
def get_by_name(self, name):
return self.session.query(Channel).filter_by(name=name).first()
def get(self, id):
if not isinstance(id, int):
if not id.isdigit():
id = self.get_by_name(id).id
else:
id = int(id)
return self.session.query(Channel).get(id)
def update_channel(self,
*args): # id, parent, name, links, description, links_add,
#links_remove, temporary, position, description_hash):
pass
def add_from_message(self, message):
args = []
for m in (
'channel_id', 'parent', 'name', 'links', 'description',
'links_add',
'links_remove', 'temporary', 'position', 'description_hash'):
args.append(getattr(message, m, None))
self.add_channel(*args)
def delete(self):
sess = Session()
sess.delete(self)
sess.commit()
sess.close()
