def __init__(self, filename):

self.terminal = sys.stdout

self.logfile = open(filename, "a", buffering=1, encoding="utf-8")

def write(self, message):

self.terminal.write(message)

self.logfile.write(message)

self.terminal.flush()

self.logfile.flush()

def flush(self):

url = CHECK_INTERNET_URL

try:

_ = req.get(url, timeout=CHECK_INTERNET_TIMEOUT)

print("OK")

return True

except Exception as e:

print(f"No connectivity, please check your network - {e}")

sys.exit(1)

intervals = (

('years', 31556952), # approximation

('months', 2629746), # approximation

('weeks', 604800), # 60 * 60 * 24 * 7

('days', 86400), # 60 * 60 * 24

('hours', 3600), # 60 * 60

('minutes', 60),

('seconds', 1),

)

result = []

if seconds > 0:

for name, count in intervals:

value = seconds // count

if value:

seconds -= value * count

if value == 1:

name = name.rstrip('s')

result.append(f"{value} {name}")

return ', '.join(result[:granularity])

else:

result = []

intervals = ['years', 'months', 'weeks', 'days', 'hours', 'minutes', 'seconds']

ts1 = timestamp1

ts2 = timestamp2

if type(timestamp1) is int:

dt1 = datetime.fromtimestamp(int(ts1))

elif type(timestamp1) is float:

ts1 = int(round(ts1))

dt1 = datetime.fromtimestamp(ts1)

elif type(timestamp1) is datetime:

dt1 = timestamp1

ts1 = int(round(dt1.timestamp()))

else:

return ""

if type(timestamp2) is int:

dt2 = datetime.fromtimestamp(int(ts2))

elif type(timestamp2) is float:

ts2 = int(round(ts2))

dt2 = datetime.fromtimestamp(ts2)

elif type(timestamp2) is datetime:

dt2 = timestamp2

ts2 = int(round(dt2.timestamp()))

else:

return ""

if ts1 >= ts2:

ts_diff = ts1 - ts2

else:

ts_diff = ts2 - ts1

dt1, dt2 = dt2, dt1

if ts_diff > 0:

date_diff = relativedelta.relativedelta(dt1, dt2)

years = date_diff.years

months = date_diff.months

weeks = date_diff.weeks

if not show_weeks:

weeks = 0

days = date_diff.days

if weeks > 0:

days = days - (weeks * 7)

hours = date_diff.hours

if (not show_hours and ts_diff > 86400):

hours = 0

minutes = date_diff.minutes

if (not show_minutes and ts_diff > 3600):

minutes = 0

seconds = date_diff.seconds

if (not show_seconds and ts_diff > 60):

seconds = 0

date_list = [years, months, weeks, days, hours, minutes, seconds]

for index, interval in enumerate(date_list):

if interval > 0:

name = intervals[index]

if interval == 1:

name = name.rstrip('s')

result.append(f"{interval} {name}")

return ', '.join(result[:granularity])

else:

fqdn_re = re.compile(r'(?=^.{4,253}$)(^((?!-)[a-zA-Z0-9-]{1,63}(?<!-)\.)+[a-zA-Z]{2,63}\.?$)')

email_re = re.compile(r'[^@]+@[^@]+\.[^@]+')

try:

is_ip = ipaddress.ip_address(str(SMTP_HOST))

except ValueError:

if not fqdn_re.search(str(SMTP_HOST)):

print("Error sending email - SMTP settings are incorrect (invalid IP address/FQDN in SMTP_HOST)")

return 1

try:

port = int(SMTP_PORT)

if not (1 <= port <= 65535):

raise ValueError

except ValueError:

print("Error sending email - SMTP settings are incorrect (invalid port number in SMTP_PORT)")

return 1

if not email_re.search(str(SENDER_EMAIL)) or not email_re.search(str(RECEIVER_EMAIL)):

