Exemple #1
0
def add_song(name, list):
    startTime = time.time()
    ytb = Youtube()
    print("ytb " + str(time.time() - startTime))
    url = ytb.get_one(name)
    print("url " + str(time.time() - startTime))
    pafy = ytb.get_audio(url)
    print("pafy " + str(time.time() - startTime))
    list.add(pafy)
    print("list " + str(time.time() - startTime))
Exemple #2
0
def daily_thread():
    """ Print daily data every minute """
    youtube = Youtube()
    portfolio = Portfolio()
    while True:
        try:
            youtube.subscribers()
            portfolio.value()
        except ConnectionError:
            time.sleep(300)
        time.sleep(60)
Exemple #3
0
def main():
    sp = Spotify()
    yt = Youtube()

    yt_playlist_id = input("Enter youtube playlist id: ")
    spotify_playlist_name = input("Enter a name for your spotify playlist: ")
    songs = yt.get_songs_from_playlist(yt_playlist_id)
    spotify_playlist_id = sp.create_playlist(spotify_playlist_name)

    for song in songs:
        song_uri = sp.get_song_uri(song.artist, song.title)
        was_added = sp.add_song_to_playlist(song_uri, spotify_playlist_id)
        if was_added:
            print(f'{song.artist} - {song.title} was added to playlist.')
def gen_process() -> list:
    event_list = []
    if config['youtube']['enable']:
        for user_config in config['youtube']['users']:
            y = Youtube(user_config)
            event_list.append(y)
    if config['twitcasting']['enable']:
        for user_config in config['twitcasting']['users']:
            t = Twitcasting(user_config)
            event_list.append(t)
    if config['openrec']['enable']:
        for user_config in config['openrec']['users']:
            o = Openrec(user_config)
            event_list.append(o)
    if config['mirrativ']['enable']:
        for user_config in config['mirrativ']['users']:
            m = Mirrativ(user_config)
            event_list.append(m)
    if config['bilibili']['enable']:
        for user_config in config['bilibili']['users']:
            b = Bilibili(user_config)
            event_list.append(b)
            if user_config['article']:
                b1 = BilibiliArticle(user_config)
                event_list.append(b1)
            if user_config['live']:
                b2 = BilibiliLive(user_config)
                event_list.append(b2)
    return event_list
Exemple #5
0
def initialize():
	"""Method for initializing a youtube object, connection to the DB and load comments 
	get the comments for the youtube videos ids listed in the DB, store the comments in the DB, 
	train the classifier and print the classifier metrics   
		Args: 
		   config: dicitionary containing the DB parameters
	"""
	with app.app_context():
		g.config = get_config()
		g.yt = Youtube(api_key= g.config ['youtube']['API_KEY'], api_version = g.config ['youtube']['API_VERSION'], service_name=g.config['youtube']['API_SERVICE_NAME'])
		video_ids = g.config['youtube_videos_id']
		g.comments = []
		for video_id in video_ids:
			g.comments.extend(g.yt.get_video_comments(video_id))
		#db_params = {"user":g.config['db']['user'], "host":g.config['db']["host"], "port":g.config['db']["port"],"database": g.config['db']["database"]}
		g.db = DBController(**g.config['db'])

		# create table if it does not exist:
		g.db.create_comments_table()

		# train classifier
		g.classifier = Classifier()
		g.classifier.train()

		# predication of the comments
		for comment_item in g.comments:
			text = comment_item.text
			predication = g.classifier.predict(comment_text)
			comment_item.sentiment  = predication
			# insert the comment in DB 
			g.db.insert_comments(comment_item)		
Exemple #6
0
 def __init__(self):
     self.index = 0
     self.youtube_services = []
     for api_key in YOUTUBE_API_KEYS:
         self.youtube_services.append(
             Youtube(api_key, YOUTUBE_API_SERVICE_NAME,
                     YOUTUBE_API_VERSION))
Exemple #7
0
    def youtube(*args):
        """
        Use the Youtube API to return a youtube video
        """
        # Convert from tuple to list so we can modify
        try:
            idx, args = _get_idx_from_args(list(args))
            idx = 0 if idx == -1 else idx
        except ValueError as error:
            return "text", str(error)

        try:
            youtube = Youtube(*args)
        except APIError as error:
            return "text", str(error)

        return "text", youtube.get_video(idx)
Exemple #8
0
 def __init__(self, spotify={}, youtube={}):
     """
     make a resource to talk to spotify api and youtube api
     see spotify.py for params
     see youtube.py for params
     """
     self.sf = Spotfy(**spotify)
     self.yt = Youtube(**youtube_parser)
Exemple #9
0
def listening_now(max_tunes, by_id=True):
    """
    Get a list of tunes other people using last.fm are listening to,
    and turn them in to a youtube list of Tracks objects.

    TODO: this might need a little more work

    :param max_tunes: The amount of Tracks.
    :type max_tunes: int
    :param by_id: Only add tunes that have a youtube ID(recommended)
    :type by_id: bool
    :return: A list of Track objects
    :rtype: list | None
    """
    url = LISTENING_NOW_URL.format(max_tunes)
    lastfm = web.get(url=url, as_json=True)

    log.debug('lastfm response %s' % lastfm.json)

    if len(lastfm.json['Users']) != 0:
        yt_tracks = []
        for user in lastfm.json['Users']:
            if 'playlink' in user:
                if 'data-youtube-id' in user['playlink']:
                    youtube_id = user['playlink']['data-youtube-id']
                    yt = Youtube.id_details(youtube_id)
                    log.debug(yt)

                    if isinstance(yt, Track):
                        yt_tracks.append(yt)
            else:
                if 'Track' in user:
                    search_str = '%s-%s' % (user['Track']['Artist'],
                                            user['Track']['Name'])
                    if not by_id:
                        yt = Youtube.search(search_str)
                        log.debug('search by search string: %s result: %s' %
                                  (search_str, yt))
                        if isinstance(yt, Track):
                            yt_tracks.append(yt)

            return yt_tracks

        return None
 def get_from_yt(user_input):
     youtube = Youtube(yt_resource)
     youtube.search_channel(user_input)
     youtube.print_channels()
     return youtube.select_channel(
         int(
             input_in_range('Select channel: ', 1,
                            youtube.total_channels + 1)))
    def upload(self):
        self.youtube = Youtube()
        title = util.template(self.config.youtube_title, self.dictionary)
        description = util.template(self.config.youtube_description, self.dictionary)
        category_id = self.config.youtube_category_id
        tags = []
        upload_result = self.youtube.initialize_upload(title, description, self.video_path, category_id, tags)
        self.youtube_videoid = upload_result["id"]

        return upload_result["id"]
