def run_rt_processing():
click.echo(
"Provide the full path the the raw tweet processing config(leave blank to set to default)"
)
default_path = get_project_root(
) / 'src' / 'process' / 'raw_tweet_processing' / 'rt_processing_config.yaml'
rt_processing_config_path = click.prompt("Path", default_path)
rt_processing_config_parser = RawTweetProcessingConfigParser(
rt_processing_config_path)
tweet_getter = rt_processing_config_parser.create_getter_DAOs()
tweet_setter, processed_tweet_setter = rt_processing_config_parser.create_setter_DAOs(
)
tweet_processor = RawTweetProcessor()
click.echo("Process Types")
click.echo("1. Global(random) Tweets")
click.echo("2. User Tweets")
process_type = click.prompt("Choose what to process", type=int)
if process_type == 1:
click.echo("Processing global tweets")
tweet_processor.gen_processed_global_tweets(tweet_getter, tweet_setter,
processed_tweet_setter)
elif process_type == 2:
click.echo("Processing user tweets")
tweet_processor.gen_processed_user_tweets(tweet_getter, tweet_setter,
processed_tweet_setter)
else:
raise Exception("Invalid input")
def run_wf():
default_path = get_project_root(
) / 'src' / 'process' / 'word_frequency' / 'wf_config.yaml'
wf_config_path = click.prompt("Path", default_path)
wf_config_parser = WordFrequencyConfigParser(wf_config_path)
processed_tweet_getter, wf_getter = wf_config_parser.create_getter_DAOs()
processed_tweet_setter, wf_setter = wf_config_parser.create_setter_DAOs()
word_freq = WordFrequency()
click.echo("Word Vector Types")
click.echo("1. Global Word Count Vector")
click.echo("2. Global Word Frequency Vector")
click.echo("3. User Word Count Vector")
click.echo("4. User Word Frequency Vector")
click.echo("5. Relative User Word Frequency Vector")
wf_type = click.prompt("Choose what to compute", type=int)
if wf_type == 1:
click.echo("Computing global word count vector")
word_freq.gen_global_word_count_vector(processed_tweet_getter,
processed_tweet_setter,
wf_setter)
elif wf_type == 2:
click.echo("Computing global word frequency vector")
word_freq.gen_global_word_frequency_vector(wf_getter, wf_setter)
elif wf_type == 3:
click.echo("Computing user word count vector")
word_freq.gen_user_word_count_vector(processed_tweet_getter,
processed_tweet_setter, wf_setter)
elif wf_type == 4:
click.echo("Computing user word frequency vector")
word_freq.gen_user_word_frequency_vector(wf_getter, wf_setter)
elif wf_type == 5:
click.echo("Computing relative user word frequency vector")
word_freq.gen_relative_user_word_frequency_vector(wf_getter, wf_setter)
def run_social_graph():
default_path = get_project_root(
) / 'src' / 'process' / 'social_graph' / 'social_graph_config.yaml'
social_graph_path = click.prompt("Path", default_path)
social_graph_config_parser = SocialGraphConfigParser(social_graph_path)
user_friends_getter = social_graph_config_parser.create_getter_DAOs()
social_graph_setter = social_graph_config_parser.create_setter_DAOs()
social_graph = SocialGraph()
click.echo("Social Graph options")
click.echo("1. User Friends Graph")
social_graph_option = click.prompt("Choose what to compute", type=int)
if social_graph_option == 1:
click.echo("Computing user friends graph")
click.echo(
"Reminder: make sure to have downloaded the local neighborhood for your user of interest"
)
use_user_list, user_or_user_list, ulp = get_user()
if use_user_list:
ulp.run_function_by_user_list(social_graph.gen_user_friends_graph,
user_or_user_list,
user_friends_getter,
social_graph_setter)
else:
social_graph.gen_user_friends_graph(user_or_user_list,
user_friends_getter,
social_graph_setter)
else:
raise Exception("Invalid input")
def main():
tweet_downloader = TwitterTweetDownloader()
config_path = get_project_root(
) / 'src' / 'process' / 'download' / 'download_config.yaml'
download_config_parser = DownloadConfigParser(config_path)
tweepy_getter, _ = download_config_parser.create_getter_DAOs()
tweet_mongo_setter, _, _ = download_config_parser.create_setter_DAOs()
tweet_downloader.gen_random_tweet(tweepy_getter, tweet_mongo_setter)
def global_word_count():
word_frequency = WordFrequency()
config_path = get_project_root(
) / 'src' / 'process' / 'word_frequency' / 'wf_config.yaml'
word_frequency_parser = WordFrequencyConfigParser(config_path)
processed_tweet_getter, _ = word_frequency_parser.create_getter_DAOs()
processed_tweet_setter, wf_setter = word_frequency_parser.create_setter_DAOs(
)
word_frequency.gen_global_word_count_vector(processed_tweet_getter,
processed_tweet_setter,
wf_setter)
def get_user():
ulp = None
use_user_list = click.confirm("Do you wish to provide a user list?")
if use_user_list:
default_ul_path = get_project_root() / 'src' / 'tools' / 'user_list'
ul_path = click.prompt("User List Path", default_ul_path)
ulp = UserListProcessor()
user_or_user_list = ulp.user_list_parser(ul_path)
else:
user_or_user_list = click.prompt("User")
return use_user_list, user_or_user_list, ulp
import argparse
import time
from src.dependencies.injector import Injector
from src.shared.utils import get_project_root
from src.shared.logger_factory import LoggerFactory
from typing import List
log = LoggerFactory.logger(__name__)
DEFAULT_PATH = str(
get_project_root()) + "/src/scripts/config/detect_community_config.yaml"
def detect_community(name_list: List, path=DEFAULT_PATH):
try:
injector = Injector.get_injector_from_file(path)
process_module = injector.get_process_module()
community_detector = process_module.get_community_detector()
community_detector.detect_community_by_screen_name(name_list)
except Exception as e:
log.exception(e)
exit()
if __name__ == "__main__":
"""
Short script to download tweets
"""
parser = argparse.ArgumentParser(
description='Detect community from seed sets')
import argparse
from src.shared.utils import get_project_root
from src.scripts.parser.parse_config import parse_from_file
from src.activity.cluster_social_graph_activity import ClusterSocialGraphActivity
DEFAULT_PATH = str(get_project_root()) + "/src/scripts/config/cluster_social_graph_config.yaml"
def cluster_social_graph(seed_id: str, params=None, path=DEFAULT_PATH):
config = parse_from_file(path)
activity = ClusterSocialGraphActivity(config)
activity.cluster_social_graph(seed_id, params)
if __name__ == "__main__":
"""
Short script to perform clustering on a social graph
"""
parser = argparse.ArgumentParser(description='Downloads the given number of tweets')
parser.add_argument('-s', '--seed_id', dest='seed_id', required=True,
help='The seed id of the local neighbourhood to convert into a social graph', type=str)
parser.add_argument('-p', '--path', dest='path', required=False,
default=DEFAULT_PATH, help='The path of the config file', type=str)
args = parser.parse_args()
cluster_social_graph(args.seed_id, path=args.path)
from src.activity.download_user_tweets_activity import DownloadUserTweetsActivity
import argparse
import time
from src.dependencies.injector import Injector
from src.shared.utils import get_project_root
from src.shared.logger_factory import LoggerFactory
import numpy as np
import matplotlib.mlab as mlab
import matplotlib.pyplot as plt
from src.model.local_neighbourhood import LocalNeighbourhood
import json
log = LoggerFactory.logger(__name__)
DEFAULT_PATH = str(get_project_root()) + "/src/scripts/config/default_config.yaml"
def produce_plots(seed_id: str, user_name: str, path=DEFAULT_PATH):
threshold = 60
injector = Injector.get_injector_from_file(path)
process_module = injector.get_process_module()
dao_module = injector.get_dao_module()
user_friend_getter = dao_module.get_user_friend_getter()
friends_cleaner = process_module.get_friends_cleaner()
social_graph_constructor = process_module.get_social_graph_constructor()
clusterer = process_module.get_clusterer()
cluster_word_frequency_processor = process_module.get_cluster_word_frequency_processor()
tweet_processor = process_module.get_tweet_processor()
def test_getProjectRoot_returnsExpectedInput():
path = utils.get_project_root()
path_string = str(path)
assert path_string.endswith("core")
import argparse
from src.shared.utils import get_project_root
from src.dependencies.injector import Injector
DEFAULT_PATH = str(get_project_root(
)) + "/src/scripts/config/process_local_neighbourhood_tweets_config.yaml"
def process_user_tweets(id: str, path=DEFAULT_PATH):
injector = Injector.get_injector_from_file(path)
process_module = injector.get_process_module()
tweet_processor = process_module.get_tweet_processor()
tweet_processor.process_tweets_by_user_id(id)
if __name__ == "__main__":
"""
Short script to process the tweets of a Local Neighbourhood
"""
parser = argparse.ArgumentParser(
description='Processes the tweets of the given user')
parser.add_argument('-i',
'--id',
dest='id',
required=True,
help='The id of the user',
type=str)
parser.add_argument('-p',
'--path',
from src.activity.download_local_neighbourhood_activity import DownloadLocalNeighbourhoodActivity
import argparse
import time
from src.scripts.parser.parse_config import parse_from_file
from src.shared.utils import get_project_root
DEFAULT_PATH = str(get_project_root(
)) + "/src/scripts/config/download_local_neighbourhood_config.yaml"
def download_local_neighbourhood(name: str, path=DEFAULT_PATH):
config = parse_from_file(path)
activity = DownloadLocalNeighbourhoodActivity(config)
activity.download_local_neighbourhood_by_screen_name(name)
if __name__ == "__main__":
"""
Short script to download tweets
"""
parser = argparse.ArgumentParser(
description='Downloads the local neighbourhood of the given user')
parser.add_argument('-n',
'--name',
dest='name',
required=True,
help='The name of the user to start on',
type=str)
parser.add_argument('-p',
'--path',
import argparse
from src.shared.utils import get_project_root
from src.dependencies.injector import Injector
from src.shared.logger_factory import LoggerFactory
log = LoggerFactory.logger(__name__)
DEFAULT_PATH = str(
get_project_root()) + "/src/scripts/config/download_user_config.yaml"
def download_user(name: str, path=DEFAULT_PATH):
injector = Injector.get_injector_from_file(path)
process_module = injector.get_process_module()
user_downloader = process_module.get_user_downloader()
log.info("Starting Download user with name: %s" % (name))
user_downloader.download_user_by_screen_name(name)
log.info("Done downloading user: %s" % (name))
if __name__ == "__main__":
"""
Short script to download users
"""
parser = argparse.ArgumentParser(description='Downloads the given user')
parser.add_argument('-n',
'--name',
dest='name',
help="The screen name of the user to download",
from src.data_cleaning.Activity.clean_friends_activity import FriendsCleaningActivity
import argparse
import time
from src.data_cleaning.parser.parse_config import parse_from_file
from src.shared.utils import get_project_root
DEFAULT_PATH = str(
get_project_root()) + "/src/data_cleaning/config/friends_cleaning.yaml"
def friends_cleaning(threshold: int,
method: str,
base_user: str,
path=DEFAULT_PATH):
config = parse_from_file(path)
activity = FriendsCleaningActivity(config)
if method == "1":
activity.clean_by_friends(base_user, threshold)
elif method == "2":
activity.clean_by_tweets(base_user, threshold)
else:
raise NotImplementedError()
if __name__ == "__main__":
"""
Clean inactive users in the friends list.
"""
parser = argparse.ArgumentParser(description='Get rid of inactive users')
parser.add_argument('-t',
def run_download():
click.echo(
"Provide the full path the the download config(leave blank to set to default)"
)
default_path = get_project_root(
) / 'src' / 'process' / 'download' / 'download_config.yaml'
download_config_path = click.prompt("Path", default_path)
download_config_parser = DownloadConfigParser(download_config_path)
tweepy_getter, user_friends_getter = download_config_parser.create_getter_DAOs(
)
tweet_mongo_setter, user_friends_setter, user_followers_setter = download_config_parser.create_setter_DAOs(
)
click.echo("Download Types:")
click.echo("1. Twitter Tweet Download")
click.echo("2. Twitter Friends Download")
click.echo("3. Twitter Followers Download")
download_type = click.prompt("Choose a download type", type=int)
if download_type == 1:
tweet_downloader = TwitterTweetDownloader()
click.echo("Tweet types:")
click.echo("1. User Tweets")
click.echo("2. Random Tweets")
tweet_type = click.prompt("Choose what to download", type=int)
if tweet_type == 1:
# TODO: follow by this example
click.echo("Downloading User Tweets")
use_user_list, user_or_user_list, ulp = get_user()
num_tweets = click.prompt(
"Number of Tweets(leave blank to get all)", type=int)
if click.confirm("Do you want to specify a start and end date?"):
start_date = get_date(click.prompt("Start Date(YYYY-MM-DD)"))
end_date = get_date(click.prompt("End Date(YYYY-MM-DD)"))
if use_user_list:
ulp.run_function_by_user_list(
tweet_downloader.gen_user_tweets, user_or_user_list,
tweepy_getter, tweet_mongo_setter, num_tweets,
start_date, end_date)
else:
tweet_downloader.gen_user_tweets(user_or_user_list,
tweepy_getter,
tweet_mongo_setter,
num_tweets, start_date,
end_date)
else:
if use_user_list:
ulp.run_function_by_user_list(
tweet_downloader.gen_user_tweets, user_or_user_list,
tweepy_getter, tweet_mongo_setter, num_tweets)
else:
tweet_downloader.gen_user_tweets(user_or_user_list,
tweepy_getter,
tweet_mongo_setter,
num_tweets)
elif tweet_type == 2:
click.echo("Downloading Random Tweets")
click.echo(
"Due to Tweepy constraints, if you want to download multiple tweets, you should launch a daemon"
)
if click.confirm(
"Do you wish to launch a daemon to download random tweets?"
):
click.echo("Launching daemon")
download_daemon.download_random_tweet()
else:
tweet_downloader.gen_random_tweet(tweepy_getter,
tweet_mongo_setter)
elif download_type == 2:
click.echo("Friend Download Types")
click.echo("1. User Friends")
click.echo("2. User Local Neighborhood")
friend_type = click.prompt("Choose which to download", type=int)
friends_downloader = TwitterFriendsDownloader()
if friend_type == 1:
click.echo("Downloading user friends")
use_user_list, user_or_user_list, ulp = get_user()
num_friends = click.prompt(
"Number of Friends(leave blank to get all)", type=int)
if use_user_list:
ulp.run_function_by_user_list(
friends_downloader.gen_friends_by_screen_name,
user_or_user_list, tweepy_getter, user_friends_setter,
num_friends)
else:
friends_downloader.gen_friends_by_screen_name(
user_or_user_list, tweepy_getter, user_friends_setter,
num_friends)
elif friend_type == 2:
click.echo("Downloading user local neightborhood")
use_user_list, user_or_user_list, ulp = get_user()
if use_user_list:
ulp.run_function_by_user_list(
friends_downloader.gen_user_local_neighborhood,
user_or_user_list, tweepy_getter, user_friends_getter,
user_friends_setter)
else:
friends_downloader.gen_user_local_neighborhood(
user_or_user_list, tweepy_getter, user_friends_getter,
user_friends_setter)
else:
raise Exception("Invalid input")
elif download_type == 3:
click.echo("Downloading followers")
use_user_list, user_or_user_list, ulp = get_user()
num_followers = click.prompt(
"Number of Followers(leave blank to get all)", type=int)
followers_downloader = TwitterFollowersDownloader()
if use_user_list:
ulp.run_function_by_user_list(
followers_downloader.gen_followers_by_screen_name,
user_or_user_list, tweepy_getter, user_followers_setter,
num_followers)
else:
followers_downloader.gen_followers_by_screen_name(
user_or_user_list, tweepy_getter, user_followers_setter,
num_followers)
else:
raise Exception("Invalid input")
from src.activity.download_raw_tweets_activity import DownloadTweetsActivity
import argparse
import time
from src.scripts.parser.parse_config import parse_from_file
from src.shared.utils import get_project_root
DEFAULT_PATH = str(
get_project_root()) + "/src/scripts/config/download_tweets_config.yaml"
def download_tweets(num: int, path=DEFAULT_PATH):
config = parse_from_file(path)
activity = DownloadTweetsActivity(config)
activity.stream_random_tweets(num_tweets=num)
if __name__ == "__main__":
"""
Short script to download tweets
"""
parser = argparse.ArgumentParser(
description='Downloads the given number of tweets')
parser.add_argument('-n',
'--num',
dest='num',
required=True,
help='The number of tweets to download',
type=int)
parser.add_argument('-p',
'--path',
from src.algorithm.Activity.top_words_activity import TopWordsActivity
import argparse
import time
from src.algorithm.top_words.parser.parse_config import parse_from_file
from src.shared.utils import get_project_root
DEFAULT_PATH = str(get_project_root()) + "/src/algorithm/top_words/config/top_words.yaml"
DEFAULT_METHOD = "Label Propagation"
def top_words(cluster_num: int, base_user: str, cluster_type: str, path=DEFAULT_PATH):
config = parse_from_file(path)
activity = TopWordsActivity(config)
activity.find_top_words(cluster_num, base_user,cluster_type)
if __name__ == "__main__":
"""
Clean inactive users in the friends list.
"""
parser = argparse.ArgumentParser(description='Get rid of inactive users')
parser.add_argument('-c', '--cluster number', dest='cluster_num', required=True,
help='which cluster to find top words', type=int)
parser.add_argument('-u', '--user', dest='base_user', required=True,
help='The target user', type=str)
parser.add_argument('-t', '--clustering type', dest='cluster_type', required=False,
default=DEFAULT_METHOD, help='Label Propagation / Max Modularity', type=str)
parser.add_argument('-p', '--path', dest='path', required=False,
default=DEFAULT_PATH, help='The path of the config file', type=str)
args = parser.parse_args()
import argparse
from src.shared.utils import get_project_root
from src.dependencies.injector import Injector
from typing import List
DEFAULT_PATH = str(get_project_root()) + "/src/scripts/config/cluster_word_frequency_config.yaml"
def get_cluster_word_frequency(ids: List[str], path=DEFAULT_PATH):
injector = Injector.get_injector_from_file(path)
process_module = injector.get_process_module()
cluster_word_frequency_processor = process_module.get_cluster_word_frequency_processor()
cluster_word_frequency_processor.process_cluster_word_frequency_vector(ids)
cluster_word_frequency_processor.process_relative_cluster_word_frequency(ids)
if __name__ == "__main__":
"""
Short script to download users
"""
parser = argparse.ArgumentParser(description='Downloads the given user')
parser.add_argument('-u', '--users', dest='users',
help="The ids of the users to get cluster word frequency", required=True)
parser.add_argument('-p', '--path', dest='path', required=False,
default=DEFAULT_PATH, help='The path of the config file', type=str)
args = parser.parse_args()
users = args.users.split(",")
get_cluster_word_frequency(users, args.path)
import argparse
from src.shared.utils import get_project_root
from src.scripts.parser.parse_config import parse_from_file
from src.activity.process_tweet_activity import ProcessTweetActivity
DEFAULT_PATH = str(
get_project_root()) + "/src/scripts/config/process_tweet_config.yaml"
def process_tweet(id: str, path=DEFAULT_PATH):
config = parse_from_file(path)
activity = ProcessTweetActivity(config)
activity.process_tweet_by_id(id)
if __name__ == "__main__":
"""
Short script to process tweets
"""
parser = argparse.ArgumentParser(description='Processes the given tweet')
parser.add_argument('-i',
'--id',
dest='id',
help="The id of the tweet to process",
required=True,
type=str)
parser.add_argument('-p',
'--path',
dest='path',
required=False,
def run_clustering():
click.echo("Clustering Algorithms")
click.echo("1. Affinity Propagation")
click.echo("2. Label Propagation")
click.echo("3. MUISI")
clustering_type = click.prompt("Choose a clustering algorithm", type=int)
if clustering_type == 1:
click.echo("Computing Affinity Propagation cluster")
ap = AffinityPropagation()
default_path = get_project_root(
) / 'src' / 'process' / 'clustering' / 'affinity_propagation' / 'ap_config.yaml'
ap_config_path = click.prompt("Path", default_path)
ap_config_parser = AffinityPropagationConfigParser(ap_config_path)
wf_getter = ap_config_parser.create_getter_DAOs()
ap_setter = ap_config_parser.create_setter_DAOs()
ap.gen_clusters(wf_getter, ap_setter)
elif clustering_type == 2:
click.echo("Computing Label Propagation cluster")
default_path = get_project_root(
) / 'src' / 'process' / 'clustering' / 'label_propagation' / 'lp_config.yaml'
lp_config_path = click.prompt("Path", default_path)
lp_config_parser = LabelPropagationConfigParser(lp_config_path)
social_graph_getter = lp_config_parser.create_getter_DAOs()
lp_cluster_setter = lp_config_parser.create_setter_DAOs()
user = click.prompt("User")
lab_prop = LabelPropagation()
lab_prop.gen_clusters(user, social_graph_getter, lp_cluster_setter)
elif clustering_type == 3:
click.echo("MUISI Variants")
click.echo("1. Tweets")
click.echo("2. Retweets")
muisi_variant = click.prompt("Choose a variant", type=int)
if muisi_variant == 1:
click.echo("Computing MUISI cluster")
default_path = get_project_root(
) / 'src' / 'process' / 'clustering' / 'muisi' / 'standard' / 'muisi_config.yaml'
muisi_config_path = click.prompt("Path", default_path)
muisi_config_parser = MUISIConfigParser(muisi_config_path, False)
wf_getter = muisi_config_parser.create_getter_DAOs()
muisi_cluster_setter = muisi_config_parser.create_setter_DAOs()
muisi = MUISI()
# Get user args
intersection_min = click.prompt("Intersection Min", type=float)
popularity = click.prompt("Popularity", type=float)
threshold = click.prompt("Threshold", type=float)
user_count = click.prompt("User Count", type=int)
item_count = click.prompt("Item Count", type=int)
count = click.prompt("Count", type=int)
is_only_popularity = click.confirm(
"Do you wish to only compute based on popularity?")
muisi_config = MUISIConfig(intersection_min, popularity, threshold,
user_count, item_count, count,
is_only_popularity)
muisi.gen_clusters(muisi_config, wf_getter, muisi_cluster_setter)
elif muisi_variant == 2:
click.echo("Computing MUISI retweets cluster")
default_path = get_project_root(
) / 'src' / 'process' / 'clustering' / 'muisi' / 'retweets' / 'muisi_retweets_config.yaml'
muisi_config_path = click.prompt("Path", default_path)
muisi_config_parser = MUISIConfigParser(muisi_config_path, True)
tweet_getter = muisi_config_parser.create_getter_DAOs()
muisi_cluster_setter = muisi_config_parser.create_setter_DAOs()
muisi = MUISIRetweet()
# Get user args
intersection_min = click.prompt("Intersection Min", type=float)
popularity = click.prompt("Popularity", type=float)
user_count = click.prompt("User Count", type=int)
muisi_config = MUISIRetweetConfig(intersection_min, popularity,
user_count)
muisi.gen_clusters(muisi_config, tweet_getter,
muisi_cluster_setter)
else:
raise Exception("Invalid input")
else:
raise Exception("Invalid input")
import argparse
from src.shared.utils import get_project_root
from src.scripts.parser.parse_config import parse_from_file
from src.activity.construct_social_graph_activity import ConstructSocialGraphActivity
DEFAULT_PATH = str(get_project_root()
) + "/src/scripts/config/construct_social_graph_config.yaml"
def construct_social_graph(seed_id: str, params=None, path=DEFAULT_PATH):
config = parse_from_file(path)
activity = ConstructSocialGraphActivity(config)
activity.construct_social_graph(seed_id, params)
if __name__ == "__main__":
"""
Short script to convert a local neighbourhood to a social graph
"""
parser = argparse.ArgumentParser(
description='Downloads the given number of tweets')
parser.add_argument(
'-s',
'--seed_id',
dest='seed_id',
required=True,
help=
'The seed id of the local neighbourhood to convert into a social graph',
type=str)
parser.add_argument('-p',
import argparse
from src.shared.utils import get_project_root
from src.scripts.parser.parse_config import parse_from_file
from src.dependencies.injector import Injector
DEFAULT_PATH = str(
get_project_root()) + "/src/scripts/config/detect_core_config0.yaml"
def rank_cluster(seed_id: str, params=None, path=DEFAULT_PATH):
injector = Injector.get_injector_from_file(path)
process_module = injector.get_process_module()
dao_module = injector.get_dao_module()
cluster_getter = dao_module.get_cluster_getter()
ranker = process_module.get_ranker('Consumption')
clusters, _ = cluster_getter.get_clusters(seed_id)
for cluster in clusters:
ranker.rank(seed_id, cluster)
if __name__ == "__main__":
"""
Short script to perform clustering on a social graph
"""
parser = argparse.ArgumentParser(
description='Downloads the given number of tweets')
parser.add_argument(
'-s',
from src.algorithm.Activity.top_users_activity import TopUsersActivity
import argparse
import time
from src.algorithm.top_users.parser.parse_config import parse_from_file
from src.shared.utils import get_project_root
DEFAULT_PATH = str(get_project_root()) + "/src/algorithm/top_users/config/rank_users.yaml"
DEFAULT_METHOD = "Label Propagation"
def top_users(cluster_num: int, base_user: str, cluster_type: str, path=DEFAULT_PATH):
config = parse_from_file(path)
activity = TopUsersActivity(config)
activity.find_top_users(cluster_num, base_user, cluster_type)
if __name__ == "__main__":
"""
Clean inactive users in the friends list.
"""
parser = argparse.ArgumentParser(description='Get rid of inactive users')
parser.add_argument('-c', '--cluster number', dest='cluster_num', required=True,
help='which cluster to find top words', type=int)
parser.add_argument('-u', '--user', dest='base_user', required=True,
help='The target user', type=str)
parser.add_argument('-t', '--clustering type', dest='cluster_type', required=False,
default=DEFAULT_METHOD, help='Label Propagation / Max Modularity', type=str)
parser.add_argument('-p', '--path', dest='path', required=False,
default=DEFAULT_PATH, help='The path of the config file', type=str)
args = parser.parse_args()
from src.dependencies.injector import Injector
from src.shared.utils import get_project_root
from src.shared.logger_factory import LoggerFactory
import numpy as np
import matplotlib.mlab as mlab
import matplotlib.pyplot as plt
from src.model.local_neighbourhood import LocalNeighbourhood
import json
import logging
import random
import gc
log = LoggerFactory.logger(__name__, logging.ERROR)
DEFAULT_PATH = str(
get_project_root()) + "/src/scripts/config/default_config.yaml"
def produce_plots(user_name: str, thresh, i, path=DEFAULT_PATH):
injector = Injector.get_injector_from_file(path)
process_module = injector.get_process_module()
dao_module = injector.get_dao_module()
user_friend_getter = dao_module.get_user_friend_getter()
friends_cleaner = process_module.get_extended_friends_cleaner()
social_graph_constructor = process_module.get_social_graph_constructor()
clusterer = process_module.get_clusterer()
user_getter = dao_module.get_user_getter()
seed_id = user_getter.get_user_by_screen_name(user_name).id
import argparse
from src.shared.utils import get_project_root
from src.dependencies.injector import Injector
DEFAULT_PATH = str(
get_project_root()) + "/src/scripts/config/user_word_frequency_config.yaml"
def get_user_word_frequency(id, path=DEFAULT_PATH):
injector = Injector.get_injector_from_file(path)
process_module = injector.get_process_module()
user_word_frequency_processor = process_module.get_user_word_frequency_processor(
)
user_word_frequency_processor.process_user_word_frequency_vector(id)
user_word_frequency_processor.process_relative_user_word_frequency(id)
if __name__ == "__main__":
"""
Short script to download users
"""
parser = argparse.ArgumentParser(description='Downloads the given user')
parser.add_argument('-u',
'--name',
dest='name',
help="The id of the user to get word frequency",
required=True)
parser.add_argument('-p',
'--path',