print("Error sending email - SMTP settings are incorrect (invalid email in SENDER_EMAIL or RECEIVER_EMAIL)")

return 1

if not SMTP_USER or not isinstance(SMTP_USER, str) or SMTP_USER == "your_smtp_user" or not SMTP_PASSWORD or not isinstance(SMTP_PASSWORD, str) or SMTP_PASSWORD == "your_smtp_password":

print("Error sending email - SMTP settings are incorrect (check SMTP_USER & SMTP_PASSWORD variables)")

return 1

if not subject or not isinstance(subject, str):

print("Error sending email - SMTP settings are incorrect (subject is not a string or is empty)")

return 1

if not body and not body_html:

print("Error sending email - SMTP settings are incorrect (body and body_html cannot be empty at the same time)")

return 1

try:

if use_ssl:

ssl_context = ssl.create_default_context()

smtpObj = smtplib.SMTP(SMTP_HOST, SMTP_PORT, timeout=smtp_timeout)

smtpObj.starttls(context=ssl_context)

else:

smtpObj = smtplib.SMTP(SMTP_HOST, SMTP_PORT, timeout=smtp_timeout)

smtpObj.login(SMTP_USER, SMTP_PASSWORD)

email_msg = MIMEMultipart('alternative')

email_msg["From"] = SENDER_EMAIL

email_msg["To"] = RECEIVER_EMAIL

email_msg["Subject"] = Header(subject, 'utf-8')

if body:

part1 = MIMEText(body, 'plain')

part1 = MIMEText(body.encode('utf-8'), 'plain', _charset='utf-8')

email_msg.attach(part1)

if body_html:

part2 = MIMEText(body_html, 'html')

part2 = MIMEText(body_html.encode('utf-8'), 'html', _charset='utf-8')

email_msg.attach(part2)

smtpObj.sendmail(SENDER_EMAIL, RECEIVER_EMAIL, email_msg.as_string())

smtpObj.quit()

except Exception as e:

print(f"Error sending email - {e}")

return 1

try:

csv_file = open(csv_file_name, 'a', newline='', buffering=1, encoding="utf-8")

csvwriter = csv.DictWriter(csv_file, fieldnames=csvfieldnames, quoting=csv.QUOTE_NONNUMERIC)

csvwriter.writerow({'Date': timestamp, 'Type': object_type, 'Name': object_name, 'Old': old, 'New': new})

csv_file.close()

except Exception as e:

if type(ts) is datetime:

ts_new = int(round(ts.timestamp()))

elif type(ts) is int:

ts_new = ts

elif type(ts) is float:

ts_new = int(round(ts))

else:

return ""

if type(ts) is datetime:

ts_new = int(round(ts.timestamp()))

elif type(ts) is int:

ts_new = ts

elif type(ts) is float:

ts_new = int(round(ts))

else:

return ""

if show_hour:

hour_strftime = " %H:%M"

else:

hour_strftime = ""

if show_year and int(datetime.fromtimestamp(ts_new).strftime("%Y")) != int(datetime.now().strftime("%Y")):

if show_hour:

hour_prefix = ","

else:

hour_prefix = ""

return (f'{calendar.day_abbr[(datetime.fromtimestamp(ts_new)).weekday()]} {datetime.fromtimestamp(ts_new).strftime(f"%d %b %y{hour_prefix}{hour_strftime}")}')

else:

try:

if version == 1:

utc_string_sanitize = utc_string.split('+', 1)[0]

utc_string_sanitize = utc_string_sanitize.split('.', 1)[0]

dt_utc = datetime.strptime(utc_string_sanitize, '%Y-%m-%d %H:%M:%S')

elif version == 2:

utc_string_sanitize = utc_string

dt_utc = datetime.strptime(utc_string_sanitize, '%Y-%m-%dT%H:%M:%SZ')

old_tz = pytz.timezone("UTC")

new_tz = pytz.timezone(timezone)

dt_new_tz = old_tz.localize(dt_utc).astimezone(new_tz)