Exemple #12
0
def main():
    playlist_url = input("Youtube playlist url: ")
    playlist_name = input("Playlist name: ")

    yt = Youtube(playlist_url)
    song_titles = yt.get_songs_title()
    print(len(song_titles))
    songs_info = yt.get_songs_info(song_titles)
    print(len(songs_info))
    spotify = Spotify()
    playlst_id = spotify.create_playlist(playlist_name)

    for song_name, artist in songs_info.items():
        uri = spotify.get_spotify_uri(artist, song_name)
        status = spotify.add_songs_to_playlist(playlst_id, {"uris": [uri]})
        if status:
            print(f"{artist}-{song_name} was added to playlist.")
        else:
            print(f"\nERROR!! {artist}-{song_name} could not be added.\n")
    async def populate_random(self):
        youtube = Youtube()

        async def get_one():
            async for item in youtube.random(None, 50):
                self.db[item['id']['videoId']] = 'random'
                if len(self.db) % 100 == 0:
                    print(len(self.db))

        tasks = [get_one() for i in range(2000)]
        await asyncio.gather(*tasks)
        await youtube.close()
Exemple #14
0
    def setpassword(message, client):
        global youtube_instance
        global password
        global user_id
        print("In set password")

        with open(os.path.join(sys.path[0], "assets/ussername_pass.json"),
                  'r+') as passfile:
            data = json.load(passfile)
            email = data["email"]
            passs = data["password"]
            credentials = message[9:]
            username, password_ = credentials.split(",")
            print(username)
            print(password_)
            if passs == "":
                print("Here")
                hashpass = hashlib.sha256(str.encode(password_)).hexdigest()
                print(hashpass)
                data = {"email": username, "password": hashpass}
                passfile.seek(0)
                json.dump(data, passfile)
                passfile.truncate()
                youtube_instance = Youtube(username, password_)
                password = password_
                client.publish("GladOs/messages/raspberry2phone" + user_id,
                               "Everything OK")
                TTS("I am ready to take your commands master!")
            else:

                if (hashlib.sha256(
                        str.encode(password_)).hexdigest() == passs):
                    print("Here")
                    youtube_instance = Youtube(username, password_)
                    client.publish("GladOs/messages/raspberry2phone" + user_id,
                                   "Everything OK")
                    TTS("I am ready to take your commands master!")
                else:
                    client.publish("GladOs/messages/raspberry2phone" + user_id,
                                   "Wrong password enter again!")
Exemple #15
0
    def paginate(self) -> bool:
        if self.current_playlist_urls and len(
                self.current_playlist_urls) == self.total_items:
            return False
        self.current_page += 1

        response: Dict = self.spotify.get_liked_songs(limit=PAGINATION_LIMIT,
                                                      page=self.current_page)
        songs: List[Dict] = response['items']
        self.total_items = response['total']
        queries = list(map(Spotify.get_searchable_name, songs))
        print(queries)
        new_urls = list(
            map(lambda s: Youtube.get_audio_url(Youtube.search(s)[0]),
                queries))
        print("URLS: ", new_urls)

        self.current_playlist_urls.extend(new_urls)
        self.current_media_list.lock()
        for url in new_urls:
            self.current_media_list.add_media(url)
        self.current_media_list.unlock()
        return True
Exemple #16
0
def main():
    sp = Spotify()
    yt = Youtube()

    yt_playlist_id = input("Enter youtube playlist id: ")
    spotify_playlist_name = input("Enter a name for your spotify playlist: ")
    spotify_playlist_id = sp.create_playlist(spotify_playlist_name)
    songs = yt.get_songs_from_playlist(yt_playlist_id)

    for song in songs:
        song_uri = sp.get_song_uri(song.artist, song.title)

        if not song_uri:
            print(f"{song.artist} - {song.title} was not found!")
            continue

        was_added = sp.add_song_to_playlist(song_uri, spotify_playlist_id)

        if was_added:
            print(f'{song.artist} - {song.title} was added to playlist.')

    total_songs_added = sp._num_playlist_songs(spotify_playlist_id)
    print(f'Added {total_songs_added} songs out of {len(songs)}')
Exemple #17
0
    def get_songs(self):

        spotify = spotipy.Spotify(auth=self.token)
        results = spotify.search(q=self.genre, type='playlist',limit=10)

        for playlist in results['playlists']['items']:

            if playlist['tracks']['total'] < self.num_of_vid:
                print('tracks less than '+ str(self.num_of_vid) + 'skipping to next playlist')
                continue

            else:
                playlist_tracks = spotify.user_playlist_tracks(playlist['owner']['id'], playlist['id'])
                print('playlist has ' +str(playlist_tracks['total'])+ ' songs.')

                f_cnt = -1
                s_cnt = 0
                for playlist_track in playlist_tracks['items']:

                    f_cnt += 1
                    if f_cnt == 0:
                        continue

                    try:
                        #song data
                        song_title = playlist_track['track']['artists'][0]['name'] + ' - ' + playlist_track['track']['name']
                        song_id = playlist_track['track']['id']

                        # song features
                        audio_features = spotify.audio_features(song_id)

                        # video data
                        video_url = Youtube(song_title).search_video()
                        format = pytube.YouTube(video_url).streams.get_by_itag('133')

                        if s_cnt == self.num_of_vid:
                            break
                        
                        # donwload video / save data in db
                        s_cnt += 1
                        print('song: '+str(s_cnt)+ ': '+song_title+ ' | ' +video_url+ ' | ' +str(format))
                        format.download(self.dir)

                    except:
                        print('error. continuing to next song.')
                        continue

                break
