def _create_tweet_dao(self, tweet_config, is_setter):
"""
Create a Tweet getter or setter as required.
For a getter dao, get the required data collection from MongoDB.
For a setter dao, set the data collection into MongoDB.
@param tweet_config: the config file path
@param is_setter: True if TweetDao setter is required
@return: a Tweet MongoDAO getter or a Tweet MongoDAO setter
"""
tweet_mongo_dao = TweetMongoSetDAO() if is_setter else TweetMongoGetDAO()
global_tweets_config = tweet_config['Global-Tweet'] if 'Global-Tweet' in tweet_config else None
user_tweets_config = tweet_config['User-Tweet'] if 'User-Tweet' in tweet_config else None
# Get Global Tweets
if global_tweets_config:
tweet_mongo_dao.global_tweet_collection = get_collection_from_config(global_tweets_config)
# Get User Tweets
if user_tweets_config:
tweet_mongo_dao.user_tweet_collection = get_collection_from_config(user_tweets_config)
if not global_tweets_config and not user_tweets_config:
tweet_mongo_dao = None
return tweet_mongo_dao
def _create_wf_dao(self, wf_config, is_setter):
"""
Create a WordFrequency getter or setter as required.
For a getter dao, get the required data collection from MongoDB.
For a setter dao, set the data collection into MongoDB.
@param wf_config: path of the config file
@param is_setter: True if WordFrequenceDao setter is required
@return: a WordFrequencyDAO getter or a WordFrequenctDAO setter
"""
wf_mongo_dao = WordFrequencyMongoSetDAO(
) if is_setter else WordFrequencyMongoGetDAO()
global_wcv_config = wf_config[
'Global-Word-Count'] if 'Global-Word-Count' in wf_config else None
user_wcv_config = wf_config[
'User-Word-Count'] if 'User-Word-Count' in wf_config else None
global_wfv_config = wf_config[
'Global-Word-Frequency'] if 'Global-Word-Frequency' in wf_config else None
user_wfv_config = wf_config[
'User-Word-Frequency'] if 'User-Word-Frequency' in wf_config else None
user_rwfv_config = wf_config[
'Relative-User-Word-Frequency'] if 'Relative-User-Word-Frequency' in wf_config else None
gen_new_collection = True
if global_wcv_config:
wf_mongo_dao.global_word_count_vector_collection = get_collection_from_config(
global_wcv_config)
# # uncomment if create a new collection
# wf_mongo_dao.global_word_count_vector_collection = get_collection_from_config(global_wcv_config ,gen_new_collection)
if user_wcv_config:
wf_mongo_dao.user_word_count_vector_collection = get_collection_from_config(
user_wcv_config)
if global_wfv_config:
wf_mongo_dao.global_word_frequency_vector_collection = get_collection_from_config(
global_wfv_config)
if user_wfv_config:
wf_mongo_dao.user_word_frequency_vector_collection = get_collection_from_config(
user_wfv_config)
if user_rwfv_config:
wf_mongo_dao.relative_user_word_frequency_vector_collection = get_collection_from_config(
user_rwfv_config)
if not global_wcv_config and not user_wcv_config and not global_wfv_config and not user_wfv_config and not user_rwfv_config:
wf_mongo_dao = None
return wf_mongo_dao
def configure(self, config: Dict):
if config is not None:
raw_tweet_getter = MongoRawTweetGetter()
processed_tweet_setter = MongoProcessedTweetSetter()
raw_tweet_config = config['raw_tweets']
raw_tweets_collection = get_collection_from_config(raw_tweet_config)
raw_tweet_getter.set_tweet_collection(raw_tweets_collection)
processed_tweets_config = config['processed_tweets']
processed_tweets_collection = get_collection_from_config(processed_tweets_config)
processed_tweet_setter.set_processed_tweet_collection(processed_tweets_collection)
self.tweet_processor = TweetProcessor(raw_tweet_getter,
processed_tweet_setter)
def _create_muisi_dao(self, muisi_config, is_setter):
# Check whether retweets mode is set in config
is_retweets_mode = muisi_config['is-retweets-mode']
if is_retweets_mode:
muisi_mongo_dao = MUISIRetweetsMongoSetDAO() if is_setter else MUISIRetweetsMongoGetDAO()
else:
muisi_mongo_dao = MUISIMongoSetDAO() if is_setter else MUISIMongoGetDAO()
muisi_cluster_config = muisi_config['Cluster']
if muisi_cluster_config:
if is_retweets_mode:
muisi_mongo_dao.muisi_retweets_cluster_collection = get_collection_from_config(muisi_cluster_config)
else:
muisi_mongo_dao.muisi_cluster_collection = get_collection_from_config(muisi_cluster_config)
else:
muisi_mongo_dao = None
return muisi_mongo_dao
def create_getter(raw_tweets: Dict) -> RawTweetGetter:
raw_tweet_getter = None
if raw_tweets["type"] == "Mongo":
raw_tweet_getter = MongoRawTweetGetter()
collection = get_collection_from_config(raw_tweets["config"])
raw_tweet_getter.set_tweet_collection(collection)
else:
raise Exception("Datastore type not supported")
return raw_tweet_getter
def create_setter(friends: Dict) -> FriendSetter:
friend_setter = None
if friends["type"] == "Mongo":
friend_setter = MongoFriendSetter()
collection = get_collection_from_config(friends["config"])
friend_setter.set_friend_collection(collection)
else:
raise Exception("Datastore type not supported")
return friend_setter
def create_cluster_getter(config: Dict):
cluster_getter = None
if config["type"] == "Mongo":
cluster_getter = MongoClusterGetter()
collection = get_collection_from_config(config["config"])
cluster_getter.set_collection(collection)
else:
raise Exception("Datastore type not supported")
return cluster_getter
def create_setter(config: Dict) -> ProcessedTweetSetter:
processed_tweet_setter = None
if config["type"] == "Mongo":
processed_tweet_setter = MongoProcessedTweetSetter()
collection = get_collection_from_config(config["config"])
processed_tweet_setter.set_collection(collection)
else:
raise Exception("Datastore type not supported")
return processed_tweet_setter
def _create_ap_dao(self, ap_config, is_setter):
ap_mongo_dao = AffinityPropagationMongoSetDAO() if is_setter else AffinityPropagationMongoGetDAO()
ap_cluster_config = ap_config['Cluster']
if ap_cluster_config:
ap_mongo_dao.clusters_collection = get_collection_from_config(ap_cluster_config)
else:
ap_mongo_dao = None
return ap_mongo_dao
def create_getter(config: Dict):
user_neighbourhood_getter = None
if config["type"] == "Mongo":
user_neighbourhood_getter = MongoUserNeighborhoodGetter()
collection = get_collection_from_config(config["config"])
user_neighbourhood_getter.set_collection(collection)
else:
raise Exception("Datastore type not supported")
return user_neighbourhood_getter
def create_getter(config: Dict) -> LocalNeighbourhoodGetter:
local_neighbourhood_getter = None
if config["type"] == "Mongo":
local_neighbourhood_getter = MongoLocalNeighbourhoodGetter()
collection = get_collection_from_config(config["config"])
local_neighbourhood_getter.set_collection(collection)
else:
raise Exception("Datastore type not supported")
return local_neighbourhood_getter
def _create_social_graph_dao(self, social_graph_config, is_setter):
social_graph_mongo_dao = SocialGraphMongoSetDAO() if is_setter else SocialGraphMongoGetDAO()
user_friend_graph_config = social_graph_config['User-Friend-Graph']
if user_friend_graph_config:
social_graph_mongo_dao.user_friends_graph_collection = get_collection_from_config(user_friend_graph_config)
else:
social_graph_mongo_dao = None
return social_graph_mongo_dao
def create_setter(users: Dict) -> UserSetter:
user_setter = None
if users["type"] == "Mongo":
user_setter = MongoUserSetter()
collection = get_collection_from_config(users["config"])
user_setter.set_user_collection(collection)
else:
raise Exception("Datastore type not supported")
return user_setter
def create_setter(config: Dict) -> UserWordFrequencySetter:
user_word_frequency_setter = None
if config["type"] == "Mongo":
user_word_frequency_setter = MongoUserWordFrequencySetter()
collection = get_collection_from_config(config["config"])
user_word_frequency_setter.set_user_word_frequency_collection(collection)
else:
raise Exception("Datastore type not supported")
return user_word_frequency_setter
def create_setter(config: Dict) -> CommunitySetter:
community_setter = None
if config["type"] == "Mongo":
community_setter = MongoCommunitySetter()
collection = get_collection_from_config(config["config"])
community_setter.set_collection(collection)
else:
raise Exception("Datastore type not supported")
return community_setter
def create_setter(followers: Dict) -> FollowerSetter:
follower_setter = None
if followers["type"] == "Mongo":
follower_setter = MongoFollowerSetter()
collection = get_collection_from_config(followers["config"])
follower_setter.set_follower_collection(collection)
else:
raise Exception("Datastore type not supported")
return follower_setter
def create_topusers_setter(config: Dict):
top_users_setter = None
if config["type"] == "Mongo":
top_users_setter = MongoTopUsersSetter()
collection = get_collection_from_config(config["config"])
top_users_setter.set_collection(collection)
else:
raise Exception("Datastore type not supported")
return top_users_setter
def create_wordfrequency_getter(config: Dict):
relative_wordfrequency_getter = None
if config["type"] == "Mongo":
relative_wordfrequency_getter = MongoRelativeWordFrequencyGetter()
collection = get_collection_from_config(config["config"])
relative_wordfrequency_getter.set_collection(collection)
else:
raise Exception("Datastore type not supported")
return relative_wordfrequency_getter
def create_getter(config: Dict) -> RankingGetter:
ranking_getter = None
if config["type"] == "Mongo":
ranking_getter = MongoRankingGetter()
collection = get_collection_from_config(config["config"])
ranking_getter.set_collection(collection)
else:
raise Exception("Datastore type not supported")
return ranking_getter
def create_setter(config: Dict) -> GlobalWordFrequencySetter:
global_word_frequency_setter = None
if config["type"] == "Mongo":
global_word_frequency_setter = MongoGlobalWordFrequencySetter()
collection = get_collection_from_config(config["config"])
global_word_frequency_setter.set_global_word_frequency_collection(
collection)
else:
raise Exception("Datastore type not supported")
return global_word_frequency_setter
def configure(self, config: Dict):
if config is not None:
tweepy_getter = TweepyTwitterGetter()
user_follower_setter = MongoFollowerSetter()
collection = get_collection_from_config(config)
user_follower_setter.set_follower_collection(collection)
self.follower_downloader = MongoFollowerSetter(
tweepy_getter, user_follower_setter)
def _create_uf_dao(self, user_friends_config, is_setter):
user_friends_dao = UserFriendsMongoSetDAO(
) if is_setter else UserFriendsMongoGetDAO()
by_name_config = user_friends_config[
'User-Friend-By-Name'] if 'User-Friend-By-Name' in user_friends_config else None
by_id_config = user_friends_config[
'User-Friend-By-ID'] if 'User-Friend-By-ID' in user_friends_config else None
if by_name_config:
user_friends_dao.user_friends_by_name_collection = get_collection_from_config(
by_name_config)
if by_id_config:
user_friends_dao.user_friends_by_id_collection = get_collection_from_config(
by_id_config)
if not by_name_config and not by_id_config:
user_friends_dao = None
return user_friends_dao
def _create_lp_dao(self, lp_config, is_setter):
lp_mongo_dao = LabelPropagationMongoSetDAO(
) if is_setter else LabelPropagationMongoGetDAO()
ap_cluster_config = lp_config['Cluster']
if ap_cluster_config:
lp_mongo_dao.clusters_collection = get_collection_from_config(
ap_cluster_config)
else:
lp_mongo_dao = None
return lp_mongo_dao
def create_getter(config, Type):
getter = Type()
collection = get_collection_from_config(config)
getter.set_collection(collection)
return getter