return dt_new_tz

except Exception as e:

global profile_notification

profile_notification = not profile_notification

sig_name = signal.Signals(sig).name

print(f"* Signal {sig_name} received")

print(f"* Email notifications: [profile changes = {profile_notification}]")

global event_notification

event_notification = not event_notification

sig_name = signal.Signals(sig).name

print(f"* Signal {sig_name} received")

print(f"* Email notifications: [new events = {event_notification}]")

global repo_notification

repo_notification = not repo_notification

sig_name = signal.Signals(sig).name

print(f"* Signal {sig_name} received")

print(f"* Email notifications: [repos changes = {repo_notification}]")

global repo_update_date_notification

repo_update_date_notification = not repo_update_date_notification

sig_name = signal.Signals(sig).name

print(f"* Signal {sig_name} received")

print(f"* Email notifications: [repos update date = {repo_update_date_notification}]")

global GITHUB_CHECK_INTERVAL

GITHUB_CHECK_INTERVAL = GITHUB_CHECK_INTERVAL + GITHUB_CHECK_SIGNAL_VALUE

sig_name = signal.Signals(sig).name

print(f"* Signal {sig_name} received")

print(f"* Github timers: [check interval: {display_time(GITHUB_CHECK_INTERVAL)}]")

global GITHUB_CHECK_INTERVAL

if GITHUB_CHECK_INTERVAL - GITHUB_CHECK_SIGNAL_VALUE > 0:

GITHUB_CHECK_INTERVAL = GITHUB_CHECK_INTERVAL - GITHUB_CHECK_SIGNAL_VALUE

sig_name = signal.Signals(sig).name

print(f"* Signal {sig_name} received")

print(f"* Github timers: [check interval: {display_time(GITHUB_CHECK_INTERVAL)}]")

html_url = ""

if "https://api.github.com/repos/" in url:

url_suffix = url.split('https://api.github.com/repos/', 1)[1]

html_url = "https://github.com/" + url_suffix

print(f"Getting followers & followings for user '{user}' ...")

auth = Auth.Token(GITHUB_TOKEN)

g = Github(auth=auth)

g_user = g.get_user(user)

user_login = g_user.login

user_name = g_user.name

user_url = g_user.html_url

followers_count = g_user.followers

followings_count = g_user.following

followers_list = g_user.get_followers()

followings_list = g_user.get_following()

user_name_str = user_login

if user_name:

user_name_str += f" ({user_name})"

print(f"\nUsername:\t{user_name_str}")

print(f"URL:\t\t{user_url}/")

print(f"\nFollowers:\t{followers_count}")

if followers_list:

for follower in followers_list:

follower_str = f"\n- {follower.login}"

if follower.name:

follower_str += f" ({follower.name})"

if follower.html_url:

follower_str += f"\n[ {follower.html_url}/ ]"

print(follower_str)

print(f"\nFollowings:\t{followings_count}")

if followings_list:

for following in followings_list:

following_str = f"\n- {following.login}"

if following.name:

following_str += f" ({following.name})"

if following.html_url:

following_str += f"\n[ {following.html_url}/ ]"

print(following_str)

list_of_repos = []

stargazers = []

subscribers = []

forked_repos = []

if repos_list:

for repo in repos_list:

try:

repo_created_date = repo.created_at

repo_created_date_ts = convert_utc_str_to_tz_datetime(str(repo_created_date), LOCAL_TIMEZONE, 1).timestamp()

repo_updated_date = repo.updated_at

repo_updated_date_ts = convert_utc_str_to_tz_datetime(str(repo_updated_date), LOCAL_TIMEZONE, 1).timestamp()

stargazers = [star.login for star in repo.get_stargazers()]

subscribers = [subscriber.login for subscriber in repo.get_subscribers()]

forked_repos = [fork.full_name for fork in repo.get_forks()]