Exemple #18
0
async def scheduled(wait_for):
    while True:
        await asyncio.sleep(wait_for)
        with open('data.json', 'r') as data_file:
            json_data = data_file.read()
        video_links = json.loads(json_data)

        video_links1 = Youtube.get_all_video_in_channel(channel_id)
        subscriptions = db.get_subscriptions()

        if video_links1[0] != video_links[0]:
            for s in subscriptions:
                vd = video.vid_info(video_links1[0])
                await bot.send_message(s[1],
                                       vd['title'] + "\n" + video_links1[0],
                                       disable_notification=True)
        video_links = video_links1
Exemple #19
0
def test_get_video(mock_request, mock_response):
    """ Test getting a YT video """
    mock_request.return_value = mock_response
    youtube = Youtube("northernlion")
    assert youtube.url == (f"https://www.googleapis.com/youtube/v3/search"
                           f"?key={YOUTUBE_AUTH}&q=northernlion&maxResults"
                           f"={MAX_REQUESTED_VIDS}&type=video")

    assert youtube.get_video(0) == f"{BASE_URL}isaac"

    # Test getting a youtube video but no results
    mock_response.json.return_value = {"items": []}
    youtube = Youtube("northernlion")
    with pytest.raises(APIError) as error:
        youtube.validate_num_vids()

    assert "Sorry, there were no videos" in str(error)
 def gen_process(self):
     if config['youtube']['enable']:
         for user_config in config['youtube']['users']:
             y = Youtube(user_config)
             self.events_multi.append(y)
     if config['twitcasting']['enable']:
         for user_config in config['twitcasting']['users']:
             t = Twitcasting(user_config)
             self.events_multi.append(t)
     if config['openrec']['enable']:
         for user_config in config['openrec']['users']:
             o = Openrec(user_config)
             self.events_multi.append(o)
     if config['mirrativ']['enable']:
         for user_config in config['mirrativ']['users']:
             m = Mirrativ(user_config)
             self.events_multi.append(m)
     if config['bilibili']['enable']:
         for user_config in config['bilibili']['users']:
             b = Bilibili(user_config)
             self.events_multi.append(b)
Exemple #21
0
async def main():
    if "youtube.com/channel" in sys.argv[1] or "youtube.com/watch" in sys.argv[
            1]:
        s = Youtube(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "")
        data = await s.get_play_info()
        title = data["title"]
        url = data["play_url"]
    elif "twitch.tv/" in sys.argv[1]:
        s = Twitch(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "")
        data = await s.get_play_info()
        title = data["title"]
        url = data["play_url"]
    elif "douyu.com/" in sys.argv[1]:
        s = Douyu(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "")
        data = await s.get_play_info()
        title = data["title"]
        url = data["play_url"]
    elif "huya.com/" in sys.argv[1]:
        s = Huya(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "")
        data = await s.get_play_info()
        title = data["title"]
        url = data["play_url"]
    elif "live.bilibili.com/" in sys.argv[1]:
        s = Bilibili(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "")
        data = await s.get_play_info()
        title = data["title"]
        url = data["play_url"]
    elif "bilibili.com/" in sys.argv[1]:
        s = Bilibili(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "")
        await s.get_play_info_video()
        return
    else:
        await run_ykdl(sys.argv[1])
        return

    print("title: " + title, flush=True)
    print(url, flush=True)
Exemple #22
0
def chart(chart_items=5):
    """
    Finds the currently most played tunes on last.fm and
    returns them as a list of Track objects.

    :param chart_items: The amount of tracks wanted.
    :type chart_items: int
    :return: A list of Track objects or None on error.
    :rtype: list | None
    """
    url = CHART_URL.format(chart_items)
    lastfm = web.get(url=url, as_json=True)

    log.debug('lastfm response %s' % lastfm.json)

    if len(lastfm.errors) > 0:
        log.error(lastfm.errors)
        return None
    else:
        if 'results' in lastfm.json:
            if 'track' in lastfm.json['results']:
                if len(lastfm.json['results']['track']) != 0:

                    yt_tracks = []
                    for track in lastfm.json['results']['track']:
                        search_str = '%s-%s' % (track['artist'], track['name'])
                        yt = Youtube.search(search_str)

                        log.debug(yt)

                        if isinstance(yt, Track):
                            yt_tracks.append(yt)

                    return yt_tracks

                return None
Exemple #23
0
#function to list the region that I am interesting in.
def generate_supported_region_ids():
    regions_ids = {'Argentina': 'AR', 'Australia': 'AU', 'Brazil': 'BR', 'Canada': 'CA',
                   'Egypt': 'EG', 'France': 'FR', 'Germany': 'DE', 'Great Britain': 'GB',
                   'Hong Kong': 'HK', 'India': 'IN', 'Ireland': 'IE', 'Italy': 'IT',
                   'Japan': 'JP', 'Malaysia': 'MY', 'Mexico': 'MX', 'Netherlands': 'NL',
                   'New Zealand': 'NZ', 'Russia': 'RU', 'Saudi Arabia': 'SA', 'Singapore': 'SG',
                   'South Africa': 'ZA', 'South Korea': 'KR', 'Spain': 'ES', 'Sweden': 'SE',
                   'Switzerland': 'CH', 'Taiwan': 'TW', 'United States': 'US'}
    return regions_ids

#main
if __name__ == '__main__':
    #instantiate the youtubapi class. This would default the region to US and api string.
    youtube = Youtube()
    #get a dictionary of regions ids.
    regions_ids = generate_supported_region_ids()
    #a list to store the result.
    result = []
    #go through all regions ids.
    for name, region_id in regions_ids.iteritems():

        temp_result = dict()
        #first set the region to region id.
        youtube.set_region_id(region_id)
        #then do an api to youtube to get the top 10.
        status, body = youtube.get_most_popular_by_region()
        #if response from youtube is not okay then store the error.
        if status != 200:
            temp_result[name] = 'Unable to get data for %s' % name
