def test_successful_create(self):
"""
GIVEN a Flask application
WHEN the '/data' endpoint is is posted with array of data
THEN check that results are correct
"""
data_array = []
d1 = DataModel(name="nasredine", value=2.347736)
d2 = DataModel(name="nasredine", value=13.763882)
d3 = DataModel(name="sid", value=10)
data_array.append(d1)
data_array.append(d2)
data_array.append(d3)
data_dict = [{
"name": v.name,
"value": v.value,
} for v in data_array]
data_json = json.dumps({
"data": data_dict,
})
response = self.execute_post(data_json)
self.assertAlmostEqual(8.05, response.json['nasredine'], 1)
self.assertAlmostEqual(10.0, response.json['sid'], 1)
def post(self):
try:
todo = parser2.parse_args()["new_todo"]
user = get_raw_jwt()['identity']
DataModel.update_todo(user, todo)
return {"message": "Success"}, 200
except:
return {"Error": "Something went wrong"}, 500
class GetMethod(Mapping):
def __init__(self, *args, **kwargs):
self.data_model = DataModel(db_name=kwargs['db_name'])
self.parent_id = kwargs['parent_id']
self.method_id = kwargs['method_id']
self.methods_meta_info = self.data_model.get_method_meta()
def __getitem__(self, names):
try:
base_name = names.pop(0)
base_method_info = self.methods_meta_info[base_name]
parent = base_method_info['parent']
base_method = self.data_model.get_method(parent, self.parent_id,
base_name, self.method_id)
# Since we can assign multiple method object based on different
# events to each method name under a particular parent_id
# when in a rule we are using a parent_method_id which actually is
# demonstrating a method name under a parent type (for
# example user_payback) this method cannot have different ids or
# parent ids. For example if a method has been activated
# at a special time and we added this onther the user_id x and
# method name payback. THen this particular payback method
# can only has one pay_request_id.
def get_attrs(names, method):
while True:
name = names.pop(0)
if name.endswith('id'):
parent, method_name = name.split('_')[:2]
method_inf = next(mtd
for mtd in method['linked_methods']
if mtd['parent'] == parent
and mtd['method'] == method_name)
method_id, parent_id = method_inf['id'], method_inf[
'parent_id']
method = self.data_model.get_method(
parent, parent_id, method_name, method_id)
return get_attrs(names, method)
else:
return method['name']
return get_attrs(names, base_method)
except KeyError:
# should be handled properly
# print (self._all_methods)
raise
def __iter__(self):
return iter(self._all_methods)
def __len__(self):
return len(self._all_methods)
def post(self):
extra = parser3.parse_args()['extra_content']
from_ = os.environ["MY_MAIL"]
to = parser3.parse_args()['to']
if (to == "user_self"):
to = get_raw_jwt()['identity']
data = DataModel.get_todo(get_raw_jwt()['identity'])
lst = data.split(".:::.")
for i in range(len(lst)):
pri = self.__get_pri__(lst[i][10:13])
if lst[i][14:23] == "completed":
lst[i] = f"Priority {pri} (Completed): {lst[25:-4]}"
else:
lst[i] = f"Priority {pri}: {lst[15:-4]}"
data = "\n ".join(lst)
data = "ToDo List:\n" + data + "\n\n"
h = f"Mail (SMTP)\nFROM: {from_}\nTO: {to}\nSubject: Your ToDo List\n\n\n"
data = h + data + extra
message = Mail(from_email=from_,
to_emails=to,
subject='Your ToDo list',
html_content=data)
try:
sg = SendGridAPIClient(os.environ.get('SENDGRID_API_KEY'))
response = sg.send(message)
return response.status_code
except:
return {"Error": "Somthing went wrong."}, 500
def add_data():
name = request.form['name']
content = request.form['content']
new_data = DataModel(name, content)
db.session.add(new_data)
db.session.commit()
return redirect('/')
def get(self):
try:
user = get_raw_jwt()['identity']
todo_list = DataModel.get_todo(user)
resp = {"todo_list": todo_list, "message": "Success"}
return resp, 200
except:
return {"Error": "Something went wrong"}, 500
def add(list1): #向数据库中增添数据
DataModel.objects.all().delete()
for person in list1:
student = DataModel(student_ID=person.student_ID,
name=person.name,
department=person.department,
major=person.major,
grade=person.grade,
graduate_time=person.graduate_time,
student_status=person.student_status,
failed_number=person.failed_number,
center_credits=person.center_credits,
courses_must_to_take=person.courses_must_to_take,
general_courses=person.general_courses,
others=person.others)
student.save()
return
def post(self):
data = parser5.parse_args()
if UserModel.find_by_username(data['username']):
return {
'message': 'User {} already exists'.format(data['username'])
}, 400
q = data['security-question']
ques = [
"What is your hometown's name?",
"What is/was your first pet's name?",
"Who is your favorite author?",
"Who is your favorite character in your favorite show?"
]
sec_q = -1
for i, el in enumerate(ques):
if el == q:
sec_q = i
break
new_user = UserModel(username=data['username'],
password=UserModel.generate_hash(
data['password']),
question=sec_q,
answer=data['security-answer'])
try:
new_user.save_to_db()
___id__ = new_user.find_by_username(data['username']).id
new_user_data = DataModel(user_id=___id__,
username=data['username'],
todo="")
new_user_data.save_to_db()
access_token = create_access_token(identity=data['username'])
#refresh_token = create_refresh_token(identity = data['username'])
resp = jsonify({'user': data['username']})
set_access_cookies(resp, access_token)
#set_refresh_cookies(resp, refresh_token)
resp.status_code = 200
return resp
except:
res = {'message': "Something went wrong"}
return res, 500
def create(data) -> dict:
""" Create Data """
try:
avg_values = DataModel.compute_average_values(data)
# save each entry separately
for d in avg_values:
d = DataModel(d, avg_values[d])
d.save()
except IntegrityError:
DataModel.rollback()
raise ResourceExists('hat already exists')
return avg_values
def __init__(self, parent=None):
super(MainWidget, self).__init__(parent)
# set app name before mediaObject was created to avoid phonon problem
QCoreApplication.setApplicationName("NetEaseMusic-ThirdParty")
self.ui = UiMainWidget()
self.ui.setup_ui(self)
self.signal_mapper = QSignalMapper(self)
self.player = Phonon.createPlayer(Phonon.MusicCategory)
self.net_manager = QNetworkAccessManager()
self.searchShortcut = QShortcut(QKeySequence("Ctrl+F"), self)
self.sources = []
self.net_ease = NetEase()
self.model = DataModel()
self.set_self_prop()
self.set_signal_binding()
self.init_table_widget()
def __init__(self, *args, **kwargs):
self.data_model = DataModel(db_name=kwargs['db_name'])
self.parent_id = kwargs['parent_id']
self.method_id = kwargs['method_id']
self.methods_meta_info = self.data_model.get_method_meta()
import time
from models import CharacterLSTM, DataModel
parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('--save_dir', type=str, default='./save', help='Directory to save model checkpoints')
parser.add_argument('--rnn_layers', type=int, default=2, help='No:of layers in the RNN')
parser.add_argument('--rnn_size', type=int, default=128, help='Size of RNN hidden states')
parser.add_argument('--lr', type=float, default=0.002, help='Learning Rate')
parser.add_argument('--decay', type=float, default=0.97, help='Decay Rate')
parser.add_argument('--batch_size', type=int, default=100, help='Mini-batch size')
parser.add_argument('--seq_length', type=int, default=50, help='Sequence Length')
parser.add_argument('--epochs', type=int, default=30, help='No:of Epochs')
parser.add_argument('--save_every', type=int, default=1000, help='save frequency')
args = parser.parse_args()
with open('character_set.pkl', 'rb') as f:
character_set = pickle.load(f)
data_model = DataModel(args.batch_size, args.seq_length, character_set, args.save_dir)
args.vocab_size = data_model.get_total_characters()
with open(args.save_dir + '/args.pkl', 'wb') as f:
pickle.dump(args, f, pickle.HIGHEST_PROTOCOL)
model = CharacterLSTM(args)
start_time = time.time()
model.train(data_model)
end_time = time.time()
print('Finished in %d minutes %d seconds' % ((end_time - start_time) / 60, (end_time - start_time) % 60))
help='No:of layers in the RNN')
parser.add_argument('--rnn_size',
type=int,
default=128,
help='Size of RNN hidden states')
parser.add_argument('--lr', type=float, default=0.002, help='Learning Rate')
parser.add_argument('--decay', type=float, default=0.97, help='Decay Rate')
parser.add_argument('--batch_size',
type=int,
default=30,
help='Mini-batch size')
parser.add_argument('--seq_length',
type=int,
default=30,
help='Sequence Length')
parser.add_argument('--epochs', type=int, default=50, help='No:of Epochs')
parser.add_argument('--save_every',
type=int,
default=1000,
help='save frequency')
args = parser.parse_args()
data_model = DataModel(args.batch_size, args.seq_length, args.save_dir)
args.vocab_size = data_model.get_vocab_size()
with open(args.save_dir + '/args.pkl', 'wb') as f:
pickle.dump(args, f, pickle.HIGHEST_PROTOCOL)
model = TokenLSTM(args)
model.train(data_model)
# initialize array to store battery cell data
data = np.zeros(len(mags), dtype=object)
# load battery cell data for each temperature as objects then store in data array
# note that data files are in the dyn_data folder
print('Load files')
for idx, temp in enumerate(temps):
mag = mags[idx]
if temp < 0:
tempfmt = f'{abs(temp):02}'
files = [
Path(f'./dyn_data/{cellID}_DYN_{mag}_N{tempfmt}_s1.csv'),
Path(f'./dyn_data/{cellID}_DYN_{mag}_N{tempfmt}_s2.csv'),
Path(f'./dyn_data/{cellID}_DYN_{mag}_N{tempfmt}_s3.csv')
]
data[idx] = DataModel(temp, files)
print(*files, sep='\n')
else:
tempfmt = f'{abs(temp):02}'
files = [
Path(f'./dyn_data/{cellID}_DYN_{mag}_P{tempfmt}_s1.csv'),
Path(f'./dyn_data/{cellID}_DYN_{mag}_P{tempfmt}_s2.csv'),
Path(f'./dyn_data/{cellID}_DYN_{mag}_P{tempfmt}_s3.csv')
]
data[idx] = DataModel(temp, files)
print(*files, sep='\n')
modeldyn = processDynamic(data, modelocv, numpoles, doHyst)
# convert ocv and dyn results model object to dict, then save in JSON to disk
modeldyn = {
class MainWidget(QWidget):
def __init__(self, parent=None):
super(MainWidget, self).__init__(parent)
# set app name before mediaObject was created to avoid phonon problem
QCoreApplication.setApplicationName("NetEaseMusic-ThirdParty")
self.ui = UiMainWidget()
self.ui.setup_ui(self)
self.signal_mapper = QSignalMapper(self)
self.player = Phonon.createPlayer(Phonon.MusicCategory)
self.net_manager = QNetworkAccessManager()
self.searchShortcut = QShortcut(QKeySequence("Ctrl+F"), self)
self.sources = []
self.net_ease = NetEase()
self.model = DataModel()
self.set_self_prop()
self.set_signal_binding()
self.init_table_widget()
def init_table_widget(self):
self.ui.info_widget.music_table_widget.close()
self.ui.info_widget.music_search_widget.close()
self.ui.info_widget.current_playing_widget.close()
def set_self_prop(self):
self.setWindowTitle('NetEaseMusic For Linux')
self.setObjectName('main_widget')
self.resize(960, 580)
self.setWindowIcon(QIcon('icons/format.ico'))
def paintEvent(self, QPaintEvent):
"""
self is derived from QWidget, Stylesheets don't work unless \
paintEvent is reimplemented.
at the same time, if self is derived from QFrame, this isn't needed.
"""
option = QStyleOption()
option.init(self)
painter = QPainter(self)
style = self.style()
style.drawPrimitive(QStyle.PE_Widget, option, painter, self)
def set_signal_binding(self):
self.searchShortcut.activated.connect(self.set_search_focus)
self.ui.info_widget.music_table_widget.itemDoubleClicked.connect(
self.play_userplaylist_music)
self.ui.info_widget.music_search_widget.itemDoubleClicked.connect(
self.play_search_music)
self.ui.info_widget.current_playing_widget.itemDoubleClicked.connect(
self.play_currentplayinglist_music)
self.ui.user_widget.list_widget.itemDoubleClicked.connect(
self.play_userlist)
self.ui.user_widget.list_widget.itemClicked.connect(
self.set_tablewidget_userplaylist)
self.player.setTickInterval(1000)
self.player.tick.connect(self.tick)
self.player.stateChanged.connect(self.state_changed)
self.player.currentSourceChanged.connect(self.source_changed)
self.player.aboutToFinish.connect(self.about_to_finish)
self.ui.play_widget.play_pause_btn.clicked.connect(self.play_pause)
self.ui.play_widget.last_music_btn.clicked.connect(
self.last_music)
self.ui.play_widget.next_music_btn.clicked.connect(
self.next_music)
self.ui.play_widget.seek_slider.setMediaObject(self.player)
self.ui.play_widget.login_btn.clicked.connect(self.show_login_widget)
self.ui.play_widget.search_btn.clicked.connect(self.search)
self.ui.play_widget.search_edit.returnPressed.connect(self.search)
self.ui.play_widget.show_current_list.clicked.connect(self.set_tablewidget_currentplayinglist)
self.ui.play_widget.help_btn.clicked.connect(self.show_help_info)
self.net_manager.finished.connect(self.albumimg_load_finish)
def show_help_info(self):
print 'show help info'
with open('data/help.html') as f:
text = f.read()
text = text.decode('utf8')
message = QMessageBox(self)
message.setText(text)
message.setTextFormat(Qt.RichText)
message.show()
pass
def play_userlist(self, item):
userplaylist_widget = self.ui.user_widget.list_widget
data = item.data(Qt.UserRole)
playlist = data.toPyObject()[0]
pid = playlist['id']
res = self.net_ease.playlist_detail(pid)
# table_widget.clear()
if res is not []:
current_playing = self.ui.info_widget.current_playing_widget
# 清空当前播放列表
self.sources = []
current_playing.setRowCount(0)
# 把歌曲全部加入列表
for music in res:
datamodel = self.model.music()
music_model = self.model.set_datamodel_from_data(music, datamodel)
source = Phonon.MediaSource(music_model['mp3Url'])
self.add_music_to_sources(source)
self.add_music_to_currentplayinglist(music_model)
# 播放列表第一首歌
item = current_playing.item(0, 0)
self.play_currentplayinglist_music(item)
# 显示当前播放列表
self.init_table_widget()
current_playing.show()
else:
# 具体详细提示信息需要根据后台返回进行判断
# 以后可以进行优化
self.ui.status.showMessage(u'当前列表为空', 3000)
def play_currentplayinglist_music(self, item):
current_playing = self.ui.info_widget.current_playing_widget
current_row = current_playing.row(item)
self.player.stop()
self.player.setCurrentSource(self.sources[current_row])
self.player.play()
def set_search_focus(self):
self.ui.play_widget.search_edit.setFocus(True)
def play_pause(self):
if self.player.state() == Phonon.PlayingState:
self.player.pause()
elif self.player.state() == Phonon.PausedState:
self.player.play()
def show_login_widget(self):
d = LoginDialog(self)
self.connect(d, SIGNAL('loginsuccess'), self.login)
d.show()
def login(self, data):
if data is False:
uid = '18731323'
else:
uid = data['account']['id']
try:
self.ui.status.showMessage(u'准备加载头像')
avatarUrl = data['profile']['avatarUrl']
self.net_manager.finished.connect(self.avatar_load_finish)
self.net_manager.finished.disconnect(self.albumimg_load_finish)
self.load_user_playlist(uid)
self.net_manager.get(QNetworkRequest(QUrl(avatarUrl)))
return
except:
self.ui.status.showMessage(u'加载头像失败', 2000)
self.load_user_playlist(uid)
def load_user_playlist(self, uid):
playlists = self.net_ease.user_playlist(uid)
list_widget = self.ui.user_widget.list_widget
list_widget.clear()
if playlists is not []:
for playlist in playlists:
datamodel = self.model.playlist()
datamodel = self.model.set_datamodel_from_data(playlist, datamodel)
item = QListWidgetItem(QIcon('icons/playlist_1.png'), datamodel['name'])
list_widget.addItem(item)
data = QVariant((datamodel, ))
item.setData(Qt.UserRole, data)
else:
print 'network error'
def search(self):
search_edit = self.ui.play_widget.search_edit
text= search_edit.text()
self.ui.status.showMessage(u'正在搜索: ' + text)
if text != '':
s = unicode(text.toUtf8(), 'utf8', 'ignore')
data = self.net_ease.search(s.encode('utf8'))
songs = list()
if data['result']['songCount'] != 0:
songs = data['result']['songs']
length = len(songs)
self.set_search_widget(songs)
self.ui.status.showMessage(u'搜索到 ' + str(length) + u' 首 ' +
text +u' 相关歌曲', 2000)
return
else:
self.ui.status.showMessage(u'很抱歉，没有找到相关歌曲', 2000)
return
def set_search_widget(self, songs):
self.init_table_widget()
music_search = self.ui.info_widget.music_search_widget
music_search.show()
row_count = len(songs)
music_search.setRowCount(0)
music_search.setRowCount(row_count)
row = 0
for song in songs:
datamodel = self.model.search_result()
datamodel = self.model.set_datamodel_from_data(song, datamodel)
musicItem = QTableWidgetItem(datamodel['name'])
albumItem = QTableWidgetItem(datamodel['album']['name'])
if len(song['artists']) > 0:
artistName = song['artists'][0]['name']
artistItem = QTableWidgetItem(artistName)
music = QVariant((datamodel, ))
musicItem.setData(Qt.UserRole, music)
musicItem.setTextAlignment(Qt.AlignCenter)
artistItem.setTextAlignment(Qt.AlignCenter)
albumItem.setTextAlignment(Qt.AlignCenter)
music_search.setItem(row, 0, musicItem)
music_search.setItem(row, 1, artistItem)
music_search.setItem(row, 2, albumItem)
row += 1
def set_tablewidget_userplaylist(self, item):
self.init_table_widget()
table_widget = self.ui.info_widget.music_table_widget
table_widget.show()
data = item.data(Qt.UserRole)
playlist = data.toPyObject()[0]
plid = playlist['id']
data = [{'title': 'way back into love',
'url': 'http://m1.music.126.net/KfNqSlCW2eoJ1LXtvpLThg==/1995613604419370.mp3'}]
# data = self.user.get_music_title_and_url(pid)
data = self.net_ease.playlist_detail(plid)
# table_widget.clear()
if data is not []:
row_count = len(data)
table_widget.setRowCount(0)
table_widget.setRowCount(row_count)
row = 0
for music in data:
datamodel = self.model.music()
datamodel = self.model.set_datamodel_from_data(music, datamodel)
musicItem = QTableWidgetItem(datamodel['name'])
musicItem = QTableWidgetItem(datamodel['name'])
albumItem = QTableWidgetItem(datamodel['album']['name'])
if len(datamodel['artists']) > 0:
artistName = datamodel['artists'][0]['name']
artistItem = QTableWidgetItem(artistName)
# to get pure dict from qvariant, so pay attension !
# stackoverflow: how to get the original python data from qvariant
music = QVariant((datamodel, ))
musicItem.setData(Qt.UserRole, music)
musicItem.setTextAlignment(Qt.AlignCenter)
artistItem.setTextAlignment(Qt.AlignCenter)
albumItem.setTextAlignment(Qt.AlignCenter)
table_widget.setItem(row, 0, musicItem)
table_widget.setItem(row, 1, artistItem)
table_widget.setItem(row, 2, albumItem)
row += 1
else:
print 'network, no music, error plid'
def play_specific_music(self, source):
"""
播放一首特定的歌曲(通常是搜索到的歌曲和用户列表中的歌曲)
:param source: phonon media source
"""
self.player.stop()
self.player.setCurrentSource(source)
self.player.play()
def add_music_to_sources(self, source):
self.sources.append(source)
def add_music_to_currentplayinglist(self, music_model):
"""向当前播放列表中加入一首歌
1. 向sources列表中加入相应的 media source
2. 更新当前播放列表（current_play_widget）
:param music_model: music 的标准数据model
"""
current_playing = self.ui.info_widget.current_playing_widget
rowCount = current_playing.rowCount()
current_playing.setRowCount(rowCount + 1)
# 更新 current play widget
musicItem = QTableWidgetItem(music_model['name'])
albumItem = QTableWidgetItem(music_model['album']['name'])
if len(music_model['artists']) > 0:
artistName = music_model['artists'][0]['name']
artistItem = QTableWidgetItem(artistName)
# to get pure dict from qvariant, so pay attension !
# stackoverflow: how to get the original python data from qvariant
music = QVariant((music_model, ))
musicItem.setData(Qt.UserRole, music)
musicItem.setTextAlignment(Qt.AlignCenter)
artistItem.setTextAlignment(Qt.AlignCenter)
albumItem.setTextAlignment(Qt.AlignCenter)
current_playing.setItem(rowCount, 0, musicItem)
current_playing.setItem(rowCount, 1, artistItem)
current_playing.setItem(rowCount, 2, albumItem)
def play_search_music(self, item):
music_search = self.ui.info_widget.music_search_widget
current_row = music_search.row(item)
item = music_search.item(current_row, 0) # only item 0 contain url
data = item.data(Qt.UserRole)
song = data.toPyObject()[0]
musics = self.net_ease.song_detail(song['id'])
datamodel = self.model.music()
music_model = self.model.set_datamodel_from_data(musics[0], datamodel)
source = Phonon.MediaSource(music_model['mp3Url'])
self.add_music_to_sources(source)
self.add_music_to_currentplayinglist(music_model)
self.play_specific_music(source)
def play_userplaylist_music(self, item):
music_table = self.ui.info_widget.music_table_widget
current_row = music_table.row(item)
data = item.data(Qt.UserRole)
music_model = data.toPyObject()[0]
source = Phonon.MediaSource(music_model['mp3Url'])
self.add_music_to_sources(source)
self.add_music_to_currentplayinglist(music_model)
self.play_specific_music(source)
def tick(self, time):
time_lcd = self.ui.play_widget.time_lcd
displayTime = QTime(0, (time / 60000) % 60, (time / 1000) % 60)
time_lcd.setText(displayTime.toString('mm:ss'))
def state_changed(self, new_state, old_state):
time_lcd = self.ui.play_widget.time_lcd
play_pause_btn = self.ui.play_widget.play_pause_btn
if new_state == Phonon.ErrorState:
if self.player.errorType() == Phonon.FatalError:
QMessageBox.warning(self, "Fatal Error",
self.player.errorString())
else:
QMessageBox.warning(self, "Error",
self.player.errorString())
elif new_state == Phonon.PlayingState:
play_pause_btn.setIcon(QIcon('icons/play_hover.png'))
elif new_state == Phonon.StoppedState:
time_lcd.setText("00:00")
elif new_state == Phonon.PausedState:
play_pause_btn.setIcon(QIcon('icons/pause_hover.png'))
def source_changed(self, source):
"""
"""
# set time lcd
time_lcd = self.ui.play_widget.time_lcd
time_lcd.setText('00:00')
# set text label
current_playing = self.ui.info_widget.current_playing_widget
row = self.sources.index(source)
item = current_playing.item(row, 0)
current_playing.scrollToItem(item)
current_playing.setCurrentItem(item)
data = item.data(Qt.UserRole)
music = data.toPyObject()[0]
text_label = self.ui.play_widget.text_label
text_label.setText(music['name'])
self.net_manager.get(QNetworkRequest(QUrl(music['album']['picUrl'])))
def albumimg_load_finish(self, res):
img_label = self.ui.play_widget.img_label
img = QImage()
img.loadFromData(res.readAll())
img_label.setPixmap(QPixmap(img).scaled(50, 50))
def avatar_load_finish(self, res):
login_btn = self.ui.play_widget.login_btn
img = QImage()
img.loadFromData(res.readAll())
login_btn.setIcon(QIcon(QPixmap(img).scaled(40, 40)))
self.net_manager.finished.disconnect(self.avatar_load_finish)
self.net_manager.finished.connect(self.albumimg_load_finish)
self.ui.status.showMessage(u'加载头像成功', 2000)
def about_to_finish(self):
index = self.sources.index(self.player.currentSource()) + 1
if len(self.sources) > index:
self.player.enqueue(self.sources[index])
else:
self.player.enqueue(self.sources[0])
def last_music(self):
try:
index = self.sources.index(self.player.currentSource()) - 1
except ValueError:
self.ui.status.showMessage(u'当前播放列表为空', 2000)
return
if index >= 0:
self.player.setCurrentSource(self.sources[index])
else:
self.player.setCurrentSource(self.sources[0])
self.player.play()
def next_music(self):
try:
index = self.sources.index(self.player.currentSource()) + 1
except ValueError:
self.ui.status.showMessage(u'当前播放列表为空', 2000)
return
if len(self.sources) > index:
self.player.setCurrentSource(self.sources[index])
else:
self.player.setCurrentSource(self.sources[0])
self.player.play()
def set_tablewidget_currentplayinglist(self):
self.init_table_widget()
self.ui.info_widget.current_playing_widget.show()
def mutate(root, info, input=None):
# new_data = DataModel(data=input.data, parent_id=TaskList.get_query(info.context).first())
new_data = DataModel(data=input.data)
db_session.add(new_data)
db_session.commit()
return CreateData(data=new_data)