list_of_repos.append({"name": repo.name, "descr": repo.description, "is_fork": repo.fork, "forks": repo.forks_count, "stars": repo.stargazers_count, "watchers": repo.subscribers_count, "url": repo.html_url, "language": repo.language, "date": repo_created_date_ts, "update_date": repo_updated_date_ts, "stargazers": stargazers, "forked_repos": forked_repos, "subscribers": subscribers})

except Exception as e:

print(f"Error while processing info for repo '{repo.name}', skipping for now - {e}")

print_cur_ts("Timestamp:\t\t")

continue

print(f"Getting public repositories for user '{user}' ...")

auth = Auth.Token(GITHUB_TOKEN)

g = Github(auth=auth)

g_user = g.get_user(user)

user_login = g_user.login

user_name = g_user.name

user_url = g_user.html_url

repos_count = g_user.public_repos

repos_list = g_user.get_repos()

user_name_str = user_login

if user_name:

user_name_str += f" ({user_name})"

print(f"\nUsername:\t{user_name_str}")

print(f"URL:\t\t{user_url}/")

print(f"\nRepositories:\t{repos_count}")

if repos_list:

for repo in repos_list:

repo_str = f"\n- '{repo.name}' (fork: {repo.fork})"

repo_str += f"\n[ {repo.language}, forks: {repo.forks_count}, stars: {repo.stargazers_count}, watchers: {repo.subscribers_count} ]"

if repo.html_url:

repo_str += f"\n[ {repo.html_url}/ ]"

repo_created_date = repo.created_at

repo_created_date_ts = convert_utc_str_to_tz_datetime(str(repo_created_date), LOCAL_TIMEZONE, 1).timestamp()

repo_updated_date = repo.updated_at

repo_updated_date_ts = convert_utc_str_to_tz_datetime(str(repo_updated_date), LOCAL_TIMEZONE, 1).timestamp()

repo_str += f"\n[ date: {get_date_from_ts(repo_created_date_ts)} - {calculate_timespan(int(time.time()), int(repo_created_date_ts), granularity=2)} ago) ]"

repo_str += f"\n[ update: {get_date_from_ts(repo_updated_date_ts)} - {calculate_timespan(int(time.time()), int(repo_updated_date_ts), granularity=2)} ago) ]"

if repo.description:

repo_str += f"\n'{repo.description}'"

print(repo_str)

print(f"Getting repositories starred by user '{user}' ...")

auth = Auth.Token(GITHUB_TOKEN)

g = Github(auth=auth)

g_user = g.get_user(user)

user_login = g_user.login

user_name = g_user.name

user_url = g_user.html_url

starred_list = g_user.get_starred()

starred_count = starred_list.totalCount

user_name_str = user_login

if user_name:

user_name_str += f" ({user_name})"

print(f"\nUsername:\t\t{user_name_str}")

print(f"URL:\t\t\t{user_url}/")

print(f"\nRepos starred by user:\t{starred_count}")

if starred_list:

for star in starred_list:

star_str = f"\n- {star.full_name}"

if star.html_url:

star_str += f" [ {star.html_url}/ ]"

print(star_str)

event_date_ts = 0

repo_name = ""

repo_url = ""

st = ""

tp = ""

event_date_ts = convert_utc_str_to_tz_datetime(str(event.created_at), LOCAL_TIMEZONE, 1).timestamp()

if time_passed and not ts:

tp = f" ({calculate_timespan(int(time.time()), int(event_date_ts), show_seconds=False, granularity=2)} ago)"

elif time_passed and ts:

tp = f" (after {calculate_timespan(int(event_date_ts), int(ts), show_seconds=False, granularity=2)}: {get_short_date_from_ts(int(ts))})"

st += print_v(f"Event date:\t\t\t{get_date_from_ts(event_date_ts)}{tp}")

st += print_v(f"Event ID:\t\t\t{event.id}")

st += print_v(f"Event type:\t\t\t{event.type}")