Exemple #24
0
class MusicDownloader(object):
    def __init__(self):
        self.__youtube = Youtube()
        self.__spotify = Spotify()
        self.__editor = TagEditor()
        self.__last = LastFM()
        self.__apple = AppleMusic()
        self.__deezer = Deezer()

    def __downloadMusicFromYoutube(self, name, uri, dur):

        #finding song on youtube
        self.__youtube.get(name, dur)

        #downloading video from youtube
        if self.__youtube.download(url=self.__youtube.getResult(),
                                   path=uri,
                                   filename=uri):
            #converting video to mp3 file
            self.__youtube.convertVideoToMusic(uri=uri)
            return True
        else:
            return False

    def __getSongInfoFromSpotify(self, uri):

        try:
            return self.__spotify.getSongInfo(uri)
        except:
            return None

    def getNameFromYoutube(self, url):
        return self.__youtube.getNameFromYoutube(url)

    def getData(self, uri):
        try:
            return self.__spotify.getSongInfo(uri)
        except:
            return None

    def getLastFMTags(self, name):
        return self.__last.get(name)

    def getYoutubeMusicInfo(self, url):
        return self.__youtube.getNameFromYoutube(url)

    def downloadBySpotifyUri(self, uri, path):

        #get info
        info = self.__getSongInfoFromSpotify(uri)

        if info:

            fixed_name = f'{info["artist"][0]} - {info["name"]}'
            fixed_name = fixed_name.replace('.', '')
            fixed_name = fixed_name.replace(',', '')
            fixed_name = fixed_name.replace("'", '')
            fixed_name = fixed_name.replace("/", "")

            #finding and download from YouTube and tagging
            if self.__downloadMusicFromYoutube(fixed_name, info['uri'],
                                               info['duration_ms']):

                self.__editor.setTags(data=info)

                cachepath = os.getcwd() + '/cache'
                fullpath = os.getcwd() + '/Downloads'

                if not os.path.exists(fullpath):
                    os.makedirs(fullpath)

                name = f'{info["artist"][0]} - {info["name"]}'

                os.rename(f"{cachepath}/{info['uri']}/{info['uri']}.mp3",
                          f"{fullpath}/{getCorrect(name)}.mp3")

                print(path)

                if path:

                    os.rename(f"{fullpath}/{getCorrect(name)}.mp3",
                              f"{path}/{getCorrect(name)}.mp3")

                #deleting cache
                try:
                    shutil.rmtree(f"cache/{info['uri']}")
                except:
                    pass

                notify.send(f'{info["artist"][0]} - {info["name"]}')
                return True
        return False

    def downloadBySearchQuery(self, query, path=None):

        #get info
        info = self.__spotify.search(query=query)

        if not info:
            info = self.__last.get(query)

        if info:

            fixed_name = f'{info["artist"][0]} - {info["name"]}'
            fixed_name = fixed_name.replace('.', '')
            fixed_name = fixed_name.replace(',', '')
            fixed_name = fixed_name.replace("'", '')
            fixed_name = fixed_name.replace("/", "")

            #finding and download from YouTube and tagging
            self.__downloadMusicFromYoutube(fixed_name, info['uri'],
                                            info['duration_ms'])

            self.__editor.setTags(data=info)

            cachepath = os.getcwd() + '/cache'
            fullpath = os.getcwd() + '/Downloads'

            if not os.path.exists(fullpath):
                os.makedirs(fullpath)

            name = f'{info["artist"][0]} - {info["name"]}'

            os.rename(f"{cachepath}/{info['uri']}/{info['uri']}.mp3",
                      f"{fullpath}/{getCorrect(name)}.mp3")

            if path:

                os.rename(f"{fullpath}/{getCorrect(name)}.mp3",
                          f"{path}/{getCorrect(name)}.mp3")

            #deleting cache
            try:
                shutil.rmtree(f"cache/{info['uri']}")
            except:
                pass

            notify.send(f'{info["artist"][0]} - {info["name"]}')
            return True, info
        else:
            return False, None

    def downloadBySpotifyUriFromFile(self, filename):
        try:

            with open(filename, 'r') as f:
                data = f.readlines()

        except FileNotFoundError:

            print(f'No such file or directory: "{filename}"')
            exit(2)

        #normalize
        try:
            data.remove('\n')
        except:
            pass
        links = [str(item).replace('\n', '') for item in data]

        for i, song in zip(range(len(links)), links):
            print(f'[{i+1}] - {song}')
            try:
                state = self.downloadBySpotifyUri(str(song).split(':')[-1])
                if not state:
                    notify.send(f'Failed to download', True)
            except:
                print('Something went wrong!')

    def downloadBySpotifyUriPlaylistMode(self, playlist_uri, path):

        user = Spotify.User()
        playlist = user.getPlaylistTracks(playlist_uri)

        for info, i in zip(playlist, range(len(playlist))):

            print(f'Downloading {i+1} of {len(playlist)}')

            fixed_name = f'{info["artist"][0]} - {info["name"]}'
            fixed_name = fixed_name.replace('.', '')
            fixed_name = fixed_name.replace(',', '')
            fixed_name = fixed_name.replace("'", '')
            fixed_name = fixed_name.replace("/", "")

            #finding and download from YouTube and tagging
            self.__downloadMusicFromYoutube(fixed_name, info['uri'],
                                            info['duration_ms'])

            self.__editor.setTags(data=info)

            cachepath = os.getcwd() + '/cache'
            fullpath = os.getcwd() + '/Downloads'

            if not os.path.exists(fullpath):
                os.makedirs(fullpath)

            name = f'{info["artist"][0]} - {info["name"]}'

            os.rename(f"{cachepath}/{info['uri']}/{info['uri']}.mp3",
                      f"{fullpath}/{getCorrect(name)}.mp3")

            if path:

                os.rename(f"{fullpath}/{getCorrect(name)}.mp3",
                          f"{path}/{getCorrect(name)}.mp3")

            #deleting cache
            try:
                shutil.rmtree(f"cache/{info['uri']}")
            except:
                pass

            notify.send(f'{info["artist"][0]} - {info["name"]}')

    def downloadBySpotifyUriAlbumMode(self, album_uri, path):

        user = Spotify()
        playlist = user.getAlbum(album_uri)

        for info, i in zip(playlist['tracks'], range(len(playlist['tracks']))):

            print(f'Downloading {i+1} of {len(playlist["tracks"])}')

            fixed_name = f'{info["artist"][0]} - {info["name"]}'
            fixed_name = fixed_name.replace('.', '')
            fixed_name = fixed_name.replace(',', '')
            fixed_name = fixed_name.replace("'", '')
            fixed_name = fixed_name.replace("/", "")

            #finding and downloading from YouTube and tagging
            self.__downloadMusicFromYoutube(fixed_name, info['uri'],
                                            info['duration_ms'])

            self.__editor.setTags(data=info)

            cachepath = os.getcwd() + '/cache'
            fullpath = os.getcwd() + '/Downloads'

            if not os.path.exists(fullpath):
                os.makedirs(fullpath)

            name = f'{info["artist"][0]} - {info["name"]}'

            os.rename(f"{cachepath}/{info['uri']}/{info['uri']}.mp3",
                      f"{fullpath}/{getCorrect(name)}.mp3")

            if path:

                os.rename(f"{fullpath}/{getCorrect(name)}.mp3",
                          f"{path}/{getCorrect(name)}.mp3")

            #deleting cache
            try:
                shutil.rmtree(f"cache/{info['uri']}")
            except:
                pass

            notify.send(f'{info["artist"][0]} - {info["name"]}')

    def downloadByDeezerUrl(self, url, path):

        link = str(str(url).split('/')[-1]).split('?')[0]

        #get info
        info = self.__deezer.getSongInfo(link)

        if info:

            fixed_name = f'{info["artist"][0]} - {info["name"]}'
            fixed_name = fixed_name.replace('.', '')
            fixed_name = fixed_name.replace(',', '')
            fixed_name = fixed_name.replace("'", '')
            fixed_name = fixed_name.replace("/", "")

            #finding and download from YouTube and tagging
            if self.__downloadMusicFromYoutube(fixed_name, info['uri'],
                                               info['duration_ms']):

                self.__editor.setTags(data=info)

                cachepath = os.getcwd() + '/cache'
                fullpath = os.getcwd() + '/Downloads'

                if not os.path.exists(fullpath):
                    os.makedirs(fullpath)

                name = f'{info["artist"][0]} - {info["name"]}'

                os.rename(f"{cachepath}/{info['uri']}/{info['uri']}.mp3",
                          f"{fullpath}/{getCorrect(name)}.mp3")

                print(path)

                if path:

                    os.rename(f"{fullpath}/{getCorrect(name)}.mp3",
                              f"{path}/{getCorrect(name)}.mp3")

                #deleting cache
                try:
                    shutil.rmtree(f"cache/{info['uri']}")
                except:
                    pass

                notify.send(f'{info["artist"][0]} - {info["name"]}')
                return True
        return False

    def downloadByDeezerUrlAlbumMode(self, album_url, path):

        link = str(str(album_url).split('/')[-1]).split('?')[0]

        #get info
        playlist = self.__deezer.getAlbum(link)

        for info, i in zip(playlist['tracks'], range(len(playlist['tracks']))):

            print(f'Downloading {i+1} of {len(playlist["tracks"])}')

            fixed_name = f'{info["artist"][0]} - {info["name"]}'
            fixed_name = fixed_name.replace('.', '')
            fixed_name = fixed_name.replace(',', '')
            fixed_name = fixed_name.replace("'", '')
            fixed_name = fixed_name.replace("/", "")

            #finding and downloading from YouTube and tagging
            self.__downloadMusicFromYoutube(fixed_name, info['uri'],
                                            info['duration_ms'])

            self.__editor.setTags(data=info)

            cachepath = os.getcwd() + '/cache'
            fullpath = os.getcwd() + '/Downloads'

            if not os.path.exists(fullpath):
                os.makedirs(fullpath)

            name = f'{info["artist"][0]} - {info["name"]}'

            os.rename(f"{cachepath}/{info['uri']}/{info['uri']}.mp3",
                      f"{fullpath}/{getCorrect(name)}.mp3")

            if path:

                os.rename(f"{fullpath}/{getCorrect(name)}.mp3",
                          f"{path}/{getCorrect(name)}.mp3")

            #deleting cache
            try:
                shutil.rmtree(f"cache/{info['uri']}")
            except:
                pass

            notify.send(f'{info["artist"][0]} - {info["name"]}')

    def downloadByDeezerUrlPlaylistMode(self, playlist_url, path):

        link = str(str(playlist_url).split('/')[-1]).split('?')[0]

        #get info
        playlist = self.__deezer.getPlaylist(link)

        for info, i in zip(playlist['tracks'], range(len(playlist['tracks']))):

            print(f'Downloading {i+1} of {len(playlist["tracks"])}')

            fixed_name = f'{info["artist"][0]} - {info["name"]}'
            fixed_name = fixed_name.replace('.', '')
            fixed_name = fixed_name.replace(',', '')
            fixed_name = fixed_name.replace("'", '')
            fixed_name = fixed_name.replace("/", "")

            #finding and download from YouTube and tagging
            self.__downloadMusicFromYoutube(fixed_name, info['uri'],
                                            info['duration_ms'])

            self.__editor.setTags(data=info)

            cachepath = os.getcwd() + '/cache'
            fullpath = os.getcwd() + '/Downloads'

            if not os.path.exists(fullpath):
                os.makedirs(fullpath)

            name = f'{info["artist"][0]} - {info["name"]}'

            os.rename(f"{cachepath}/{info['uri']}/{info['uri']}.mp3",
                      f"{fullpath}/{getCorrect(name)}.mp3")

            if path:

                os.rename(f"{fullpath}/{getCorrect(name)}.mp3",
                          f"{path}/{getCorrect(name)}.mp3")

            #deleting cache
            try:
                shutil.rmtree(f"cache/{info['uri']}")
            except:
                pass

            notify.send(f'{info["artist"][0]} - {info["name"]}')

    def downloadFromYoutubeMusic(self, url, info, path):

        print(info)

        uri = info['uri']

        #downloading video from youtube
        if self.__youtube.download(url=url, path=uri, filename=uri):

            #converting video to mp3 file
            self.__youtube.convertVideoToMusic(uri=uri)

            self.__editor.setTags(data=info)

            cachepath = os.getcwd() + '/cache'
            fullpath = os.getcwd() + '/Downloads'

            if not os.path.exists(fullpath):
                os.makedirs(fullpath)

            name = f'{info["artist"][0]} - {info["name"]}'

            os.rename(f"{cachepath}/{info['uri']}/{info['uri']}.mp3",
                      f"{fullpath}/{getCorrect(name)}.mp3")

            if path:

                os.rename(f"{fullpath}/{getCorrect(name)}.mp3",
                          f"{path}/{getCorrect(name)}.mp3")

            #deleting cache
            try:
                shutil.rmtree(f"cache/{info['uri']}")
            except:
                pass

            notify.send(f'{info["artist"][0]} - {info["name"]}')
            return True, info
        else:
            return False, None

    def search(self, query):
        return self.__spotify.search(query=query)
