def test_get_streams_raises_attribute_exception_for_invalid_params(param, value):
responses.add(responses.GET,
'{}streams'.format(BASE_HELIX_URL),
body=json.dumps(example_get_streams_response),
status=200,
content_type='application/json')
client = TwitchHelix('client id')
kwargs = {param: value}
with pytest.raises(TwitchAttributeException):
client.get_streams(**kwargs)
assert len(responses.calls) == 0
def twitch_chat_metadata_scraper(channel_name):
print('getting metadata for channel: ' + channel_name + '\n')
log_path = '../chat_log_data/'
log_file_name = log_path + channel_name + '_stream_metadata.txt'
client = TwitchHelix(client_id=os.environ.get('TWITCH_CLIENT_KEY'))
f = open(log_file_name, "a+")
f.close()
#writes to time and data to file
import time
starttime = time.time()
import datetime
while True:
#gets current channel metadata
streams_iterator = client.get_streams(user_logins=channel_name)
stream_data = streams_iterator.next()
#gets current datetime
now = str(datetime.datetime.now().isoformat())
#prints current time output
# print ("tick- ",now)
#writes time and channel metadata to file
data = str(now + str(stream_data) + "\n")
f = open(log_file_name, "a+")
f.write(data)
print(data)
f.close()
time.sleep(60.0 - ((time.time() - starttime) % 60.0))
def test_get_streams_returns_api_cursor():
responses.add(responses.GET,
'{}streams'.format(BASE_HELIX_URL),
body=json.dumps(example_get_streams_response),
status=200,
content_type='application/json')
client = TwitchHelix('client id')
streams = client.get_streams()
assert len(responses.calls) == 1
assert isinstance(streams, APICursor)
def getGameName(ctx, c_id, c_secret, channel):
"""
Returns a string containing the current game being played by the streamer
"""
client = TwitchHelix(client_id=c_id, client_secret=c_secret)
client.get_oauth()
game_name = ''
try:
stream = client.get_streams(user_logins=channel)._queue[0]
game_id = stream["game_id"]
game_info = client.get_games(game_ids=game_id)
game_name = game_info[0]["name"]
except Exception as E:
print('Game info not available')
return game_name
class Twitch:
"""Twitch enables interaction with the twitch.tv API to get info on
Heroes of the Storm streams."""
def __init__(self):
self._client = TwitchHelix(
client_id=os.environ["TWITCH_CLIENT_ID"],
client_secret=os.environ["TWITCH_CLIENT_SECRET"],
)
self._client.get_oauth()
# TODO: doesn't use pagination, limited to 100 streams by twitch
def _get_streams(self):
games = self._client.get_games(names=["Heroes of the Storm"])
game_id = games[0]["id"]
return self._client.get_streams(game_ids=[game_id], page_size=100)
def _format_stream(self, stream):
"""Takes a stream dict as found in API responses and formats it
for the sidebar."""
display_name = stream["user_name"].strip()
status = stream["title"].strip()
viewers = str(stream["viewer_count"])
url = "https://www.twitch.tv/{}".format(stream["user_login"])
return "* [{0} ~~{1}~~ ^{2}]({3})\n\n".format(
display_name,
status,
viewers,
url)
# TODO: omg get this outta here
def sidebar_text(self):
streams = self._get_streams()
# Choose top five streams
top_streams_formatted = [self._format_stream(s) for s in streams[:5]]
top_streams_text = "".join(top_streams_formatted)
# Choose five randomly chosen streams
random_streams = random.sample(streams[5:], 5)
random_streams_formatted = [self._format_stream(s) for s in random_streams]
random_streams_text = "".join(random_streams_formatted)
return "Top\n\n{0}\nDiscover\n\n{1}".format(
top_streams_text,
random_streams_text)
def get_uptime():
"""
Returns a string of the current uptime
Returns:
str: Contains the current amount of uptime for the channel
"""
# Set up twitch API call and get stream info
client = TwitchHelix(client_id=settings.get_client_id(),
client_secret=settings.get_client_secret())
client.get_oauth()
stream = client.get_streams(user_logins=settings.get_channel())._queue[0]
# Get stream start time (API sends UTC time) and calculate uptime
start_time = stream["started_at"]
uptime = datetime.utcnow() - start_time
return str(uptime).split(".")[0]
def test_get_streams_passes_all_params_to_request():
responses.add(
responses.GET,
"{}streams".format(BASE_HELIX_URL),
body=json.dumps(example_get_streams_response),
status=200,
content_type="application/json",
)
client = TwitchHelix("client id")
streams = client.get_streams(
after="eyJiIjpudWxsLCJhIjp7Ik9mZnNldCI6MjB9fQ==",
before="eyJiIjp7Ik9mZnNldCI6MH0sImEiOnsiT2Zmc2V0Ijo0MH19==",
community_ids=[
"848d95be-90b3-44a5-b143-6e373754c382",
"fd0eab99-832a-4d7e-8cc0-04d73deb2e54",
],
page_size=100,
game_ids=["417752", "29307"],
languages=["en"],
user_ids=["23161357"],
user_logins=["lirik"],
)
stream = streams.next()
assert len(responses.calls) == 1
assert isinstance(streams, APICursor)
assert isinstance(stream, Stream)
url = responses.calls[0].request.url
assert url.startswith("https://api.twitch.tv/helix/streams?")
assert "after=eyJiIjpudWxsLCJhIjp7Ik9mZnNldCI6MjB9fQ%3D%3D" in url
assert "before=eyJiIjp7Ik9mZnNldCI6MH0sImEiOnsiT2Zmc2V0Ijo0MH19%3D%3D" in url
assert "community_id=848d95be-90b3-44a5-b143-6e373754c382" in url
assert "community_id=fd0eab99-832a-4d7e-8cc0-04d73deb2e54" in url
assert "first=100" in url
assert "game_id=417752" in url
assert "game_id=29307" in url
assert "language=en" in url
assert "user_id=23161357" in url
assert "user_login=lirik" in url
def test_get_streams_next_returns_stream_object():
responses.add(responses.GET,
'{}streams'.format(BASE_HELIX_URL),
body=json.dumps(example_get_streams_response),
status=200,
content_type='application/json')
client = TwitchHelix('client id')
streams = client.get_streams()
stream = streams.next()
assert len(responses.calls) == 1
assert isinstance(streams, APICursor)
assert streams._cursor == example_get_streams_response['pagination']['cursor']
assert isinstance(stream, Stream)
assert stream.id == example_get_streams_response['data'][0]['id']
assert stream.game_id == example_get_streams_response['data'][0]['game_id']
assert stream.title == example_get_streams_response['data'][0]['title']
assert stream.started_at == datetime(2017, 8, 14, 16, 8, 32)
def test_get_streams_passes_all_params_to_request():
responses.add(responses.GET,
'{}streams'.format(BASE_HELIX_URL),
body=json.dumps(example_get_streams_response),
status=200,
content_type='application/json')
client = TwitchHelix('client id')
streams = client.get_streams(
after='eyJiIjpudWxsLCJhIjp7Ik9mZnNldCI6MjB9fQ==',
before='eyJiIjp7Ik9mZnNldCI6MH0sImEiOnsiT2Zmc2V0Ijo0MH19==',
community_ids=[
'848d95be-90b3-44a5-b143-6e373754c382',
'fd0eab99-832a-4d7e-8cc0-04d73deb2e54'
],
page_size=100,
game_ids=['417752', '29307'],
languages=['en'],
user_ids=['23161357'],
user_logins=['lirik']
)
stream = streams.next()
assert len(responses.calls) == 1
assert isinstance(streams, APICursor)
assert isinstance(stream, Stream)
url = responses.calls[0].request.url
assert url.startswith('https://api.twitch.tv/helix/streams?')
assert 'after=eyJiIjpudWxsLCJhIjp7Ik9mZnNldCI6MjB9fQ%3D%3D' in url
assert 'before=eyJiIjp7Ik9mZnNldCI6MH0sImEiOnsiT2Zmc2V0Ijo0MH19%3D%3D' in url
assert 'community_id=848d95be-90b3-44a5-b143-6e373754c382' in url
assert 'community_id=fd0eab99-832a-4d7e-8cc0-04d73deb2e54' in url
assert 'first=100' in url
assert 'game_id=417752' in url
assert 'game_id=29307' in url
assert 'language=en' in url
assert 'user_id=23161357' in url
assert 'user_login=lirik' in url
def test_get_streams_next_returns_stream_object():
responses.add(
responses.GET,
"{}streams".format(BASE_HELIX_URL),
body=json.dumps(example_get_streams_response),
status=200,
content_type="application/json",
)
client = TwitchHelix("client id")
streams = client.get_streams()
stream = streams.next()
assert len(responses.calls) == 1
assert isinstance(streams, APICursor)
assert streams._cursor == example_get_streams_response["pagination"]["cursor"]
assert isinstance(stream, Stream)
assert stream.id == example_get_streams_response["data"][0]["id"]
assert stream.game_id == example_get_streams_response["data"][0]["game_id"]
assert stream.title == example_get_streams_response["data"][0]["title"]
assert stream.started_at == datetime(2017, 8, 14, 16, 8, 32)
search_terms.append(term.lower())
if not os.path.exists(STATE_FILENAME):
streams = {}
else:
with open(STATE_FILENAME, 'rb') as handle:
streams = pickle.load(handle)
helix = TwitchHelix(TWITCH_TOKEN)
game = helix.get_games(names=[GAME])[0]
log.info(f"Found game {game.id}")
while True:
try:
log.debug("Starting loop")
count = 0
for stream in helix.get_streams(page_size=100, game_ids=game.id):
count += 1
if stream.user_id in streams:
continue
found = False
title = stream.title.lower()
for term in search_terms:
if term in title:
found = True
break
if found:
log.info(f"Found stream {stream.user_name} : {stream.title}")
bldr = []
def first_500_streams():
client = TwitchHelix()
streams_iterator = client.get_streams(page_size=100)
for stream in islice(streams_iterator, 0, 500):
print(stream)
def streams():
client = TwitchHelix()
streams_iterator = client.get_streams()
print(streams_iterator.next())
from twitch import TwitchHelix
import os
client = TwitchHelix(client_id=os.environ.get('TWITCH_CLIENT_KEY'))
f = open(log_file_name,"a+")
f.close()
#writes to time and data to file
import time
starttime=time.time()
import datetime
while True:
#gets current channel metadata
streams_iterator = client.get_streams(user_logins=channel_name)
stream_data = streams_iterator.next()
#gets current datetime
now = str(datetime.datetime.now().isoformat())
#prints current time output
# print ("tick- ",now)
#writes time and channel metadata to file
data = str(now+str(stream_data)+"\n")
f = open(log_file_name,"a+")
f.write(data)
print(data)
f.close()
time.sleep(1)
while True:
counter += 1
print(str(counter) + ' ' + channel + ': ' + resp)
resp = sock.recv(2048).decode('utf-8')
if resp.startswith('PING'):
sock.send("PONG\n".encode('utf-8'))
elif len(resp) > 0:
logging.info(resp)
if __name__ == "__main__":
client = TwitchHelix(client_id=os.environ.get('TWITCH_CLIENT_KEY'))
get_streams = client.get_streams(page_size=100)[1:]
top_50_channel_list = []
for stream in get_streams:
if (stream['language'] == 'en'):
top_50_channel_list.append(stream['user_name'])
my_list = top_50_channel_list[0:5]
processes = my_list
pool = Pool(processes=len(my_list))
pool.map(twitch_chat, processes)
from itertools import islice
from twitch import TwitchHelix
from twitch import TwitchClient
#channel = client.channels.get_by_id(44322889)
#print(channel.id)
#print(channel.name)
#print(channel.display_name)
client = TwitchHelix(client_id='x2nlpgpmb4nn6m1o1vby49mif3qeqy')
streams_iterator = client.get_streams(page_size=100)
for stream in islice(streams_iterator, 0, 5):
print(stream)
client = TwitchClient(client_id='x2nlpgpmb4nn6m1o1vby49mif3qeqy')
users = client.users.translate_usernames_to_ids(['vektv', 'jukes','officialf0xey'])
for user in users:
print('{}: {}'.format(user.name, user.id))
client = TwitchHelix(client_id='x2nlpgpmb4nn6m1o1vby49mif3qeqy')
streams_iterator = client.get_streams_metadata(page_size=100,user_ids=[77208443])
for stream in islice(streams_iterator, 0, 5):
print(stream)
client = TwitchHelix(client_id='x2nlpgpmb4nn6m1o1vby49mif3qeqy')
games_iterator = client.get_top_games(page_size=100)
for game in islice(games_iterator, 0, 10):
print(game)
class TwitchStreams(MycroftSkill):
def __init__(self):
super(TwitchStreams, self).__init__(name="TwitchStreams")
self.streamObject = {}
self.streamList = []
self.set_refresh_token_url = "https://twitchtokengenerator.com/api/refresh" \
"/mvfohzdugl5spyqmzsilbfoqm4d45ie965i6h55vxeovbr3eqe "
self.client = TwitchHelix(client_id="gp762nuuoqcoxypju8c569th9wz7q5",
oauth_token="fu4l5bwwgmk9b4f7rfaphzetntp30o")
def initialize(self):
self.load_data_files(dirname(__file__))
self.bus.on('twitch-streams.aiix.home', self.launcher_id)
self.gui.register_handler('twitchstreams.aiix.playstream',
self.play_stream)
self.gui.register_handler('twitchstreams.aiix.playerStatus',
self.handle_player_states)
self.gui.register_handler('twitchstreams.aiix.playerRemoveActive',
self.handleRemoveActive)
def handle_player_states(self, message):
playerState = message.data['player']
if playerState == "Playing":
self.gui["showPlayerButton"] = True
if playerState == "Paused":
self.gui["showPlayerButton"] = True
if playerState == "Stopped":
self.gui["showPlayerButton"] = False
def handleRemoveActive(self):
self.gui.remove_page("TwitchPlayer.qml")
def launcher_id(self, message):
self.prepare_homepage({})
@intent_file_handler('show_home_twitch.intent')
def show_twitch_app_by_voice(self, message):
self.prepare_homepage({})
def prepare_homepage(self, message):
self.gui.clear()
self.enclosure.display_manager.remove_active()
self.gui["loadingStatus"] = ""
self.gui.show_page("TwitchLogo.qml", override_idle=True)
self.prepare_streams_for_home()
def prepare_streams_for_home(self):
get_streams = self.client.get_streams()
for i in range(len(get_streams)):
stream_dict = {
"id":
str(get_streams[i].id),
"user_id":
str(get_streams[i].user_id),
"user_name":
str(get_streams[i].user_name),
"game_id":
str(get_streams[i].game_id),
"type":
get_streams[i].type,
"title":
str(get_streams[i].title),
"viewer_count":
str(get_streams[i].viewer_count),
"started_at":
self.build_start_time(
get_streams[i].started_at.strftime('%Y-%m-%dT%H:%M:%SZ')),
"language":
str(get_streams[i].language),
"thumbnail_url":
str(get_streams[i].thumbnail_url).format(width=240,
height=240),
"tag_ids":
list(get_streams[i].tag_ids)
}
self.streamList.append(stream_dict)
self.streamObject['streams'] = self.streamList
self.display_homepage()
def display_homepage(self):
self.gui.clear()
self.enclosure.display_manager.remove_active()
self.gui["showPlayerButton"] = False
self.gui["liveStreamsModel"] = self.streamObject
self.gui.show_page("TwitchHome.qml", override_idle=True)
def play_stream(self, message):
get_username = message.data['user_name']
get_title = message.data['title']
extract_stream_from_url = "https://www.twitch.tv/{0}".format(
get_username)
get_playable_link = self.process_video_stream(extract_stream_from_url)
if get_playable_link:
self.gui["video"] = str(get_playable_link[0])
self.gui["quality"] = str(get_playable_link[1])
self.gui["status"] = str("play")
self.gui["setTitle"] = str(message.data['title'])
self.gui["viewCount"] = str(message.data['viewer_count'])
self.gui["publishedDate"] = str(message.data['started_at'])
self.gui["videoAuthor"] = str(message.data['user_name'])
self.gui.show_page("TwitchPlayer.qml", override_idle=True)
def process_video_stream(self, videolink):
try:
streams = streamlink.streams(videolink)
if "480p" in streams.keys():
LOG.info("Playing 480p Stream")
video_quality = "480p"
video_url = streams["480p"].url
elif "360p" in streams.keys():
LOG.info("Playing 360p Stream")
video_quality = "360p"
video_url = streams["360p"].url
elif "720p" in streams.keys():
LOG.info("Playing 720p Stream")
video_quality = "720p"
video_url = streams["720p"].url
else:
LOG.info("Playing Best Stream")
video_quality = "best"
video_url = streams["best"].url
streamInformation = [video_url, video_quality]
return streamInformation
except all as exception:
return None
def build_start_time(self, update):
now = datetime.datetime.now() + datetime.timedelta(seconds=60 * 3.4)
date = dateutil.parser.parse(update)
naive = date.replace(tzinfo=None)
dtstring = timeago.format(naive, now)
return dtstring
def stop(self):
self.enclosure.bus.emit(Message("metadata", {"type": "stop"}))
pass
