def get_streams(): streams = {} ClientID = 'g3v9rj6v0t5cuthn57g3s9sd1sngmz' width = 640 height = 360 helix = twitch.Helix(ClientID) for user in helix.users(usernames): try: user.stream.type except twitch.helix.resources.streams.StreamNotFound: print('None') continue print(user.stream.data) if res['data'] != []: stream_id = res['data'][0]['id'] streams[stream_id] = {} streams[stream_id]['username'] = user streams[stream_id]['url'] = 'https://www.twitch.tv/' + user streams[stream_id]['game'] = res['data'][0]['user_name'] streams[stream_id]['status'] = res['data'][0]['title'] streams[stream_id]['preview_l'] = res['data'][0]['thumbnail_url'] streams[stream_id]['preview_l'] = streams[stream_id][ 'preview_l'].replace('{width}', '640') streams[stream_id]['preview_l'] = streams[stream_id][ 'preview_l'].replace('{height}', '360') print(streams[stream_id]['preview_l'.format(width, height)])
def test_video(self): responses.add( responses.GET, 'https://api.twitch.tv/helix/videos?id=471855782', match_querystring=True, json={ 'data': [{ 'id': '471855782', 'user_id': '26301881', 'user_name': 'sodapoppin', 'title': '2 days til Classic, passing the time til then. ', 'description': '', 'created_at': '2019-08-24T21:34:03Z', 'published_at': '2019-08-24T21:34:03Z', 'url': 'https://www.twitch.tv/videos/471855782', 'thumbnail_url': '', 'viewable': 'public', 'view_count': 329, 'language': 'en', 'type': 'archive', 'duration': '2h14m55s' }], 'pagination': { 'cursor': 'eyJiIjpudWxsLCJhIjp7Ik9mZnNldCI6MX19' } }) helix = twitch.Helix('client-id', use_cache=True) # Get display name to display name self.assertEqual(helix.video('471855782').user_name, 'sodapoppin')
def __init__(self, video_id: str = None): # Check if data should be loaded from an input file or form the Twitch API if app.cli.arguments.input: if Path(app.cli.arguments.input).is_file(): with open(app.cli.arguments.input, 'r', encoding='utf-8') as file: json_data = json.load(file) # Check if JSON format is valid if 'video' not in json_data or 'comments' not in json_data: print('Error: Invalid JSON file.') exit(1) # Set metadata and comments self.metadata = json_data['video'] self.comments = Video.comment_generator( json_data['comments']) if app.cli.arguments.verbose: print('Loaded json data form input file') else: print('Error: Unable to find {}'.format( app.cli.arguments.input)) exit(1) else: # Download from Twitch API helix = twitch.Helix(client_id=app.config.settings['client_id'], use_cache=True) video: helix.Video = helix.video(video_id) self.metadata: dict = api.video(video_id) self.comments = self.comment_generator_from_api(video)
def test_user(self): helix = twitch.Helix(client_id='id', bearer_token='token', use_cache=True) # Get display name to display name self.assertEqual(helix.user('zarlach').display_name, 'Zarlach')
def refreshToken(self): cfg = configparser.ConfigParser() cfg.read("config/config.ini") settings = cfg["settings"] client_id = settings["client_id"] secret = settings["secret"] if not client_id or not secret: print("Unable to find credentials") else: try: authorizeRequest = requests.post(self._oauthURL + "token", params={ "client_id": client_id, "client_secret": secret, "grant_type": "client_credentials" }, timeout=2) if (authorizeRequest.status_code == requests.codes.ok): response = json.loads(authorizeRequest.text) self._accessToken = response["access_token"] self._helix = twitch.Helix(client_id, secret, True, None, True, self._accessToken) else: print("Unable to complete post request for token") except requests.exceptions.Timeout: print("Request for refresh token timed out")
def create_client(twitch_id=os.environ['twitch_id'], twitch_secret=os.environ['twitch_secret']): client = twitch.Helix(client_id=twitch_id, client_secret=twitch_secret, use_cache=True, cache_duration=timedelta(minutes=30)) return client
def test_custom_user_cache(self): helix = twitch.Helix('client-id', use_cache=True) helix.users(['zarlach', 'sodapoppin']) # Users have custom caching, such that url should not be cached self.assertFalse( helix.api.SHARED_CACHE.has( 'GET:https://api.twitch.tv/helix/users?login=zarlach')) # Cache entries by login name and id number self.assertTrue( helix.api.SHARED_CACHE.has('helix.users.login.zarlach')) self.assertTrue(helix.api.SHARED_CACHE.has('helix.users.id.24250859')) self.assertTrue( helix.api.SHARED_CACHE.has('helix.users.login.sodapoppin')) self.assertTrue(helix.api.SHARED_CACHE.has('helix.users.id.26301881')) # Flush cache to remove helix.api.flush_cache() # Check cache flush self.assertFalse( helix.api.SHARED_CACHE.has('helix.users.login.zarlach')) self.assertFalse(helix.api.SHARED_CACHE.has('helix.users.id.24250859')) self.assertFalse( helix.api.SHARED_CACHE.has('helix.users.login.sodapoppin')) self.assertFalse(helix.api.SHARED_CACHE.has('helix.users.id.26301881'))
def run(self): try: helix = twitch.Helix(self.twitch_id) vod = helix.video(self.vod_num) if vod is None: self.status = 'error' return start = datetime.datetime.strptime(vod.created_at[:19], '%Y-%m-%dT%H:%M:%S') duration = self.str2sec(vod.duration) file_name = './static/download/' + self.vod_num with open(file_name + '.tmp', 'w', encoding='utf8') as f: f.write('comment_time' + '\n') for comment in vod.comments: comment_time = datetime.datetime.strptime( comment.updated_at[:19], '%Y-%m-%dT%H:%M:%S') comment_sec = int((comment_time - start).total_seconds()) f.write(str(comment_sec) + '\n') with lock: self.progress = round(comment_sec / duration * 100, 2) os.rename(file_name + '.tmp', file_name + '.csv') self.status = 'complete' return # 기타 error가 발생한 경우 except Exception as ex: print('Downloader ERROR') print(ex) self.status = 'error' return
def main(): helix = twitch.Helix('', use_cache=True) global lastmsg, msg lastmsg = datetime.datetime.now() msg = queue.Queue(100) sess = gpt2.start_tf_sess() gpt2.load_gpt2(sess, run_name=run_name) while not msg.full(): newmsg = genmsg(sess) print(newmsg) msg.put(newmsg) for channel in textchannels: chat = twitch.Chat(channel="#" + channel, nickname='WoodenLongboard', oauth="", helix=helix) chats[channel] = chat chats[channel].subscribe(handle_message) print("Finished init") while True: if not msg.full(): msg.put(genmsg(sess))
async def task_check_live_status(bot): """ Checks if the best streamers are live on Twitch every few seconds This will be executed every 30 seconds -- bot: interactions.Client """ print("checking live status") if "twitch_channel" in db.keys(): helix = twitch.Helix(Constants.TWITCH_ID, Constants.TWITCH_SECRET) for streamer_name in Constants.STREAMERS: stream = get_live_status(streamer_name, helix=helix) if stream is not None: if streamer_name not in db["is_currently_live"].keys( ) or streamer_name not in db[ "previous_live_message_time"].keys(): db["is_currently_live"][streamer_name] = False db["previous_live_message_time"][streamer_name] = 0 if not db["is_currently_live"][streamer_name]: db["is_currently_live"][streamer_name] = True await send_new_live_message(bot, stream, streamer_name) else: db["is_currently_live"][streamer_name] = False
def test_video(self): helix = twitch.Helix(client_id='id', bearer_token='token', use_cache=True) # Get display name to display name self.assertEqual(helix.video('471855782').user_name, 'sodapoppin')
def test_users(self): # Should returned cached data from above helix = twitch.Helix('client-id', use_cache=True) for user, display_name in zip(helix.users([24250859, 'sodapoppin']), ['Zarlach', 'sodapoppin']): self.assertEqual(user.display_name, display_name)
def test_cache(self): helix = twitch.Helix('client-id', use_cache=True) helix.api.SHARED_CACHE.set('key', {'data': 'value'}) # Entry in shared cache self.assertTrue(helix.api.SHARED_CACHE.has('key')) # Not expired self.assertFalse(helix.api.SHARED_CACHE.expired('key')) # Expiration helix.api.SHARED_CACHE.set('key-with-expiration', {'data': 'value'}, duration=timedelta(seconds=-1)) # Key is expired self.assertTrue(helix.api.SHARED_CACHE.expired('key-with-expiration')) # Unable to retrieve expired value self.assertFalse(helix.api.SHARED_CACHE.get('key-with-expiration')) # Has key, but expired self.assertTrue(helix.api.SHARED_CACHE.has('key-with-expiration')) # Clean expired keys helix.api.SHARED_CACHE.clean() self.assertFalse(helix.api.SHARED_CACHE.has('key-with-expiration')) # Flush cache helix.api.SHARED_CACHE.flush() self.assertFalse(helix.api.SHARED_CACHE.has('key'))
def test_user(self): responses.add( responses.GET, 'https://api.twitch.tv/helix/users?login=zarlach', match_querystring=True, json={ 'data': [{ 'id': '24250859', 'login': '******', 'display_name': 'Zarlach', 'type': '', 'broadcaster_type': '', 'description': '', 'profile_image_url': 'https://static-cdn.jtvnw.net/jtv_user_pictures/zarlach-profile_image-1cb98e7eadb5918a-300x300.png', 'offline_image_url': 'https://static-cdn.jtvnw.net/jtv_user_pictures/zarlach-channel_offline_image-f2d036ac9582d793-1920x1080.png', 'view_count': 1664 }] }) helix = twitch.Helix('client-id', use_cache=True) # Get display name to display name self.assertEqual(helix.user('zarlach').display_name, 'Zarlach')
def __init__(self, client_id=None): self._client_id = client_id or settings.TWITCH_CLIENT_ID self.client = twitch.Helix(self._client_id, use_cache=True, cache_duration=timedelta(minutes=30)) self.channel = self.client.user("overwatchleague") self.videos = self.filter_by_full_matches( self.get_channel_videos(type="highlight"))
def test_first_videos(self): # Should returned cached data from above helix = twitch.Helix('client-id', use_cache=True) for video, user_name in zip( helix.user('sodapoppin').videos(first=2), ['sodapoppin', 'sodapoppin']): self.assertEqual(video.user_name, user_name)
def __init__(self, channel): self.chat = twitch.Chat(channel=channel, nickname='bot', oauth='oauth:la6kj4pn3vzfdvvkfrg8y5eqvbuxjk', helix=twitch.Helix( client_id='hqiwd4o8a3mf6l7t7l0xge8qt7ksob', use_cache=True)) self.chat.subscribe(handle_message)
def twitchLive(): import twitch helix = twitch.Helix(client_id=Config.TWITCH_CLIENT_ID, use_cache=True, bearer_token=Config.TWITCH_BEARER_TOKEN) twitch.Chat(channel=Config.TWITCH_CHANNEL, nickname=Config.TWITCH_NICKNAME, oauth=Config.TWITCH_OAUTH_TOKEN).subscribe( lambda message: twitchChat(message, helix))
def get_twitch(self, user): twitch_id = self.bot.config.data.get("config").get("TWITCH_CLIENT_ID") helix = twitch.Helix(twitch_id) live_flag = False try: helix.user(user).stream().type live_flag = True except twitch.helix.streams.StreamNotFound: live_flag = False return live_flag
def assign_core(self, core): if not self.enabled: return False super().assign_core(core) self.helix = twitch.Helix('jqqxdo6tewc80vot6w66mkzfnso558', '7tsxcnw9efuxbjk3q2r8ebdx54k01c') self.chat = twitch.Chat(channel='#cheeseypi', nickname='cheeseyquichebot', oauth='oauth:948piogkdqxbti42c8pwu0grd5zily', helix=self.helix) self.chat.subscribe((lambda message: self.receivedMessage(message))) return True
def get_vod_info(vod_num, twitch_id='9k8fhtcsrjfgip3v1jrs1ut33yzs7c'): try: helix = twitch.Helix(twitch_id) vod = helix.video(vod_num) # 유효한 vod가 아닌 경우 if vod is None: return '' return vod.user_name + ': ' + vod.title except: return ''
def __init__(self, channel):#api:webhook.api): self.channel = channel # self.api = api # self._id = self.api.user_id(channel) #la6kj4pn3vzfdvvkfrg8y5eqvbuxjk qxhcdwsgg5m3qm7or17f3lo51soznk # self.api.sub_streamchange(self._id) self.helix=twitch.Helix(client_id='hqiwd4o8a3mf6l7t7l0xge8qt7ksob', use_cache=True) self.chat = twitch.Chat(channel=channel, nickname='bot', oauth='oauth:la6kj4pn3vzfdvvkfrg8y5eqvbuxjk', helix=self.helix) self.buf = []
async def twitch(self, ctx, user="******"): twitch_id = self.bot.config.data.get("config").get("TWITCH_CLIENT_ID") helix = twitch.Helix(twitch_id) try: await ctx.send(helix.user(user).stream().type) game_id = helix.user(user).stream().game_id title = helix.user(user).stream().title test = helix.game(id=game_id) await ctx.send(f"<https://twitch.tv/{user}>") await ctx.send(f"Title: {title}") await ctx.send(f"Streaming: {test.name}") except twitch.helix.streams.StreamNotFound: await ctx.send("Not Live")
def test_download(self): httpretty.register_uri( method=httpretty.GET, uri='https://api.twitch.tv/helix/users?login=zarlach', match_querystring=True, body=json.dumps({ 'data': [{ 'id': '24250859', 'login': '******', 'display_name': 'Zarlach', 'type': '', 'broadcaster_type': '', 'description': '', 'profile_image_url': 'https://static-cdn.jtvnw.net/jtv_user_pictures/zarlach-profile_image-1cb98e7eadb5918a-300x300.png', 'offline_image_url': 'https://static-cdn.jtvnw.net/jtv_user_pictures/zarlach-channel_offline_image-f2d036ac9582d793-1920x1080.png', 'view_count': 1664 }] })) httpretty.register_uri( method=httpretty.GET, uri='https://api.twitch.tv/helix/users?login=sodapoppin', match_querystring=True, body=json.dumps({ 'data': [{ 'id': '26301881', 'login': '******', 'display_name': 'sodapoppin', 'type': '', 'broadcaster_type': 'partner', 'description': 'Wtf do i write here? Click my stream, or i scream.', 'profile_image_url': 'https://static-cdn.jtvnw.net/jtv_user_pictures/sodapoppin-profile_image-10049b6200f90c14-300x300.png', 'offline_image_url': 'https://static-cdn.jtvnw.net/jtv_user_pictures/7ed72b04-897e-4a85-a3c9-2a8ba74aeaa7-channel_offline_image-1920x1080.jpg', 'view_count': 276164750 }] })) helix = twitch.Helix('client-id', use_cache=True) # Login to display name self.assertEqual(helix.user('zarlach').display_name, 'Zarlach') # Should returned cached data from above for user, display_name in zip(helix.users(24250859, 'sodapoppin'), ['Zarlach', 'sodapoppin']): self.assertEqual(user.display_name, display_name)
def test_custom_cache(self): httpretty.register_uri( method=httpretty.GET, uri='https://api.twitch.tv/helix/users?login=sodapoppin&login=zarlach', match_querystring=True, body=json.dumps({ 'data': [{'id': '24250859', 'login': '******', 'display_name': 'Zarlach', 'type': '', 'broadcaster_type': '', 'description': '', 'profile_image_url': 'https://static-cdn.jtvnw.net/jtv_user_pictures/zarlach-profile_image-1cb98e7eadb5918a-300x300.png', 'offline_image_url': 'https://static-cdn.jtvnw.net/jtv_user_pictures/zarlach-channel_offline_image-f2d036ac9582d793-1920x1080.png', 'view_count': 1664}, {'id': '26301881', 'login': '******', 'display_name': 'sodapoppin', 'type': '', 'broadcaster_type': 'partner', 'description': 'Wtf do i write here? Click my stream, or i scream.', 'profile_image_url': 'https://static-cdn.jtvnw.net/jtv_user_pictures/sodapoppin-profile_image-10049b6200f90c14-300x300.png', 'offline_image_url': 'https://static-cdn.jtvnw.net/jtv_user_pictures/7ed72b04-897e-4a85-a3c9-2a8ba74aeaa7-channel_offline_image-1920x1080.jpg', 'view_count': 276164750}] }) ) helix = twitch.Helix('client-id', use_cache=True) helix.users('zarlach', 'sodapoppin') # Users have custom caching, such that url should not be cached self.assertFalse(helix.api.SHARED_CACHE.has('GET:https://api.twitch.tv/helix/users?login=zarlach')) # Cache entries by login name and id number self.assertTrue(helix.api.SHARED_CACHE.has('helix.users.login.zarlach')) self.assertTrue(helix.api.SHARED_CACHE.has('helix.users.id.24250859')) self.assertTrue(helix.api.SHARED_CACHE.has('helix.users.login.sodapoppin')) self.assertTrue(helix.api.SHARED_CACHE.has('helix.users.id.26301881')) # Flush cache to remove helix.api.flush_cache() # Check cache flush self.assertFalse(helix.api.SHARED_CACHE.has('helix.users.login.zarlach')) self.assertFalse(helix.api.SHARED_CACHE.has('helix.users.id.24250859')) self.assertFalse(helix.api.SHARED_CACHE.has('helix.users.login.sodapoppin')) self.assertFalse(helix.api.SHARED_CACHE.has('helix.users.id.26301881'))
def main(): # pdb.set_trace() chat = twitch.Chat( channel='isaiahmonday', # adjust this for your channel name nickname='bot', # awd contains an oauth key which is not shared publicly. Create your own awd.txt file oauth=open("awd.txt").read(), # adjust this for your client ID helix=twitch.Helix(client_id='lmpf9a1btnphwvvy879gqly1voc4ak', use_cache=True)) chat.subscribe(handle_message) app.run()
def start(self): for _, channel in utils.getChannels(): self.active_chats[channel] = twitch.Chat( channel='#{}'.format(channel), nickname=config.BOT_NAME, oauth=config.OAUTH_TOKEN, helix=twitch.Helix(client_id=config.CLIENT_ID, use_cache=True)) self.active_chats[channel].subscribe(self.messageHandler) events = utils.getEvents(channel) glob.events[channel] = eventHandler.MessagePoster( chat=self.active_chats[channel]) for message, interval in events: glob.events[channel].addEvent(message, interval) logging.info("JOINED #{}".format(channel)) logging.info("Succesfully started")
def test_custom_video_cache(self): helix = twitch.Helix('client-id', use_cache=True) _ = helix.video(471855782) # Videos have custom caching, such that url should not be cached self.assertFalse( helix.api.SHARED_CACHE.has( 'GET:https://api.twitch.tv/helix/videos?id=471855782')) # Cache entries by video id self.assertTrue(helix.api.SHARED_CACHE.has('helix.video.471855782')) # Flush cache to remove helix.api.flush_cache() # Check cache flush (cache should be empty) self.assertFalse(helix.api.SHARED_CACHE.has('helix.video.471855782'))
def main(): if len(sys.argv) < 2 or len(sys.argv) > 3: usage() sys.exit() client_id = sys.argv[1] browser = 'google-chrome' if len(sys.argv) == 3: browser = sys.argv[2] DROPSENABLED_TAGID = "c2542d6d-cd10-4532-919b-3d19f30a768b" while True: stream_to_watch = "" stream_to_watch_id = -1 # Find a drops-enabled Valorant stream helix = twitch.Helix(client_id=client_id) for stream in helix.streams(game_id=516575): if DROPSENABLED_TAGID in stream.data['tag_ids']: # subprocess.check_call(['google-chrome', 'https://twitch.tv/' + stream.data['user_name']]) stream_to_watch = stream.data['user_name'] stream_to_watch_id = stream.data['user_id'] print("gonna watch " + stream_to_watch) webbrowser.get(browser).open('https://twitch.tv/' + stream.data['user_name']) # os.system("google-chrome " + "https://twitch.tv/" + stream.data['user_name']) break print("watching " + stream_to_watch) # Watch the stream until it isnt live if stream_to_watch != "": live = True while live: print(stream_to_watch + " still live") # Heartbeat every 20 seconds to check that its live try: b = helix.streams(user_id=stream_to_watch_id) except StreamNotFound: break if len(b._data) >= 1: live = b._data[0].type == "live" else: live = False time.sleep(20) os.system("pkill chrome")
def __init__(self): self.helix_api = twitch.Helix(client_id=Settings().config['client_id'], use_cache=True) self.formats: List[str] = [] self.whitelist: List[str] = [] self.blacklist: List[str] = [] # Populate format list according to whitelist and blacklist if 'all' in Arguments().formats and 'all' in Settings().config['formats']: self.blacklist = Settings().config['formats']['all']['whitelist'] or [] self.whitelist = Settings().config['formats']['all']['blacklist'] or [] # Append formats to list if they can be used self.formats = [format_name for format_name in Settings().config['formats'].keys() if self._can_use_format(format_name)] else: self.formats = [format_name for format_name in Arguments().formats if self._can_use_format(format_name)]