Exemple #25
0
 def start_youtube():
     for target_id in channel_id:
         y = Youtube(target_id)
         y.start()
Exemple #26
0
def answerQuery(query):
    global selectedRecipe
    answer = {'text': "", 'voice': ''}

    nlc = NLC()
    my_class = ""
    if query:
        if query.endswith('?'):
            query = query[:-1]
        my_class = nlc.classify(query)

    #possible options:

    if my_class == "current":
        #Read the current step
        answer['text'] = selectedRecipe.getCurrentDirection()
    elif my_class == "next":
        #Read the next step
        answer['text'] = selectedRecipe.goForward()
    elif my_class == "previous":
        #Read the previous step
        answer['text'] = selectedRecipe.goBack()
    elif my_class == "specific":
        #Read a specific step (query~"What was the first step?")
        words = query.split()
        index = -1
        key_words = {
            'first': 0,
            'start': 0,
            'beginning': 0,
            'second': 1,
            'third': 2,
            'fourth': 3,
            'fifth': 4,
            'sixth': 5,
            'seventh': 6,
            'eighth': 7,
            'ninth': 8,
            'tenth': 9,
            'eleventh': 10,
            'twelfth': 11,
            'last': len(selectedRecipe.directions) - 1,
            'end': len(selectedRecipe.directions) - 1,
            'finish': len(selectedRecipe.directions) - 1
        }
        for word in words:
            if word in key_words:
                index = key_words[word]

        if index > len(selectedRecipe.directions) - 1 or index < 0:
            answer['text'] = "The recipe does not have that many steps"
        else:
            answer['text'] = selectedRecipe.getSpecificDirection(index)

    elif my_class == "ingredients":
        #Find out current ingredient (query~"How much of that?")
        relaventIngredients = selectedRecipe.getIngredientFromQuery(query)
        answer['text'] = relaventIngredients.pop()['Text']
        for ing in relaventIngredients:
            answer['text'] = answer['text'] + " and " + ing['Text']

    elif my_class == "conversion":
        unitNames = [
            u.symbol for _, u in units.__dict__.items()
            if isinstance(u, type(units.deg))
        ] + [
            u for u, f in u.__dict__.items() if isinstance(f, type(units.deg))
        ]
        unitNames.extend([
            'tablespoon', 'teaspoon', 'tsp', 'tbsp', 'ounces', 'Celsius',
            'Fahrenheit', 'milliliter', 'liter'
        ])
        unitsFound = []

        for token in word_tokenize(query):
            if (token in unitNames) or (token[:-1] in unitNames):
                if (token != 'in' and token != 'do' and token != 'use'
                        and token != 'to'):
                    unitsFound.append(token)
        app.logger.info(unitsFound)
        if (len(unitsFound) == 1):
            for ing in selectedRecipe.getIngredientFromQuery(query):
                conversionQuery = "What is " + ing['Val'] + " " + ing[
                    'Unit'] + " in " + unitsFound[0]
                app.logger.info(conversionQuery)
                if answer['text']:
                    answer['text'] = answer['text'] + " and "
                answer['text'] = answer['text'] + UnitConverter.getConversion(
                    conversionQuery)
        elif (len(unitsFound) > 1):
            answer['text'] = UnitConverter.getConversion(query)
        elif (len(unitsFound) == 0):
            answer['text'] = "Sorry, I don't know how to convert that."

    elif my_class == "howto":
        answer['text'] = Youtube.getVideo(query)

    elif my_class == "temperature":
        answer['text'] = selectedRecipe.getTemperatureDirectionForQuery(query)

    elif my_class == "time":
        answer['text'] = selectedRecipe.getTimeDirectionForQuery(query)
    else:
        answer = {'text': "Sorry, I didn't get that.", 'voice': ''}

    return answer