if event.repo.id:

repo_name = event.repo.name

repo_url = github_convert_api_to_html_url(event.repo.url)

st += print_v(f"\nRepo name:\t\t\t{repo_name}")

st += print_v(f"Repo URL:\t\t\t{repo_url}")

repo = g.get_repo(event.repo.name)

if hasattr(event.actor, 'login'):

if event.actor.login:

st += print_v(f"\nEvent actor login:\t\t{event.actor.login}")

if hasattr(event.actor, 'name'):

if event.actor.name:

st += print_v(f"Event actor name:\t\t{event.actor.name}")

if event.payload.get("ref"):

st += print_v(f"\nObject name:\t\t\t{event.payload.get('ref')}")

if event.payload.get("ref_type"):

st += print_v(f"Object type:\t\t\t{event.payload.get('ref_type')}")

if event.payload.get("description"):

st += print_v(f"Description:\t\t\t'{event.payload.get('description')}'")

if event.payload.get("action"):

st += print_v(f"\nAction:\t\t\t\t{event.payload.get('action')}")

if event.payload.get("commits"):

st += print_v(f"\nNumber of commits:\t\t{len(event.payload.get('commits'))}")

commits = event.payload["commits"]

for commit in commits:

commit_details = repo.get_commit(sha=commit["sha"])

commit_date_ts = convert_utc_str_to_tz_datetime(str(commit_details.commit.author.date), LOCAL_TIMEZONE, 1).timestamp()

st += print_v(f" - Commit date:\t\t\t{get_date_from_ts(commit_date_ts)}")

st += print_v(f" - Commit sha:\t\t\t{commit['sha']}")

st += print_v(f" - Commit author:\t\t{commit['author']['name']}")

st += print_v(f" - Commit URL:\t\t\t{github_convert_api_to_html_url(commit['url'])}")

st += print_v(f" - Commit message:\t\t'{commit['message']}'")

if commit != commits[-1]:

st += print_v()

if event.payload.get("release"):

st += print_v(f"\nRelease name:\t\t\t{event.payload['release'].get('name')}")

st += print_v(f"Release URL:\t\t\t{event.payload['release'].get('html_url')}")

st += print_v(f"Release tag name:\t\t{event.payload['release'].get('tag_name')}")

if event.payload["release"].get("assets"):

assets = event.payload["release"].get("assets")

for asset in assets:

st += print_v(f" - Asset name:\t\t\t{asset.get('name')}")

st += print_v(f" - Asset size:\t\t\t{asset.get('size')}")

st += print_v(f" - Download URL:\t\t{asset.get('browser_download_url')}")

if asset != assets[-1]:

st += print_v()

st += print_v(f"Release description:\n\n'{event.payload['release'].get('body')}'")

if event.payload.get("pull_request"):

st += print_v(f"\nPR title:\t\t\t{event.payload['pull_request'].get('title')}")

pr_date_ts = convert_utc_str_to_tz_datetime(str(event.payload["pull_request"].get("created_at")), LOCAL_TIMEZONE, 2).timestamp()

st += print_v(f"PR date:\t\t\t{get_date_from_ts(pr_date_ts)}")

st += print_v(f"PR URL:\t\t\t\t{event.payload['pull_request'].get('html_url')}")

if event.payload["pull_request"].get("issue_url"):

st += print_v(f"Issue URL:\t\t\t{github_convert_api_to_html_url(event.payload['pull_request'].get('issue_url'))}")

if event.payload["pull_request"].get("state"):

st += print_v(f"PR state:\t\t\t{event.payload['pull_request'].get('state')}")

st += print_v(f"Commits:\t\t\t{event.payload['pull_request'].get('commits', 0)}")

st += print_v(f"Comments:\t\t\t{event.payload['pull_request'].get('comments', 0)}")

additions = event.payload["pull_request"].get("additions", 0)

deletions = event.payload["pull_request"].get("deletions", 0)

