def vka(text, i):
import vk_api
from vk_api.audio import VkAudio
login, password = '******', 'oyatillo99' #vk.com dagi login parolizi kiritasiz
vk_session = vk_api.VkApi(login, password)
try:
vk_session.auth()
except vk_api.AuthError as error_msg:
bot1.send_message(630751054, error_msg)
vkaudio = VkAudio(vk_session)
lis = []
if i == 1:
tracks = vkaudio.search(q=text, count=i)
for track in tracks:
title = track['title']
artist = track['artist']
url = track['url'].split('?')[0]
lis = [str(title), str(artist), url]
if lis:
break
else:
group = []
tracks = vkaudio.search(q=text)
for track in tracks:
title = track['title']
artist = track['artist']
url = track['url'].split('?')[0]
group = [str(artist), str(title), url]
lis.append(group)
return tracks
def vka(text, i):
import vk_api
from vk_api.audio import VkAudio
login, password = '******', 'PASSWORD' #vk.com dagi login parolizi kiritasiz
vk_session = vk_api.VkApi(login, password)
try:
vk_session.auth()
except vk_api.AuthError as error_msg:
print(error_msg)
vkaudio = VkAudio(vk_session)
lis = []
if i == 1:
tracks = vkaudio.search(q=text, count=i)
for track in tracks:
title = track['title']
artist = track['artist']
url = track['url'].split('?')[0]
lis = [str(title), str(artist), url]
if lis:
break
else:
group = []
tracks = vkaudio.search(q=text)
for track in tracks:
title = track['title']
artist = track['artist']
url = track['url'].split('?')[0]
group = [str(artist), str(title), url]
lis.append(group)
return lis
def main():
""" Пример составления топа исполнителей для профиля вк """
login, password = '******', 'password'
vk_session = vk_api.VkApi(login, password)
try:
vk_session.auth()
except vk_api.AuthError as error_msg:
print(error_msg)
return
vkaudio = VkAudio(vk_session)
artists = collections.Counter()
for track in vkaudio.get_iter(-99463083):
artists[track['artist']] += 1
# Составляем рейтинг первых 15
print('\nTop 15:')
for artist, tracks in artists.most_common(15):
print('{} - {} tracks'.format(artist, tracks))
# Ищем треки самого популярного
most_common_artist = artists.most_common(1)[0][0]
print('\nSearch for', most_common_artist)
tracks = vkaudio.search(q=most_common_artist)[:10]
for n, track in enumerate(tracks, 1):
print('{}. {} {}'.format(n, track['title'], track['url']))
def search_aidio(Choice_fanc: str, vk_sessions: vk_api.vk_api.VkApi, name: str,
count: int):
"""
Поиск аудио записей из общего поиска вк
или из плей листа пользователя
"""
#_________________________________________________#
vkaudio = VkAudio(vk_sessions)
if Choice_fanc == 'all':
search_111 = []
for lists_music in vkaudio.search(name, count):
search_111.append((lists_music['artist'], lists_music['title'],
lists_music['url']))
return search_111
if Choice_fanc == 'id':
search_111 = []
if not isinstance(name, int):
try:
name = int(name)
except ValueError:
return False
for lists_music in enumerate(vkaudio.get_iter(owner_id=name)):
if lists_music[0] <= count:
search_111.append(
(lists_music[1]['artist'], lists_music[1]['title'],
lists_music[1]['url']))
else:
break
return search_111
return False
def main():
""" Пример составления топа исполнителей для профиля вк """
login, password = '******', 'password'
vk_session = vk_api.VkApi(login, password)
try:
vk_session.auth()
except vk_api.AuthError as error_msg:
print(error_msg)
return
vkaudio = VkAudio(vk_session)
artists = collections.Counter(
track['artist'] for track in vkaudio.get_iter()
)
# Составляем рейтинг первых 15
print('Top 15:')
for artist, tracks in artists.most_common(15):
print('{} - {} tracks'.format(artist, tracks))
# Ищем треки самого популярного
most_common_artist = artists.most_common(1)[0][0]
print('\nSearching for {}:'.format(most_common_artist))
tracks = vkaudio.search(q=most_common_artist, count=10)
for n, track in enumerate(tracks, 1):
print('{}. {} {}'.format(n, track['title'], track['url']))
class VkMusic:
def authVk(self, login, password, flag):
try:
self.session = vk_api.VkApi(login, password)
self.session.auth()
self.setVkAudio()
except Exception:
flag.append(0)
else:
self.api = self.session.get_api()
flag.append(1)
def setVkAudio(self):
self.vkAudio = VkAudio(self.session)
def getUserPhoto(self):
return self.api.photos.get(
album_id='profile')["items"][-1]["sizes"][0]["url"]
def getUserInfo(self):
return self.api.users.get()[0]
def getUserMusic(self, userList):
music = []
music.extend(self.vkAudio.get())
userList[0] = music
def getMusic(self, name, findedMusic):
music = []
music.extend(self.vkAudio.search(name, count=500))
findedMusic[0] = music
def getting_audios(self):
vk_audio = VkAudio(self.VK)
artists = collections.Counter(track['artist']
for track in vk_audio.get_iter())
most_common_artist = artists.most_common(1)[0][0]
tracks = vk_audio.search(q=most_common_artist, count=10)
self.audios = []
for self.n, self.track in enumerate(tracks, 1):
self.audios.append(self.track['title'])
def search_audios(update, context):
global playlist_type
global vk_session
global searched_tracks
update.message.reply_text('Searching...')
vkaudio = VkAudio(vk_session)
searched_tracks = list(vkaudio.search(update.message.text))
playlist_type = 'searched'
playlist = make_playlist(playlist_type)
update.message.reply_text('Playlist:', reply_markup=playlist)
def post(self):
print(request)
vk_session = vk_api.VkApi(app_id=3380204, client_secret='Ky3xN0ohvtMzaVgCYU80')
vk_session.code_auth(request.json()['code'], request.json()['redirectUri'])
token = vk_session.token['access_token']
vkaudio = VkAudio(vk_session)
print([x for x in vkaudio.search('sandstorm')])
"""
'code' (139893782146720) = {str} 'f2addb2855bb6b95b5'
'clientId' (139893782181168) = {str} '3380204'
'redirectUri' (139893782180784) = {str} 'https://192.168.20.37:8080/'
"""
return {"status": request, 'access_token': 'fdsafsad'}, 200
def main():
""" Пример составления топа исполнителей для профиля вк """
login, password = '******', 'pomogite'
vk_session = vk_api.VkApi(login, password)
try:
vk_session.auth()
except vk_api.AuthError as error_msg:
print(error_msg)
return
vkaudio = VkAudio(vk_session)
artists = collections.Counter()
offset = 0
while True:
audios = vkaudio.get(owner_id=124250662, offset=offset)
if not audios:
break
for audio in audios:
artists[audio['artist']] += 1
offset += len(audios)
# Составляем рейтинг первых 15
print('\nTop 15:')
for artist, tracks in artists.most_common(15):
print('{} - {} tracks'.format(artist, tracks))
# Ищем треки самого популярного
most_common_artist = artists.most_common(1)[0][0]
print('\nSearch for', most_common_artist)
tracks = vkaudio.search(q=most_common_artist)[:10]
for n, track in enumerate(tracks, 1):
print('{}. {} {}'.format(n, track['title'], track['url']))
def main():
""" Пример составления топа исполнителей для профиля вк """
login, password = '******', 'password'
vk_session = vk_api.VkApi(login, password)
try:
vk_session.auth()
except vk_api.AuthError as error_msg:
print(error_msg)
return
vkaudio = VkAudio(vk_session)
artists = collections.Counter()
offset = 0
while True:
audios = vkaudio.get(owner_id=-99463083, offset=offset)
if not audios:
break
for audio in audios:
artists[audio['artist']] += 1
offset += len(audios)
# Составляем рейтинг первых 15
print('\nTop 15:')
for artist, tracks in artists.most_common(15):
print('{} - {} tracks'.format(artist, tracks))
# Ищем треки самого популярного
most_common_artist = artists.most_common(1)[0][0]
print('\nSearch for', most_common_artist)
tracks = vkaudio.search(q=most_common_artist)[:10]
for n, track in enumerate(tracks, 1):
print('{}. {} {}'.format(n, track['title'], track['url']))
class VkSongs(object):
"""VK-Songs downloads VK audio files"""
def __init__(self):
self.logger = VkSongs.get_logger(level=logging.DEBUG) # TODO: Configurable log
self.session = requests.Session()
self.is_logged_in = False
self.vk = None
self.vk_audio = None
def login(self, login_user, login_pass):
"""Logs in to VK"""
vk_session = vk_api.VkApi(
login_user, login_pass,
auth_handler=self.two_factor_handler,
captcha_handler=self.captcha_handler,
app_id=6692066,
)
try:
vk_session.auth()
except vk_api.AuthError as error_msg:
self.logger.error('Login failed for {0}. Reason: {1}'.format(login_user, error_msg))
return
self.vk = vk_session.get_api()
self.vk_audio = VkAudio(vk_session)
self.is_logged_in = True
@staticmethod
def two_factor_handler():
key = input("♫ Enter authentication code: ")
remember_device = True
return key, remember_device
@staticmethod
def captcha_handler(captcha):
# TODO: Implement it using PyInquirer
key = input("♫ Enter captcha code {0}: ".format(captcha.get_url())).strip()
return captcha.try_again(key)
@staticmethod
def get_color(level):
print(level)
if level == 'ERROR':
return Fore.RED
elif level == 'WARNING':
return Fore.YELLOW
else:
return ''
@staticmethod
def get_logger(level=logging.DEBUG):
"""Returns a logger"""
logger = logging.getLogger(__name__)
fh = logging.FileHandler('vk-songs.log', 'w')
fh.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
fh.setLevel(level)
logger.addHandler(fh)
import sys
sh = logging.StreamHandler(sys.stdout)
sh.setFormatter(logging.Formatter(Fore.RED + '%(levelname)s: %(message)s'))
sh.setLevel(logging.ERROR)
logger.addHandler(sh)
return logger
def download(self, song, save_dir='./', tag=False):
"""Downloads the media file"""
from pathvalidate import sanitize_filename
import eyed3
from eyed3.id3 import ID3_V2_4
url = song.url
base_name = '{0} - {1}.mp3'.format(song.artist.strip(), song.title.strip()) # TODO: Configurable file mask
base_name = sanitize_filename(base_name, replacement_text='_')
file_path = os.path.join(save_dir, base_name)
if not os.path.isfile(file_path):
import time
with open(file_path, 'wb') as media_file:
try:
content = self.session.get(url).content
except requests.exceptions.ConnectionError:
time.sleep(5)
content = self.session.get(url).content
media_file.write(content)
file_time = time.time()
os.utime(file_path, (file_time, file_time))
if tag:
audio_file = eyed3.load(file_path)
eyed3.core.log.disabled = True
eyed3.id3.log.disabled = True
if audio_file:
if not audio_file.tag:
audio_file.initTag(version=ID3_V2_4)
audio_file.tag.artist = song.artist
audio_file.tag.album_artist = song.artist
audio_file.tag.title = song.title
if song.album is not None:
audio_file.tag.album = song.album
audio_file.tag.save(version=ID3_V2_4, encoding='utf_8')
return True
else:
return False
def search(self, query):
search = self.vk_audio.search(q=query) # TODO: Generator
result = []
for audio in search:
audio['url'] = audio['url'].split('?', 1)[0]
result.append(VkSong(num=audio['id'], artist=audio['artist'], title=audio['title'], url=audio['url']))
if len(result) == 0:
self.logger.error('No songs found')
return result
def search_user(self, owner_id, query):
search = self.vk_audio.search_user(owner_id=owner_id, q=query)
result = []
for audio in search:
audio['url'] = audio['url'].split('?', 1)[0]
result.append(VkSong(num=audio['id'], artist=audio['artist'], title=audio['title'], url=audio['url']))
if len(result) == 0:
self.logger.error('No songs found')
return result
def get_albums(self, owner_id):
albums = self.vk_audio.get_albums(owner_id=owner_id) # TODO: Generator
result = []
for album in albums:
result.append(VkAlbum(title=album['title'], album_id=album['id'], owner_id=album['owner_id']))
if len(result) == 0:
self.logger.error('No albums found')
return result
def get(self, owner_id=None, album_id=None, album_title=None):
songs = self.vk_audio.get(owner_id=owner_id, album_id=album_id) # TODO: Generator
result = []
for audio in songs:
audio['url'] = audio['url'].split('?', 1)[0]
result.append(VkSong(num=audio['id'], artist=audio['artist'],
title=audio['title'], url=audio['url'], album=album_title))
if len(result) == 0:
self.logger.error('No songs found')
return result
@staticmethod
def should_login(dict):
# TODO: Implement user session caching
return True
@staticmethod
def make_dst_dir(destination='./', artist='/'):
"""Creates the destination directory."""
destination = destination + artist
try:
os.makedirs(destination)
except OSError as err:
import errno
if err.errno == errno.EEXIST and os.path.isdir(destination):
# Directory already exists
pass
else:
# Target dir exists as a file, or a different error
raise
return destination
def process_input(message, page=1, text=""):
text = message.text
try:
# this code is used to identify repeated requests from one input
text = text.split("• ")
if len(text) > 1:
text = text[1]
else:
text = text[0]
keyboard = types.InlineKeyboardMarkup()
# retrieve songs from the private dropbox cloud
if 'dropbox' in text:
cut_text = text.strip('dropbox')
result = extract_music_files(cut_text, music_dict)
# split list into small sublists limited by 10
result_split_page = [
result[x:x + 10] for x in range(0, len(result), 10)
]
# add button to telegram according to page numeration
page_file = page - 1
# retrieve songs from public vk
else:
# autorisation process
vk_session = vk_api.VkApi(vk_login, vk_password)
vk_session.auth(token_only=True)
vk = vk_session.get_api()
vk_audio = VkAudio(vk_session)
###
result = []
page_file = 0
number_of_songs = len(
list(vk_audio.search(text, count=15, offset=0)))
time.sleep(rd.uniform(0.5, 1.1))
tracks = list(vk_audio.search(text, count=5,
offset=5 * (page - 1)))
for song in range(0, len(tracks)):
row = []
row.append(tracks[song]['artist'] + ' ' +
tracks[song]['title'])
row.append(tracks[song]['owner_id'])
row.append(tracks[song]['id'])
result.append(row)
result_split_page = [
result[x:x + 5] for x in range(0, number_of_songs, 5)
]
print(result)
audio_format = ".mp3"
if len(result_split_page) != 0:
for i in range(0, len(result_split_page[page_file])):
if ".mp3" in result_split_page[page_file][i][0]:
result_split_page[page_file][i][0] = result_split_page[
page_file][i][0].replace(".mp3", "")
# audio_format = ".mp3"
# callback_data API is limited to 64 bytes (64 letters long)
button = types.InlineKeyboardButton(
text=result_split_page[page_file][i][0],
callback_data="audio_row;" + str(i) + ";" + audio_format +
";" + str(result_split_page[page_file][i][1]) + ";" +
str(result_split_page[page_file][i][2]))
keyboard.add(button)
# initiate paginator
paginator = InlineKeyboardPaginator(int(len(result_split_page)),
current_page=page,
data_pattern='page;{page};' +
str(text))
bot.send_message(message.chat.id,
"Found songs: ",
reply_markup=keyboard)
if len(result_split_page) > 1:
# send number of pages when at least more than one
bot.send_message(message.chat.id,
"Page: " + str(page) + " • " + str(text),
reply_markup=paginator.markup,
parse_mode='Markdown')
else:
bot.send_message(message.chat.id, "No results")
except Exception as e:
print('Error in process_input:', e)
print(traceback.format_exc())
# bot.send_message(message.from_user.id, e)
bot.send_message(message.chat.id, "Error occured, no results")
def make_search(self, track, chat_id):
vkaudio = VkAudio(self.vk_session)
self.tracks[chat_id] = vkaudio.search(track, offset=0)