Exemple #27
0
from youtube_s import Youtube_S
from dang_error import DangError
from helpers import get_text, get_error_text, get_config, config_files_to_env
import logging

logging.basicConfig()
logging.getLogger().setLevel(logging.INFO)

load_dotenv()
config_files_to_env()

DISCORD_TOKEN = os.getenv('DISCORD_TOKEN')

bot = commands.Bot(command_prefix=['dang! ', '!dang ', 'dang!'],
                   help_command=None)
bot.add_cog(Youtube(bot))
bot.add_cog(Youtube_S(bot))


def get_random_quote(guild):
    return choice(get_text(guild.id, "quotes"))


def magic_eight_ball(guild):
    return choice(get_text(guild.id, "magic_eight_ball"))


def should_send_random_message(guild=None):
    freq = get_config(guild.id, "spam_freq")
    if (freq <= 0):
        return False
class RecordVideo:
    logger = logging.getLogger(__name__)

    def __init__(self, record, cfg):
        self.record = record
        self.config = cfg
        self.video_dir = os.path.join(self.config.video_dir, self.id(), "")
        if not os.path.exists(self.video_dir):
            os.makedirs(self.video_dir)
        self.video_path = os.path.join(self.video_dir, "video.mp4")
        self.audio_dir = os.path.join(self.config.audio_dir, self.id(), "")
        if not os.path.exists(self.audio_dir):
            os.makedirs(self.audio_dir)
        self.audio_path = os.path.join(self.audio_dir, "audio.mp3")

        self.dictionary = dict()
        index = 0
        for column in record:
            self.dictionary["{{Column" + chr(index + 65) + "}}"] = self.get_column(chr(index + 65))
            index += 1
        if self.config.bitly:
            self.dictionary["{{ColumnD_bitly}}"] = util.bitly_shorten(self.get_column("D"))["url"]
        else:
            self.dictionary["{{ColumnD_bitly}}"] = self.get_column("D")["url"]

    def id(self):
        return self.get_column("B")

    def get_column(self, letter):
        return self.record[ord(letter) - 65]

    def get_images(self):
        self.img_dir = os.path.join(self.config.img_dir, self.get_column("B"))
        if not os.path.exists(self.img_dir):
            os.makedirs(self.img_dir)
        self.img_paths = []
        index = 0
        for url in self.get_column("I").split(","):
            img_name = url.rsplit("/", 1)[-1]
            # path = os.path.join(self.record_path, str(index).zfill(3) + ".jpg")
            path = os.path.join(self.img_dir, img_name)

            if not self.config.cache_img or not os.path.exists(path):
                util.download_url(url, path)
                time.sleep(1)
            if os.stat(path).st_size > 0:
                self.img_paths.append(path)
            else:
                self.logger.warn("Removed file: " + path + " from url: " + url)
                os.remove(path)
            index += 1

    def create(self):
        self.write_text_files()
        if self.config.cache_video and os.path.exists(self.video_path):
            return

        self.get_images()
        self.fix_images()

        if self.config.use_audio and not os.path.exists(self.audio_path) or not self.config.cache_audio:
            util.from_text_to_speech(self.get_column("J"), self.audio_path)

        if self.config.use_audio:
            audio_length = util.get_audio_length(self.audio_path)
        else:
            audio_length = 45.0

        args3 = ["ffmpeg", "-y", "-t", str(audio_length)]
        index = 0
        # max_ = max(len(self.img_paths), audio_length / 5.0)
        max_ = len(self.img_paths)
        min_ = 0
        for path in self.img_paths:
            if index >= min_ and index < max_:
                args3.extend(["-loop", "1", "-t", "2.5", "-i", path])
            index += 1
        if self.config.use_audio:
            args3.extend(["-i", self.audio_path])

        args3.extend(["-filter_complex"])

        filter = ""
        index = 0
        outputs = ""
        for path in self.img_paths:
            if index >= min_ and index < max_ - 1:
                real_index = index - min_
                i = str(real_index)
                i2 = str(real_index + 1)
                filter += (
                    "["
                    + i2
                    + ":v]["
                    + i
                    + ":v]blend=all_expr='A*(if(gte(T,0.5),1,T/0.5))+B*(1-(if(gte(T,0.5),1,T/0.5)))'[b"
                    + i2
                    + "v];\n"
                )
                outputs += "[" + i + ":v][b" + i2 + "v]"
            index += 1

        c = str((real_index + 1) * 2 + 1)
        i = str(real_index + 1)
        filter += outputs + "[" + i + ":" + "v]concat=n=" + c + ":v=1:a=0,format=yuvj422p,"

        text = util.apply_text(
            self.get_column("A"),
            self.config.font_file_avenir_black,
            36,
            color="black",
            movement_x="151",
            movement_y="51",
        )
        text += "," + util.apply_text(
            self.get_column("A"),
            self.config.font_file_avenir_black,
            36,
            color="white",
            movement_x="150",
            movement_y="50",
        )
        filter += "" + text
        filter += "[v]"

        args3.append(filter)
        args3.extend(["-map", "[v]"])
        if self.config.use_audio:
            args3.extend(["-map", str(max_) + ":0"])
        args3.extend(["-t", str(audio_length), self.video_path])
        if util.run_args(args3) != 0:
            self.logger.warn("Video creation failed!")
            if os.path.exists(self.video_path):
                os.remove(self.video_path)

    def fix_images(self):
        self.logger.debug("Fixing images.")
        util.run_args(
            ["mogrify", "-sampling-factor", "2x2,1x1,1x1", "-resample", "300x300", "-resize", "1024x768!", "*.jpg"],
            cwd=self.img_dir,
        )

    def write_text_files(self):
        title = util.template(self.config.youtube_title, self.dictionary)
        description = util.template(self.config.youtube_description, self.dictionary)
        util.text_to_file(title, os.path.join(self.video_dir, "title.txt"))
        util.text_to_file(description, os.path.join(self.video_dir, "description.txt"))

    def get_csv_row(self):
        row = [
            util.template(self.config.youtube_title, self.dictionary),
            util.template("{{ColumnA}}", self.dictionary),
            util.template(self.config.youtube_description, self.dictionary),
            u"Travel",
            self.video_path,
        ]
        row2 = []
        for r in row:
            row2.append(r.replace('"', '\\"').replace("\n", " ").replace("\r", " "))
        return row2

    def upload(self):
        self.youtube = Youtube()
        title = util.template(self.config.youtube_title, self.dictionary)
        description = util.template(self.config.youtube_description, self.dictionary)
        category_id = self.config.youtube_category_id
        tags = []
        upload_result = self.youtube.initialize_upload(title, description, self.video_path, category_id, tags)
        self.youtube_videoid = upload_result["id"]

        return upload_result["id"]