st += print_v(f"Additions/deletions:\t\t{additions}/{deletions}")

st += print_v(f"Changed files:\t\t\t{event.payload['pull_request'].get('changed_files', 0)}")

if event.payload["pull_request"].get("body"):

st += print_v(f"PR description:\n\n'{event.payload['pull_request'].get('body')}'")

if event.payload["pull_request"].get("requested_reviewers"):

for requested_reviewer in event.payload["pull_request"].get("requested_reviewers"):

st += print_v(f"\n - Requested reviewer name:\t{requested_reviewer.get('login')}")

st += print_v(f" - Requested reviewer URL:\t{requested_reviewer.get('html_url')}")

if event.payload["pull_request"].get("assignees"):

for assignee in event.payload["pull_request"].get("assignees"):

st += print_v(f"\n - Assignee name:\t\t{assignee.get('login')}")

st += print_v(f" - Assignee URL:\t\t{assignee.get('html_url')}")

if event.payload.get("review"):

review_date_ts = convert_utc_str_to_tz_datetime(str(event.payload["review"].get("submitted_at")), LOCAL_TIMEZONE, 2).timestamp()

st += print_v(f"\nRequested review date:\t\t{get_date_from_ts(review_date_ts)}")

st += print_v(f"Requested review URL:\t\t{event.payload['review'].get('html_url')}")

if event.payload["review"].get("state"):

st += print_v(f"Requested review state:\t\t{event.payload['review'].get('state')}")

if event.payload["review"].get("body"):

st += print_v(f"Requested review description:\n'{event.payload['review'].get('body')}'")

if event.payload.get("comment"):

comment_date_ts = convert_utc_str_to_tz_datetime(str(event.payload["comment"].get("created_at")), LOCAL_TIMEZONE, 2).timestamp()

st += print_v(f"\nComment date:\t\t\t{get_date_from_ts(comment_date_ts)}")

if event.payload["comment"].get("body"):

st += print_v(f"Comment body:\t\t\t'{event.payload['comment'].get('body')}'")

st += print_v(f"Comment URL:\t\t\t{event.payload['comment'].get('html_url')}")

if event.payload["comment"].get("path"):

st += print_v(f"Comment path:\t\t\t{event.payload['comment'].get('path')}")

if event.payload.get("issue"):

st += print_v(f"\nIssue title:\t\t\t{event.payload['issue'].get('title')}")

issue_date_ts = convert_utc_str_to_tz_datetime(str(event.payload["issue"].get("created_at")), LOCAL_TIMEZONE, 2).timestamp()

st += print_v(f"Issue date:\t\t\t{get_date_from_ts(issue_date_ts)}")

st += print_v(f"Issue URL:\t\t\t{event.payload['issue'].get('html_url')}")

if event.payload["issue"].get("state"):

st += print_v(f"Issue state:\t\t\t{event.payload['issue'].get('state')}")

st += print_v(f"Issue comments:\t\t\t{event.payload['issue'].get('comments', 0)}")

if event.payload["issue"].get("assignees"):

assignees = event.payload["issue"].get("assignees")

for assignee in assignees:

st += print_v(f" - Assignee name:\t\t{assignee.get('name')}")

if assignee != assignees[-1]:

st += print_v()

if event.payload["issue"].get("body"):

st += print_v(f"Issue body:\n'{event.payload['issue'].get('body')}'")

if event.payload.get("forkee"):

st += print_v(f"\nForked to repo:\t\t\t{event.payload['forkee'].get('full_name')}")

st += print_v(f"Forked to repo (URL):\t\t{event.payload['forkee'].get('html_url')}")

g_user = g.get_user(user)

events = g_user.get_events()

for i in reversed(range(number)):

event = events[i]

if event.type in EVENTS_TO_MONITOR or 'ALL' in EVENTS_TO_MONITOR:

github_print_event(event, g)

try:

if csv_file_name:

