def test_Streamer_small_follower_list_is_okay(self):
# This twitch user has 9 total followers
very_small_streamer = TwitchStreamer('moJohat')
foll_result = very_small_streamer.get_all_follows()
followers_count = 0
for each_100 in foll_result.keys():
followers_count += len(foll_result[each_100])
self.assertEqual(int(very_small_streamer.get_total_follows_count()),
followers_count)
self.assertTrue('000' in foll_result)
self.assertFalse('100' in foll_result)
def test_Streamer_zero_follower_list_is_okay(self):
zero_streamer = TwitchStreamer('prod3x')
foll_result = zero_streamer.get_all_follows()
# This twitch user has 0 total followers
self.assertFalse(len(foll_result) > 0)
self.assertEqual(len(foll_result), 0)
self.assertEqual(len(foll_result), zero_streamer.total_followers)
self.assertEqual(zero_streamer.total_followers, 0)
self.assertEqual(zero_streamer.get_total_follows_count(), 0)
self.assertEqual(int(zero_streamer.get_total_follows_count()),
len(foll_result))
def test_Streamer_zero_follower_list_is_okay(self):
zero_streamer = TwitchStreamer('prod3x')
# This twitch user has 0 total followers
self.assertEqual(int(zero_streamer.get_total_follows_count()), int(0))
foll_result = zero_streamer.get_all_follows()
followers_count = 0
for each_100 in foll_result.keys():
followers_count += len(foll_result[each_100])
print(streamer.get_total_follows_count())
self.assertEqual(int(zero_streamer.get_total_follows_count()),
followers_count)
self.assertTrue('000' in foll_result)
self.assertFalse('100' in foll_result)
def main():
# Get info about a streamer from twitch
tmp_twitch_streamer = TwitchStreamer('stroopC')
fols = tmp_twitch_streamer.get_all_follows()
for each_hundred_list in fols.keys():
print(fols[each_hundred_list])
#db = neo4_db.Neo4jDB()
#db.find_or_add_streamer('stroopc')
#folls = tmp_twitch_streamer.get_all_follows()
#streamer_node = db.create_streamer_node(tmp_twitch_streamer)
#db.add_streamer_folls_from_twitch(tmp_twitch_streamer, streamer_node)
pass
def add_followers_to_streamer(some_streamer: TwitchStreamer, db_streamer: GraphObject) -> dict:
"""
Adds all followers to db for a given TwitchStreamer object and py2neo ogm object
:param some_streamer: TwitchStreamer object and related methods
:param db_streamer: An GraphObject representation of a Streamer node in the DB
:return: List of follower id's obtained from twitch
"""
foll_list = some_streamer.get_all_follows()
foll_nodes = []
for each_fol in foll_list:
db_follower = User()
try:
db_follower.twitch_uid = each_fol['from_id']
db_follower.display_name = each_fol['from_name']
# Commit to new follower to DB
db_follower.save()
foll_nodes.append(db_follower)
# Add Followed-by relationship to Streamer Node
db_streamer.is_followed_by.update(
db_follower, properties={'followed at': each_fol['followed_at']}
)
except Exception as exc:
module_logger.error("Failed to add follower to db: {}".format(each_fol['from_name']))
module_logger.error(exc)
pass
# Save all updated follower references to DB
db_streamer.save()
# Return a list of follower id's from twitch
return {'foll_id_list': [each_fol['from_id'] for each_fol in foll_list], 'foll_nodes': foll_nodes}
def create_or_update_from_twitch_client(some_streamer: TwitchStreamer):
db_streamer = User()
try:
for key, val in some_streamer.as_dict().items():
db_streamer.__setattr__(key, val)
# TODO: Note that this updates an existing node; this may be undesirable if we want to compare
# total followers reported by Twitch to record in DB and perform an action
# Add or Update in DB
db_streamer.save()
module_logger.info("Added {} to DB".format(some_streamer.display_name))
except Exception as exc:
module_logger.error("Failed to add streamer to db: {}".format(some_streamer.display_name))
module_logger.error(exc)
return db_streamer
def add_all_followers_followings(foll_dict: dict):
for follower_id, foll_node in zip(foll_dict['foll_id_list'], foll_dict['foll_nodes']):
# Fetch a followings list from twitch
all_followings = twitch_client.get_all_follows(follower_id, 'from_id', skip_validation=True)
for some_followed_stream in all_followings:
# Attempt to find Streamer node in DB
matched_streamer = User.match(graph, some_followed_stream['to_id']).first()
if matched_streamer is None:
new_streamer = TwitchStreamer(some_followed_stream['to_name'])
matched_streamer = User.create_or_update_from_twitch_client(new_streamer)
matched_streamer.is_followed_by.update(
foll_node, properties={'followed at': some_followed_stream['followed_at']}
)
matched_streamer.save()
def test_Streamer_small_follower_list_is_okay(self):
very_small_streamer = TwitchStreamer('moJohat')
foll_result = very_small_streamer.get_all_follows()
# This twitch user has 9 total followers
self.assertTrue(len(foll_result) > 0)
self.assertEqual(len(foll_result),
very_small_streamer.get_total_follows_count())
self.assertEqual(len(foll_result), very_small_streamer.total_followers)
self.assertEqual(very_small_streamer.total_followers,
very_small_streamer.get_total_follows_count())
self.assertEqual(int(very_small_streamer.get_total_follows_count()),
len(foll_result))
def add_streamer_folls_from_twitch(self, some_streamer: TwitchStreamer,
streamer_node: StreamerNode):
followers_dict = some_streamer.get_all_follows()
module_logger.info('Adding Followers to DB for {} ...'.format(
some_streamer.display_name))
# Add followers in followers list as nodes
for each_hundred_list in followers_dict.values():
for each_follower_dict in each_hundred_list:
follower_uid = each_follower_dict['from_id']
some_follower = UserGraphObj(follower_uid)
some_follower.followed_at = each_follower_dict['followed_at']
some_follower.display_name = each_follower_dict['from_name']
# Add Follower/Following Relationship between Streamer and Follower
#TODO: BREAKS HERE: "module 'neo4db' has no attribute 'Streamer'"
some_follower.is_following(streamer_node)
# Create or Update Follower in DB
self.db.merge(some_follower)
module_logger('DB: Added {} as a follower of {}'.format(
some_follower.display_name, some_streamer.display_name))
# Update Streamer Node Relationship in DB
self.db.push(streamer_node.is_followed_by(some_follower))
module_logger(
'Added "is following" relationship for {}'.format(
some_follower.display_name))
import unittest
from app.twitch_client import TwitchStreamer
# Removed from setUp to speed up tests -- could break at some point since streamer is set
streamer = TwitchStreamer('stroopc')
class TestStreamer(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_Streamer_has_name(self):
self.assertEqual(streamer.name, 'stroopc')
self.assertTrue(streamer.name is not None)
def test_Streamer_has_uid(self):
self.assertTrue(streamer.twitch_uid is not None)
self.assertFalse(streamer.twitch_uid == '')
self.assertEqual(streamer.twitch_uid, '106071345')
def test_Streamer_has_tot_followers(self):
# As of last check, stroopC has 465 followers; floor is set to 450 for future-proofing
self.assertTrue(streamer.total_followers > 450)
def test_Streamer_has_foll_list(self):
# Test whether get_follows produces a non-empty list
foll_result = streamer.get_all_follows()
self.assertTrue(len(foll_result) > 0)
def find_or_add_streamer(self, streamer_name: str):
# Lookup streamer_name using twitch_client to fetch twitch_uid
try:
streamer = TwitchStreamer(str(streamer_name))
twitch_api_succ_msg = "find_or_add_streamer() => Twitch API - 'validate_name()' found user: "******"{}"'.format(streamer.display_name)
twitch_api_succ_msg += ' (uid: {})'.format(streamer.twitch_uid)
self.logger.info(twitch_api_succ_msg)
except ValueError:
twitch_api_fail_msg = "'find_or_add_streamer()' => Twitch API user NOT found: "
twitch_api_fail_msg += '"{}"'.format(str(streamer_name))
self.logger.info(twitch_api_fail_msg)
return None
# Search DB for node matching
user_node = Node('User',
'Streamer',
twitch_uid=str(streamer.twitch_uid),
name=str(streamer.name),
display_name=str(streamer.display_name),
total_followers=str(streamer.total_followers),
profile_img_url=str(streamer.prof_img_url))
streamer_node = StreamerNode()
streamer_node.twitch_uid = streamer.twitch_uid
streamer_node.display_name = streamer.display_name
streamer_node.name = streamer.name
streamer_node.profile_img_url = streamer.prof_img_url
#self.db.create(user_node)
print(self.db.nodes)
# # Check DB for unique twitch uid
# uid_node = Node('User', twitch_id=str(streamer.uid))
# self.logger.info('Checking Neo4j DB for matching twitch uid')
# #matcher = NodeMatcher(self.db)
# matcher = NodeMatcher(self.db).match(uid_node)
# print('matcher', matcher)
#
# # TODO: Use MERGE to create if not exists
# # If DB match not found, try less-restrictive
# if matcher is None:
# self.logger.info('No Match found, attempting to add user to DB.')
# new_user_node = Node('User',
# twitch_id=streamer.uid,
# name=streamer.name,
# display_name=streamer.display_name,
# total_followers=streamer.total_followers,
# profile_img_url=streamer.prof_img_url)
# self.db.create(new_user_node)
# self.logger.info('New user was created in DB')
#
# # Add uid, profile img url, name, total_twitch_followers (as reported by Twitch)
#
# # Add follower list relationships from streamer.get_follows
#
# # Node found in DB
# else:
# twitch_total_followers = streamer.total_followers
# # Check if node_total_followers field exists in found node
#
# # Check if node_total_followers field is current (equal to twitch_total_followers)
# # Update follower relationships if 'node_total_followers' != twitch_total_followers
#
# # Check COUNT of follower relationships in DB
#
# # Update follower relationships if COUNT does not match 'node_total_followers'
#
# # Update follower relationships if COUNT does not match 'total_twitch_followers'
pass