Exemple #29
0
 def __init__(self):
     self.items = []
     self.wiki = Wiki()
     self.youtube = Youtube()
     self.path = os.getcwd()
     self.s = schedule.every().saturday.do(self.job)
Exemple #30
0
class Scheduler:
    def callThread(self, onExit, popenArgs):
        def runInThread(onExit, popenArgs):
            proc = subprocess.call(popenArgs)
            #proc.wait()
            onExit()
            return

        thread = threading.Thread(target=runInThread, args=(onExit, popenArgs))
        thread.start()
        return thread

    def job(self):
        print "executing job"

        def onExit():
            compress_file = "medicamentos_vademecum_out.tar.gz"
            listOut = os.listdir("./vademecum/resultsMedicamentos/")
            compress(listOut, "./vademecum/resultsMedicamentos/",
                     "../out/" + compress_file)
            shutil.rmtree("./vademecum/resultsMedicamentos/")

        self.callThread(onExit,
                        ["scrapy", "runspider", "vademecum/medicamentos.py"])

    def __init__(self):
        self.items = []
        self.wiki = Wiki()
        self.youtube = Youtube()
        self.path = os.getcwd()
        self.s = schedule.every().saturday.do(self.job)

    def splitPath(self, petition):
        names = petition.split("/")
        names = names[len(names) - 1].split(".")
        return names

    def remove_files(self, petition):
        with open(petition) as f:
            elem = f.readlines()
        for e in elem:
            if os.path.isfile("../out/" + e.strip()):
                os.remove("../out/" + e.strip())
        os.remove(petition)

    def enqueue(self, x):
        print schedule.jobs
        print "enqueue petition"
        #schedule.run_pending()
        name = self.splitPath(x)[0]
        if (name == "remove"):
            print "remove"
            print x
            self.remove_files(x)
        else:
            splitPetition = name.split("_")
            typePetition = splitPetition[len(splitPetition) - 1]
            self.insertOrderListPetition(priority[typePetition], x)

    def dequeue(self):
        try:
            return self.items.pop(0)
        except:
            raise ValueError("there are no petitions!")

    def isEmpty(self):
        return self.items == []

    def process(self, p=None):
        petition = self.dequeue() if p is None else p
        names = self.splitPath(petition)
        try:
            list = decompress(names[0], petition)
        except OSError as osE:
            print "error with a file"
            os.chdir(self.path)
            shutil.rmtree("../out/" + names[0])
            self.process(petition)
        listOut = []
        os.mkdir(list['dir'] + "/result/")
        try:
            for l in list['listDir']:
                if names[0].split("_")[1] == "wiki":
                    params = self.wiki.search(l, names[0],
                                              list['dir'] + "/result/")
                    if params and len(params) > 0:
                        for d in params:
                            listOut.append(d)
                        compress_file = names[0] + "_out.tar.gz"
                        compress(listOut, list['dir'] + "/result/",
                                 list['dir'] + "/../" + compress_file)
                elif names[0].split("_")[1] == "youtube":
                    self.youtube.search(l, names[0], list['dir'] + "/result/",
                                        names[0])
        except OSError as osE:
            print osE
            print "error with a file"
            os.chdir(self.path)
            shutil.rmtree(list['dir'])
        except Exception as eEx:
            print eEx
            os.chdir(self.path)
            shutil.rmtree(list['dir'])
            time.sleep(15)
            self.process(petition)
        except e:
            print e
            print "cannot get resources, check internet connection!"
            os.chdir(self.path)
            shutil.rmtree(list['dir'])
            time.sleep(15)
            self.process(petition)
        print "remove"
        print petition
        print os.getcwd()
        os.remove(petition)
        os.chdir(self.path)

    def insertOrderListPetition(self, num, petition):
        i = 0
        #NO FUNCIONA:
        if (len(self.items) > 0):
            name = self.splitPath(self.items[i])[0]
            splitPetition = name.split("_")
            typePetition = splitPetition[len(splitPetition) - 1]
            numType = priority[typePetition]
            i += 1
            while i < len(self.items) and numType <= num:
                name = self.splitPath(self.items[i])[0]
                splitPetition = name.split("_")
                typePetition = splitPetition[len(splitPetition) - 1]
                numType = priority[typePetition]
                i += 1

            lenA = len(self.items)
            for j, val in self.items:
                self.items.insert(lenA - j, self.items[lenA - j - 1])
        self.items.insert(i, petition)