csv_file = open(csv_file_name, 'a', newline='', buffering=1, encoding="utf-8")

csvwriter = csv.DictWriter(csv_file, fieldnames=csvfieldnames, quoting=csv.QUOTE_NONNUMERIC)

if not csv_exists:

csvwriter.writeheader()

csv_file.close()

except Exception as e:

print(f"* Error - {e}")

followers_count = 0

followings_count = 0

repos_count = 0

starred_count = 0

try:

auth = Auth.Token(GITHUB_TOKEN)

g = Github(auth=auth)

g_user_myself = g.get_user()

user_myself_login = g_user_myself.login

user_myself_name = g_user_myself.name

g_user = g.get_user(user)

user_login = g_user.login

user_name = g_user.name

user_url = g_user.html_url

location = g_user.location

bio = g_user.bio

company = g_user.company

email = g_user.email

blog = g_user.blog

account_created_date = g_user.created_at

account_updated_date = g_user.updated_at

followers_count = g_user.followers

followings_count = g_user.following

repos_count = g_user.public_repos

followers_list = g_user.get_followers()

followings_list = g_user.get_following()

repos_list = g_user.get_repos()

starred_list = g_user.get_starred()

starred_count = starred_list.totalCount

events = g_user.get_events()

except Exception as e:

print(f"* Error - {e}")

sys.exit(1)

last_event_id = 0

last_event_ts = 0

events_list_of_ids = []

try:

for i in reversed(range(EVENTS_NUMBER)):

event = events[i]

if i == 0:

last_event_id = event.id

if last_event_id:

last_event_ts = int(convert_utc_str_to_tz_datetime(str(event.created_at), LOCAL_TIMEZONE, 1).timestamp())

events_list_of_ids.append(event.id)

except Exception as e:

print(f"* Cannot get event IDs / timestamps - {e}")

pass

followers_old_count = followers_count

followings_old_count = followings_count

repos_old_count = repos_count

starred_old_count = starred_count

user_name_old = user_name

location_old = location

bio_old = bio

company_old = company

email_old = email

blog_old = blog

last_event_id_old = last_event_id

last_event_ts_old = last_event_ts

events_list_of_ids_old = events_list_of_ids

user_myself_name_str = user_myself_login

if user_myself_name:

user_myself_name_str += f" ({user_myself_name})"

print(f"\nToken belongs to:\t\t{user_myself_name_str}")

user_name_str = user_login

if user_name:

user_name_str += f" ({user_name})"

print(f"\nUsername:\t\t\t{user_name_str}")

print(f"URL:\t\t\t\t{user_url}/")

if location:

print(f"Location:\t\t\t{location}")

if company:

print(f"Company:\t\t\t{company}")

if email:

print(f"Email:\t\t\t\t{email}")

if blog:

print(f"Blog URL:\t\t\t{blog}")

account_created_date_ts = convert_utc_str_to_tz_datetime(str(account_created_date), LOCAL_TIMEZONE, 1).timestamp()

print(f"\nAccount creation date:\t\t{get_date_from_ts(account_created_date_ts)} ({calculate_timespan(int(time.time()), int(account_created_date_ts), granularity=2)} ago)")

account_updated_date_ts = convert_utc_str_to_tz_datetime(str(account_updated_date), LOCAL_TIMEZONE, 1).timestamp()

print(f"Account updated date:\t\t{get_date_from_ts(account_updated_date_ts)} ({calculate_timespan(int(time.time()), int(account_updated_date_ts), granularity=2)} ago)")

account_updated_date_old_ts = account_updated_date_ts

print(f"\nFollowers:\t\t\t{followers_count}")

print(f"Followings:\t\t\t{followings_count}")

print(f"Repositories:\t\t\t{repos_count}")

print(f"Starred repos:\t\t\t{starred_count}")

if bio:

print(f"\nBio:\n\n'{bio}'")

print_cur_ts("\nTimestamp:\t\t\t")