Analyzing Likes Using Instagram API with python – part 3

def __get_cache_file_path(self, endpoint: str, identifier: str, count: int, end_cursor: Optional[str]) -> str: """ Generate a file path for caching based on the endpoint, identifier, count, and end_cursor. """ filename = f"{endpoint}_{identifier}_{count}_{self.__get_end_cursor(end_cursor)}.pkl" return os.path.join(self.cache_dir, filename) def __get_or_set_cache(self, endpoint: str, identifier: str, count: int, end_cursor: Optional[str], url: str) -> Any: """ Retrieve data from the cache if it exists; otherwise, fetch data from the URL, cache it, and return the data. :param endpoint: The API endpoint being queried. :param identifier: The identifier for the request (e.g., user ID or post shortcode). :param count: The number of items requested. :param end_cursor: The pagination cursor for the request. :param url: The URL to fetch data from if not cached. :return: The data retrieved from the cache or fetched from the URL. """ cache_file_path = self.__get_cache_file_path(endpoint, identifier, count, end_cursor) # Check if the cache file exists
 if os.path.exists(cache_file_path): # Load and return data from cache
 with open(cache_file_path, 'rb') as cache_file: return pickle.load(cache_file) # Make the API request if cache does not exist
 response = requests.get(url, headers=self.headers) data = response.json() # Save the fetched data to the cache
 with open(cache_file_path, 'wb') as cache_file: pickle.dump(data, cache_file) return data

def __init__(self, cache_dir: str = 'cache'): self.headers = { 'x-rapidapi-key': RAPIDAPI_KEY, 'x-rapidapi-host': RAPIDAPI_HOST } self.cache_dir = cache_dir if not os.path.exists(self.cache_dir): os.makedirs(self.cache_dir)

def get_user_posts(self, userid, count, end_cursor=None): url = self.__get_api_url(f"/userposts/{userid}/{count}/{self.__get_end_cursor(end_cursor)}") return self.__get_or_set_cache("userposts", userid, count, end_cursor, url) def get_post_likes(self, shortcode, count, end_cursor=None): url = self.__get_api_url(f"/postlikes/{shortcode}/{count}/{self.__get_end_cursor(end_cursor)}") return self.__get_or_set_cache("postlikes", shortcode, count, end_cursor, url) def get_user_followers(self, userid, count, end_cursor=None): url = self.__get_api_url(f"/userfollowers/{userid}/{count}/{self.__get_end_cursor(end_cursor)}") return self.__get_or_set_cache("userfollowers", userid, count, end_cursor, url)

class PostData: def __init__(self, post_id, post_likers: List[str], followers: List[str]): self.post_id = post_id self.post_likers = post_likers self.followers = followers

class PostResult: def __init__(self, post_id, all_likes_count, likers_likes_count): self.all_likes_count = all_likes_count self.likers_likes_count = likers_likes_count self.post_id = post_id

# Create an instance of the RapidApiClient
api_client = RapidApiClient()
end_cursor = None # Replace with your actual Instagram account ID
ACCOUNT_ID = '__PASTE_ACCOUNT_ID__' # Retrieve followers for the account (maximum 50 followers for testing purposes)
followers = api_client.get_user_followers(ACCOUNT_ID, 50)
# Extract usernames of the followers
followers_usernames = [user['username'] for user in followers["data"]["user"]] # Initialize an empty list to store post data
posts_data: List[PostData] = []
PAGE_LIMIT = 1 # Limit the number of pages to retrieve for testing purposes

for i in range(PAGE_LIMIT): # Retrieve user posts (maximum 5 posts per page for testing purposes)
 posts = api_client.get_user_posts(ACCOUNT_ID, 5, end_cursor) # Check if there is no next page, break the loop if not
 if not posts["data"]["next_page"]: break data = posts["data"] end_cursor = data["end_cursor"] # Update the end_cursor for the next page
 edges = data["edges"] # Extract the posts data
 for edge in edges: node = edge["node"] post_id = node["id"] # Extract the post ID
 # Retrieve likes for the post (maximum 50 likes for testing purposes)
 post_likes = api_client.get_post_likes(node["shortcode"], 50) # Extract usernames of the users who liked the post
 post_likers = [like['username'] for like in post_likes["data"]["likes"]] # Create a PostData object and add it to the posts_data list
 posts_data.append(PostData(post_id, post_likers, followers_usernames))

from typing import List class LikesAnalyzer: def __init__(self, posts_data: List[PostData]): """ Initialize the LikesAnalyzer with a list of PostData objects. :param posts_data: List of PostData objects containing data for each post. """ self.posts_data = posts_data def get_analysis(self) -> List[PostResult]: """ Analyze the likes data to determine the total likes and the likes from followers for each post. :return: A list of PostResult objects containing the analysis results for each post. """ results: List[PostResult] = [] # Initialize an empty list to store the analysis results
 # Iterate through each PostData object in the posts_data list
 for p in self.posts_data: all_likes_count = len(p.post_likers) # Count the total number of likes for the post
 likers_likes_count = 0 # Initialize the count for likes from followers
 # Iterate through each liker of the post
 for liker in p.post_likers: # Check if the liker is also a follower
 if liker in p.followers: likers_likes_count += 1 # Increment the count if the liker is a follower
 # Create a PostResult object with the post ID, total likes, and likes from followers
 results.append(PostResult(p.post_id, all_likes_count, likers_likes_count)) return results # Return the list of PostResult objects

import matplotlib.pyplot as plt
from typing import List
import random # Constants for the bar chart
BAR_WIDTH = 0.5 # Width of the bars in the chart
ALL_LIKES_COLOR = 'blue' # Color of the bars representing all likes
LIKERS_LIKES_COLOR = 'green' # Color of the bars representing likes from followers

class PostLikesPlotter: def plot_analysis(self, results: List[PostResult]) -> None: """ Plot the analysis of post likes, showing total likes and likes from followers for each post. :param results: A list of PostResult objects containing analysis results for each post. """ # Extract post IDs, total likes counts, and likers likes counts from the results
 post_ids = [result.post_id for result in results] all_likes_counts = [result.all_likes_count for result in results] likers_likes_counts = [result.likers_likes_count for result in results] # Create a figure and axis for the bar chart
 fig, ax = plt.subplots() # Plot the bars for total likes
 bars = ax.bar(post_ids, all_likes_counts, BAR_WIDTH, color=ALL_LIKES_COLOR, label='All Likes') # Plot the bars for likes from followers, overlaying them on the total likes bars
 for i, (bar, all_likes, liker_likes) in enumerate(zip(bars, all_likes_counts, likers_likes_counts)): ax.bar(bar.get_x(), liker_likes, BAR_WIDTH, color=LIKERS_LIKES_COLOR, label='Likers Likes' if i == 0 else "") # Set the labels and title of the chart
 ax.set_xlabel('Post ID') ax.set_ylabel('Likes Count') ax.set_title('Likes Analysis per Post') # Move the legend outside the bar chart area
 ax.legend(loc='upper left', bbox_to_anchor=(1, 1)) # Adjust the appearance of the x-axis labels
 ax.set_xticklabels(post_ids, fontsize=8, rotation=45, ha='right') # Display the bar chart
 plt.show()