Exemple #31
0
from exalead import Exalead
from quora import Quora
from youtube import Youtube
from parsijoo import Parsijoo

scrapers = {
    'g': Google(),
    'b': Bing(),
    'y': Yahoo(),
    'd': Duckduckgo(),
    'a': Ask(),
    'yd': Yandex(),
    'u': Baidu(),
    'e': Exalead(),
    'q': Quora(),
    't': Youtube(),
    'p': Parsijoo()
}


def read_in():
    lines = sys.stdin.readlines()
    return json.loads(lines[0])


def small_test():
    assert isinstance(scrapers.google.results_search('fossasia'), list)


def feedgen(query, engine, count=10):
    if engine in ['q', 't']:
Exemple #32
0
    data = json.load(user_id_file)
    user_id = data["username"]
    print(user_id)
    if (user_id == ""):
        mqtt_thred_to_get_userid = threading.Thread(
            target=mqttclient_to_get_userid)
        mqtt_thred_to_get_userid.daemon = True
        mqtt_thred_to_get_userid.start()
    else:
        TTS("Welcome back " + user_id)
'''this loop checks whether the username had been passed or not.'''
'''if new username is passed it is written onto disk'''
while (True):
    if (len(user_id) > 0):
        with open(os.path.join(sys.path[0], "assets/user_id.json"),
                  'r+') as user_id_file:
            data = {"username": user_id}
            user_id_file.seek(0)
            json.dump(data, user_id_file)
            user_id_file.truncate()
        break
youtube_instance = Youtube()
'''calling the main message thread from here'''
mqtt_thred = threading.Thread(target=mqttclient)
mqtt_thred.daemon = True
mqtt_thred.start()

while (True):
    if active == False:
        print("Exiting main thread")
        sys.exit()
from youtube import Youtube
s1omething = Youtube()
s1omething.youtube_subscriptions()