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