DEV Community: apiharbor

Analyzing Likes Using Instagram API with python - part 3

apiharbor — Sun, 30 Jun 2024 16:08:07 +0000

Analyzing likes using Instagram API with python - part 3

Some time ago, we started working on an app to analyze likes on Instagram posts. We want to answer the question: What percentage of followers like Instagram posts? This will tell us whether the account should focus on gaining new followers or improving content since its current followers might not be interested. The result will be a bar chart for each post showing the ratio of all likes to likes from followers.

In our previous post How to analyze Instagram likes – part 2, we created an API client in Python. We decided to use the Instagram Scraper 2023 API. We wrote a client to fetch the data needed for our task. Today, it’s time to finish our app.

Save requests to Instagram API by adding file caching

Let’s revisit our rapidapi_client. We want to cache every call to the endpoint. We don’t want to waste requests while working, so it’s worth returning previously fetched data.

Currently, we have three functions that we will add caching to. Let’s write the caching method first:

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

We also need to change the constructor to create a folder for caching files:

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)

Everything looks fantastic! Now, we need to change the methods that communicate with the API:

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)

Nothing extraordinary here, we just use __get_or_set_cache and return the cached content if found instead of querying the Instagram API.

We are now protected against wasting requests, let’s move on!

Creating plain old python objects (POPO)

POPO are simple Python objects without additional methods or attributes other than those explicitly defined. We need them to pass data between classes.

Let’s think about the POPO we need. We must gather data from the API and merge it into one object to pass it further. So, we need a simple PostData class:

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

Another POPO will be the analysis result, let’s name this class PostResult:

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

Let’s create a list of PostData built from Instagram API data.

# 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))

At this point, posts_data contains a list of PostData objects composed of post IDs, lists of likers, and lists of followers. Great! We have the data ready; it’s time to feed it to the analyzer.

Analyzing data from the Instagram API

Let’s think about what such an analyzer should do. Essentially, it should count, just count 😉 But what exactly?

The total number of likes on a given post
The number of likes from followers

This is achieved by the following code:

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

The get_analysis function returns a list of PostResult. Yes, these are the results of our analysis. Such dry results don’t tell us much. Let’s make a chart out of them!

Displaying the chart based on

Data from the Instagram API

I propose the class name PostLikesPlotter to keep it simple. The best representation for the results will be a bar chart. It will immediately show on one bar how many followers liked a given post.

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()

Summary

We have a working application written in Python for Instagram data analysis! For those who want to download the source code, visit our website UseMyApi.com where you will find a link to GitHub with the code.

If you liked the post ❤️ leave a comment or any reaction. If you need any other application or changes to the current code, you can "hire" me for programming work. Feel free to contact me!

All the best for you all!

How to create an Instagram API client in python: a step-by-step tutorial

apiharbor — Wed, 19 Jun 2024 13:06:18 +0000

How to Create an Instagram API Client in Python: A Step-by-Step Tutorial - part 2

In the previous post, we set up the runtime environment for working with RapidAPI in Python. We also wrote a simple client that communicates with the Instagram Scraper 2023 API hosted on RapidAPI. The tests went well, so today we will be finishing the client.

Our Goal

To remind you of our goal: We want to create a full-fledged Python application using Instagram data that will:

Tell us who is liking the posts
Calculate the percentage of followers who like the posts

What value will this application provide?

It will help determine whether the account owner should focus more on encouraging users to follow the profile, getting more likes, or improving the content.

Let's get to work!

Necessary Endpoints

To achieve our goal, we need to know exactly what data we need to conduct our analysis. Therefore, we need:

To get a listing of posts by user ID
To get a list of people liking a particular post
To get a list of people following a user

In our application, we use the Instagram Scraper 2023 API, which provides the necessary data without any issues. We will use the following endpoints:

User Posts - returns a listing of posts by user ID
Post Likes - returns a listing of people liking a particular post
User Followers - returns a listing of people following a user

Since we have everything selected, it's time to implement these endpoints in our RapidApiClient class.

Implementation in RapidApiClient Class

Currently, this class in Python looks like this:

import http
import requests
from config import RAPIDAPI_HOST, RAPIDAPI_KEY

class RapidApiClient:
    def __init__(self):
        self.headers = {
            'x-rapidapi-key': RAPIDAPI_KEY,
            'x-rapidapi-host': RAPIDAPI_HOST
        }

    def get_user_posts(self, userid, count):
        url = self.__get_api_url(f"/userposts/{userid}/{count}/%7Bend_cursor%7D")
        response = requests.get(url, headers=self.headers)
        return response.json()

    def __get_api_url(self, path_and_query):
        return f"https://{RAPIDAPI_HOST}{path_and_query}"

As you can see, there's nothing complicated here. To fetch more posts, we need to add end_cursor support. The operation of end_cursor is very simple. When we fetch the first batch of posts, the response will include an end_cursor value. To get the next batch of posts, we simply pass this cursor in the next request.

Modify the get_user_posts Function

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)}")
    response = requests.get(url, headers=self.headers)
    return response.json()

We set the end_cursor parameter as default (None) and wrote a simple function __get_end_cursor:

def __get_end_cursor(self, ec):
    if ec is None:
        return "%7Bend_cursor%7D"
    return ec

This function returns the default value if the cursor is None.

Let's modify main.py to fetch more than 50 posts:

# Initialize the end_cursor to None
end_cursor = None

# Loop to fetch posts, iterating up to 2 times
for i in range(2):
    # Fetch user posts using the API client, specifying user ID, number of posts to fetch, and end cursor for pagination
    posts = api_client.get_user_posts('11579415180', 50, end_cursor)

    # Check if there is no next page of posts
    if not posts["data"]["next_page"]:
        # Break the loop if there are no more pages
        break

    # Update the end_cursor to the end cursor from the current batch of posts for the next iteration
    end_cursor = posts["data"]["end_cursor"]

    # Print the fetched posts
    print(posts)

This code fetches 100 posts. The first time, when cursor_end = None, it fetches the 50 latest posts. Then, in the second loop iteration, it captures cursor_end from the API response and uses it to fetch 50 more posts.

We're doing quite well!

Write the Function to Return People Liking the Post

Let's move to rapidapi_client.py:

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)}")
    response = requests.get(url, headers=self.headers)
    return response.json()

As you can see, the operation is identical to get_user_posts. So, let's write another function:

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)}")
    response = requests.get(url, headers=self.headers)
    return response.json()

This function will return the followers of a user.

RapidApiClient Ready for Action!

At this point, we have a complete client for communicating with the API. We can fetch all the data we need. In the next post, we will write the logic to use this data for analysis. Finally, we will be able to advise the analyzed user on how to develop their profile.

See you next time! 🚀

How to Analyze Instagram Likes: A Simple Python App - part 1

apiharbor — Sun, 16 Jun 2024 10:41:56 +0000

How to Analyze Instagram Likes: A Simple Python App - part 1

Do you want to better understand which Instagram posts attract the most attention? In my latest article on usemyapi.com, I show you how to build a simple application in Python to analyze Instagram likes.

You will learn how to:

Gain access to the Instagram API
Establish a connection with the API
Write a Python class that communicates with the API
Create a working example that operates on the retrieved data

Don't miss this opportunity to enhance your programming skills and gain valuable insights into Instagram user behavior.

👉 Read the full article here

How to publish a python package - Best Practices: A YouTube Channel API Example

apiharbor — Wed, 10 Jan 2024 08:48:06 +0000

Hey everyone! 👋

We've finally wrapped up our coding journey with The Better YouTube Channel Details API. It's been a real adventure getting all those YouTube channel details like social media links, email addresses, avatars, RSS feeds, and subscriber stats.

Guess what? It's time to roll out our baby to the world - we're hitting PyPi with our package! It's not just about bragging rights; we're here to lend a hand to fellow coders. We've cooked up this nifty library so you can plug it into your apps without breaking a sweat. Cheers to smoother coding days ahead!

creating the package structure and writing code to communicate with the API
testing the solution
👉 we are here: publishing our work on pypi.org

setup.py - necessary information about the package

So let’s create the setup.py file directly in the project directory

We will be using a template like the one below. It contains all the important information, so in my opinion, this example has everything we need:

from setuptools import setup, find_packages

setup(
    name='example',
    version='0.1.0',
    author='author',
    author_email='author@example.com',
    description='short description',
    long_description=open('README.md').read(),
    long_description_content_type='text/markdown',
    url='https://example.com',
    packages=find_packages(),
    install_requires=[
        # Package dependency list, e.g 'requests >= 2.20.0'
    ],
    classifiers=[
        'Programming Language :: Python :: 3',
        'License :: OSI Approved :: MIT License',
        'Operating System :: OS Independent',
    ],
    keywords=['example'],
    python_requires='>=3.6',
)

We will closely examine the setup and present the best practices for each property!

Best Practices

👉 Name

Simplicity is Key: Pick a name that's easy to remember and reflects your package's functionality.

Check for Uniqueness: Make sure your chosen name isn't already in use on PyPI to avoid naming conflicts.

Lowercase Preference: Typically, Python package names are all lowercase, following a common Python packaging convention.

No Special Characters: Use only letters, numbers, and underscores. Avoid characters like hyphens, as they can make importing the package more difficult.

Descriptive and Relevant: Choose a name that gives a hint about what your package does. Steer clear of names that are too generic or ambiguous.

Concise and Memorable: Aim for a name that's short and sticks in the mind. Long or complex names can be hard to remember.

Avoid Trademark Issues: Make sure your package name doesn't infringe upon existing trademarks or brand names.

Our choice:

Following the instructions above, we are leaning towards the name: apiharbor_youtubeapi, because it combines username with "youtube" and "api," clearly indicating its purpose and origin.

👉 Version

Choosing the right version number for your Python package is important for effective version control and to communicate the nature of changes to users. Here are some best practices for versioning your package:

Use Semantic Versioning (SemVer):

Major Version (X.y.z): Bump this up when you make big changes that aren't backward compatible. Think of it as a 'new era' for your package.

Minor Version (x.Y.z): Increase this when you add cool new features, but everything old still works fine.

Patch Version (x.y.Z): This one's for those little bug fixes and tweaks that don't change the features.

Starting Point: If your package is all grown up and stable, kick off with 1.0.0. If it's still a baby (in early development), start with something like 0.1.0.

Pre-Release Fun: Got a beta or alpha version? Tag it onto the end like 1.0.0-beta. It's like giving your users a sneak peek.

Post-Release Adjustments: Need to tweak a release without a big fuss? Use post-releases like 1.0.0-1 for those minor changes, maybe a typo fix in your documentation.

Changelog Is Your Friend: Keep a log of what you change or fix. It's super helpful for users and fellow developers to track what's new or different.

Stay Consistent: Picked SemVer? Great! Stick with it. Consistency is key.

No Wild Jumps: Avoid crazy jumps in version numbers. Each increment should make sense.

Define Your Public API: Make it clear what's in your public API and how you plan to keep it stable. This guides your versioning strategy.

Remember, version numbers are like signposts for users – they tell them what to expect with each new update. Keep it clear and sensible!

Our choice:

We will set version 1.0.0 as it is the first production version. Later, we will adhere to the semantics and best practices mentioned above.

👉 Author

You might be wondering, it's just the author field, what could be important here? Choosing the right author can actually be a challenge. Here are some best practices to follow when specifying an author:

Go Real with Names: Using your real name adds a touch of professionalism and trust. If you're in a team, you might want to list the lead dev or the project boss.

Keep It Uniform: Got a bunch of packages? Stick to the same name across the board. It helps users and contributors spot your work in different places.

Shoutout to Co-Authors: Working with a cool team? Give them a nod. But remember, the author field usually has just one name or entity. You can always detail everyone else's contributions in a CONTRIBUTORS file or the docs.

Representing an Org? Use Its Name: Publishing on behalf of a company, university, or open-source group? Use that name. It's pretty standard for projects developed under an official banner.

Emails: Handle with Care: Including an email? Make sure it's one you set up for the project or can handle public emails. Watch out for spam risks!

Privacy Matters: If you're worried about privacy or other personal issues, a pseudonym is totally fine. Just keep it professional and consistent.

Change of Guard? Update the Name: If there's a new sheriff in town (aka a new maintainer), update the author field. Maybe give a shout out to the original author in the docs.

Stay Professional: This field is out there for all to see in package directories and repos. A professional touch can really make a difference in how people view your package's reliability.

Remember, the way you present the author info can say a lot about your package. Keep it clear, respectful, and professional!

Our choice:

As we can see, author is not so obvious, but in our case, we will simply set it to: apiharbor. However, it's good to be aware of the things mentioned above.

👉 Description

A very important thing. The description must attract developers and encourage them to install our package. After all, we want to clearly show them that using our library will make their lives easier. What should guide us? Here are our best practices:

Short and Sweet: Nail your description in just a few words. It should quickly let users know what your package is all about, in plain language.

Keyword Magic: Sprinkle in those relevant keywords. They're like beacons for users and search engines, guiding them to what your package offers.

Jargon? Just Say No: Unless you're talking to a niche crowd, keep the tech talk to a minimum. Clear and simple is your best bet.

Showcase the Wow Factor: What's special about your package? Does it solve a tricky problem? Add a sparkle to something ordinary? Let that shine through.

Grammar Police: Polish your description. No typos, no grammar bloopers. It's like dressing your package for success.

Language Harmony: Stick to one language. If your code comments and docs are in English, your description should be too.

Tone It Right: Keep the vibe professional, tailored to who you're talking to.

Stay Current: Evolved your package? Give your description a makeover too. Keep it in sync with what's new or different.

Keep It Real: Don't oversell. Promise what you can deliver, or you might end up with unhappy users.

Build Trust: Especially for packages aimed at a broad audience, your description should radiate confidence about your package’s stability and usefulness.

Remember, your description is like the front door to your package. Make it inviting, clear, and true to what's inside!

Our choice:

Following these practices, we will set the description:

Want to dive deeper into the YouTube scene? Our YouTube Channel Details API is just what you need, especially if you're a marketer, researcher, or content creator. It's not just about getting contact info; it's about discovering those little gems like social media and location details of YouTube channels. Imagine the possibilities - like when one of our users found the perfect collaboration opportunity just by using these insights!

A big advantage of it is that it's short and clear to understand. Right away, you can see who it's intended for and what it does.

👉 Long Description

Here are two properties to be filled

long_description=open('README.md').read() - path to the README file
long_description_content_type='text/markdown', - content format

Let's take a look at the best practices we use.

Snappy Title: Kick off with a title that's both clear and catchy. It should give a snapshot of what your project is all about.

Elevator Pitch Description: In just a few sentences, highlight what your project does and its coolest features. Think of it as your project's elevator pitch.

Easy-Peasy Setup: Guide your users through a hassle-free installation. Simple steps, commands to run, or download links will make it a breeze.

How-to-Use Demo: Show off how your project works. Include code snippets, command-line examples, or even screenshots for a quick visual guide.

Dependencies List: Got other tools or libraries your project leans on? List them out clearly along with installation tips.

Config 101: If your project needs some setting up, walk your users through it with detailed instructions.

Test Run: If your project has automated tests, explain how to run them. It's like a health check for your project.

Join the Club: Invite others to contribute and lay out the ground rules in your CONTRIBUTING.md. Collaboration makes the project world go round!

Version Chronicles: Talk about your versioning system, if you have one. It's like telling the history of your project's evolution.

Cheers to the Team: Acknowledge the brains behind the project. List the authors and give a shout-out to contributors.

License Lowdown: Include your project's license details – a brief note and a link to the full text should do the trick.

FAQs Corner: Tackle those frequently asked questions or common hiccups users might run into.

Got Questions? Get in Touch: Provide contact info for support or inquiries. It's always nice to have someone to reach out to.

Badge Bonanza: (Optional) Flaunt those badges! They're like little trophies showing off your project's health or status.

Show and Tell: If it makes sense, add visuals like screenshots, gifs, or videos to showcase your project in action.

Global Reach: If your project speaks multiple languages, mention the available translations and how to switch them.

What’s Next? Got plans for your project? Share your roadmap or future dreams – it's exciting to see where things are headed.

Remember, your project documentation is your chance to make a great first impression. Make it friendly, informative, and engaging!

Our choice:

We won't paste the content here because it would be a bit (just a tad ;)) over the top, but I encourage you to check out our README.md

👉 Keywords

Keywords are the last property we'll discuss, as the rest is purely technical and there's nothing groundbreaking there, you just need to set the remaining values correctly 😊 and that's it.

Our best practices for selecting keywords are:

Spot-On Selection: Pick keywords that are like a bullseye for what your project is all about. Think of functionality and purpose.

Nail the Specifics: Choose terms that precisely paint a picture of what your project can do. It's like giving someone a mini-tour through its features.

What Would Users Type?: Think about the words your future fans might use when they're on the hunt for a project like yours. Those are your golden keywords.

Mix It Up: Blend both broad and narrow terms. It's like casting a wide net, but with some targeted spots.

Quality Over Quantity: It’s tempting to throw in a kitchen sink of keywords, but resist the urge. A well-thought-out, concise list is way more effective. Aim for that sweet spot where you've covered the essentials without going overboard.

Remember, picking the right keywords is like setting up signposts that lead straight to your project. Make them count!

Our choice:

keywords = [
    "youtube",
    "api",
    "youtube-api",
    "channel-details",
    "youtube-data",
    "youtube-analytics",
    "contact-information",
    "social-media-analysis",
    "youtube-marketing",
    "content-creation",
    "influencer-research",
    "video-analytics",
    "youtube-content",
    "media-analysis",
    "digital-marketing"
]

That will be perfect 🙂

Let's put everything together

from setuptools import setup, find_packages

setup(
    name='example',
    version='0.1.0',
    author='author',
    author_email='author@example.com',
    description='short description',
    long_description=open('README.md').read(),
    long_description_content_type='text/markdown',
    url='https://example.com',
    packages=find_packages(),
    install_requires=[
           ],
    classifiers=[
        'Programming Language :: Python :: 3',
        'License :: OSI Approved :: MIT License',
        'Operating System :: OS Independent',
    ],
    keywords=['example'],
    python_requires='>=3.6',
)

Publishing the Package!

The first thing we need to do is register at PyPi

Then, we launch the command line and navigate to the directory where we have setup.py. Next, we run a command to ensure we have the latest installation package installed:

\ApiHarbor\libs\youtube_channel_details_api>python -m pip install --upgrade build

Now, we need to generate the distribution archives that we will publish. We do this using the command:

python -m build

The build has finished. Let's check if everything was generated correctly by entering the command:

twine check dist/*

Everything looks great!

Now that we have the distribution files, we need to install twine as it's needed to upload the distribution package. We enter the installation command:

python -m pip install --upgrade twine

✋ Token needed!

PyPi has changed its authentication system. Now, we won't publish by providing our username and password for the account, but we need to do it through API tokens.

First, we need to create the token by entering here:
https://pypi.org/manage/account/token/

Then, let's save it somewhere on the side so we don't lose it.

Now, the most important part, the command to publish our package:

python -m twine upload --repository pypi dist/*

After entering the command, you will be prompted to enter the username. There, you should type: __token__
yes, __token__, always enter __token__

and the password, which is the previously saved token, including the prefix: pypi-
This is very important

Note! If we want to publish on testpypi, we need to create an account (register) at https://test.pypi.org/

pypi (production) and testpypi (test) are separate from each other, so the generated tokens will not work in both places. This needs to be kept in mind, because during the upload, we might encounter a situation where we provide the correct auth data but still receive the response:

HTTPError: 403 Forbidden from …

Summary

That's all from our series of posts about creating and publishing your own Python package. We went through the journey from setting up the project structure, writing the code, and its tests, to publishing the package. Now, programmers around the world can breathe a little easier thanks to us.

You can see our work here:

💚 Thanks for your time and see you!

p.s. I hope you enjoyed the style and examples. If possible, please give a thumbs up, comment, or any kind of reaction! It fuels me for future posts. Follow me to make sure you don't miss anything 🚀

Get YouTube Channel Details API: Testing Connection

apiharbor — Wed, 27 Dec 2023 16:10:21 +0000

Hi,

In our previous post here, we built the framework for a Python package that communicates with the API at The Better YouTube Channel Details to retrieve YouTube channel details. If you haven't read the previous part, I highly recommend it!

Let's look at the roadmap to see where we are now:

creating the package structure and coding for API communication.
👉 we are currently here: testing our solution
next, we'll publish our work on pypi

Today, we're going to:

create a function that will connect to the API endpoint
test the implementation

Let's get started!

Everyone ready? Camera! ACTION! 🎬

📡 Get Youtube Channel details by using `__get_request`

Previously, we implemented the __get_request function, which connects to the API and returns data in JSON format. We'll use it to fetch the details of a YouTube channel from the API.

In the API documentation, we see that the endpoint is located at:
https://the-better-youtube-channel-details.p.rapidapi.com/GetChannelDetails
and it accepts a query parameter UrlOrUsername. The endpoint only supports the GET method.

With this knowledge of the API, let's write a function:

   async def get_channel_details(self, urlOrUsername) -> any:
        response = await self.__get_request("/GetChannelDetails", urlencode({'urlOrUsername': urlOrUsername}))
        print(response)

In the previous post, when we were implementing __get_request, we explained why this function would take a query: dict parameter. Briefly, it's because urlencode, which is used for encoding special characters, returns them in the form of a dict.

👨‍💻 Let's test the code!

Phew, now we need to check if everything works correctly. We'll use tests for this task. Yes, I know, "test-first". But in such a project, let's be realistic - we write tests (like a BOSS) AFTER coding 😊 We write them only to check if we haven't made any mistakes and if the code works as it should.

We open a file tests/tests.py. At the very beginning of the file, we add an import line:

from src.youtube_channel_details_api_client_apiharbor.api_client import YouTubeChannelDetailsApiClient

print("it works!")

It's very important! Pay attention to how the from construct looks, and then look at the structure of our project:

We open cmd and navigate to the directory \libs\youtube_channel_details_api, then write the command to run the test: python -m tests.tests
And we should see the message: "it works!"

When everything works we can move on. Let's write a simple test to check if data fetching from the API works.

api = YouTubeChannelDetailsApiClient("YOUR_RAPID_API_KEY")

async def test_get_channel_details():
  await api.get_channel_details('@MrBeast')

async def main():
  await test_get_channel_details()
  return None

asyncio.run(main())

We run it using the previously mentioned command:
python -m tests.tests
in the directory \libs\youtube_channel_details_api and here is the result:

{'description': 'OK', 'status': 200, 'data': {'channel_url': 'https://www.youtube.com/channel/UCX6OQ3DkcsbYNE6H8uQQuVA', 'channel_name': 'MrBeast', 'channel_id': 'UCX6OQ3DkcsbYNE6H8uQQuVA', 'joined_date_text': 'Joined Feb 20, 2012', 'channel_country': 'United States', 'rss_url': …

🦾 We're the best! Everything works as it should, but we want to make our work easier in other projects. Therefore, we will do mapping from JSON to OBJECT.

🔄 Mapping plain JSON to python OBJECT

Let's go back to our get_channel_details function.

async def get_channel_details(self, urlOrUsername) -> any:
        response = await self.__get_request("/GetChannelDetails", urlencode({'urlOrUsername': urlOrUsername}))
        print(response)

Everything is going well, but we still need to map JSON. We'll use the pydantic package for this task. Let's install it by running the command: pip install pydantic.

Now let's start coding the mapping. We add a directory src/schemas, where we'll put: base.py, which will be the main model from which every class in the schema will inherit.

from pydantic import BaseModel

class BaseModelORM(BaseModel):
    class Config:
        from_attributes = True

We create a new schema schemas/channel_details.py.

from .base import BaseModelORM

class ChannelDetails(BaseModelORM):
    status: int
    description: str

So far, we will only map these two fields: status and description. We need to make sure that everything works. Only then will we map all the fields.

Let's go back to api_client.py and import the ChannelDetails schema.

from .schemas.channel_details import ChannelDetails

and modify the get_channel_details function so that it returns a ChannelDetails object created from the JSON received from the API.

async def get_channel_details(self, urlOrUsername) -> any:
 response = await self.__get_request("/GetChannelDetails", urlencode({'urlOrUsername': urlOrUsername}))
        return ChannelDetails.model_validate(response)

The final step is to modify the test_get_channel_details test.

async def test_get_channel_details():
    r = await api.get_channel_details('@MrBeast')
    assert r.status == 200

Run python -m tests.tests and... nothing appears. That means everything is working! Otherwise, we would have received an error. To confirm this theory, let's change the assert in the test to

    assert r.status != 200

After running the test, we are greeted with a beautiful error:

assert r.status != 200
AssertionError

All that's left for us to do is to complete the mapping for ChannelDetails.

Just kidding. We won't be doing this mapping manually; instead, we'll use a tool available at https://jsontopydantic.com/. You just need to input your JSON, and the tool will generate the schema for you.

Recap

Let's summarize what we managed to do today:

We wrote the get_channel_details function, which calls __get_request to fetch YouTube channel details.
We also wrote a test for it to check if everything works OK.
We implemented mapping from JSON to a Python object.

What will we do next time? Actually, the whole package is ready, and all that's left is to publish it on Packagist.

Thanks for your time and see you next time!

Building Python Package: API Client for YouTube Channel Details (RapidAPI)

apiharbor — Thu, 21 Dec 2023 15:07:31 +0000

Hi!
Today, we're going to work on creating a Python 3 package to facilitate access to an API for fetching YouTube channel details (The Better YouTube Channel Details). Even if the topic of API communication doesn't interest you, you might enjoy the presented complete process of creation.

The entire content will be divided into three separate posts, as I don't want to clutter your time with one large monolith.

👉 we are here: creating the package structure and writing code to communicate with the API
testing the solution
publishing our work on pypi.org

Don't frown! I invite you on an exciting adventure from which you'll surely learn something.

Everyone ready? Camera! ACTION! 🎬

🧬 The Project Structure

We're creating the structure of our package in Python 3

Every package must adhere to a specific directory and file structure. According to the official documentation.

packaging_tutorial/
├── LICENSE
├── pyproject.toml
├── README.md
├── src/
│   └── example_package_YOUR_USERNAME_HERE/
│       ├── __init__.py
│       └── example.py
└── tests/

This is how the package should look.

Our API will be relatively very simple:

we will only connect to the API
fetch JSON data
map JSON to an object so that it can be easily used in other applications

Let's create the file structure of our project.

🧙 Doing some magic

Looks great, so let's move on to writing the code, and we'll handle the metadata files later. As programmers, we love writing code, so anything not related to code isn't as appealing to us 😈

⌨️ "Pressing (random) keys"

So, let's program! That's what we're paid for (right...? right!?)

We're adding a file src/api_client.py. This file will contain all the communication with the API and the mapping of the response. The constructor of the class should accept a rapid_api_key, which we can obtain. How to do it? It's simple:

✔️ register (for free of course)
✔️ move to the API page and click on Test Endpoint
✔️ on the same page, grab the displayed value of X-RapidAPI-Key, this is our rapid_api_key

Great, let's write the code:

class YouTubeChannelDetailsApiClient(object):
    def __init__(self, rapid_api_key: str):
        self.rapidapi_host = 'the-better-youtube-channel-details.p.rapidapi.com'
        self.headers = {
            "X-RapidAPI-Key": rapid_api_key,
            "X-RapidAPI-Host": self.rapidapi_host,
        }

Our structure has changed

Looks decent. There's nothing particularly interesting in it 🥱 a bit dull.

We need a function that will query the API. We'll use the aiohttp package for assistance. This package provides us with an HTTP client for communicating with the API.

✋ Before we proceed, we need to install this package:
pip install aiohttp
so we can create HTTP requests.

Our function for communicating with the API will be named __get_request. From the name, it's clear that it will be a private function accessible only within api_client.

The function should accept path, which is the path to the API endpoint, and query. It's important to note that query should be of type dict. Why dict and not, string? We want to encode each parameter input by the user, and we'll use the urlencode function for this, which accepts a dict, not a string.

Okay, but what should the __get_request function return? The natural instinct is a string, so we'll set it to return a string (wow, what a surprise! 😉)

Let's write the header of the __get_request function:

async def __get_request(self, path: str, query: dict) -> str:

Moving on to programming, which is what we love the most! ;) the __get_request function should:

build the URL to the API endpoint
query the API
in case of a network error, retry the request after waiting 300 milliseconds
in case of an API error, throw an exception

Let's start writing the code for this function. Remember, we're using aiohttp for the HTTP client, and we'll need to handle retries and error checking.

    async def __get_request(self, path: str, query: dict) -> str:
        url = URL(
            host=self.rapidapi_host,
            path=path,
            query=query,
            scheme="https"
        ).as_string()

        session_timeout = aiohttp.ClientTimeout(total=45.0)
        is_ok = False

        while True:
            async with aiohttp.ClientSession(headers=self.headers, timeout=session_timeout) as session:
                async with session.get(url=url) as response:
                    try:
                        json_response = await response.json()  
                        if response.status == 200:  
                            is_ok = True
                    except aiohttp.client.ContentTypeError:
                        continue
                    if is_ok:
                        break
            await asyncio.sleep(0.3)

        return json_response

Let's check to make sure we have all the necessary imports added:

import asyncio
import aiohttp

from urllib.parse import urlencode
from purl import URL

Sure, let's also ensure we have all the necessary packages installed:
✔️ pip install asyncio
✔️ pip install aiohttp
✔️ pip install purl

The code looks good (or even great!), but does it work well? That's the eternal question we'll only answer by testing it ourselves.

But that will come in the next post, so stay tuned!

I hope you enjoyed the style and examples. If possible, please give a thumbs up, comment, or any kind of reaction! It fuels me for future posts. Follow me to make sure you don't miss anything 🚀

Thanks for your time and see you in the next post!

Building a Gateway to Netflix API: A Developer's Guide

apiharbor — Mon, 20 Nov 2023 09:36:47 +0000

Introduction: Creating in C# .NET Netflix API Gateway

In this article, we embark on an exciting journey to create a C# API client that interfaces with the Netflix API. It's important to note that Netflix doesn't offer an official API, so we'll be utilizing a set from RapidAPI. Among the options, DataOcean's Netflix API emerged as my top pick for several compelling reasons:

Its novelty often translates to better features.
The simplicity is key — with just 7 endpoints, it covers nearly all desired functionalities.
Affordability is a great plus.
Rapid performance seals the deal.

With these criteria in mind, let's dive in!

Setting Up Our Project in Visual Studio

First things first, we'll adhere to a naming convention for clarity and organization: ApiHarbor.RapidApi.Author.ApiName.

Our project's initial layout looks fantastic and promising. The guiding principle here is "less code, more efficiency." At this point, our codebase is a clean slate, perfectly set up for our next steps 😉.

Now, let's break this perfection by adding the code 😉.

Crafting the NetflixApiClient.cs: Connecting to Netflix API

To query an endpoint on RapidApi, two additional header values are crucial:

X-RapidAPI-Key
X-RapidAPI-Host

You can find these in the Code Snippets section on the API's webpage - https://rapidapi.com/dataocean/api/netflix99

Our NetflixApiClient constructor should definitely accept a rapidApiKey for use in requests. Let's consider if we need anything else. For sure something that communicates over http/s. In C#, there are several methods for this, we can use:

We wouldn't want to restrict the user to a specific method, so our constructor will accept an IWebClient interface. This way, users can choose their preferred implementation. A logger would also be handy to know what's happening during API usage. We'll follow a similar approach as before, providing a custom ILogger interface, compelling the user to implement it.

Implementing IWebClient

IWebClient should be straightforward, with a single method to retrieve content from a given URL and the ability to add headers to the request.

Implementing ILogger

Here, we aim for simplicity. Our logger should have two methods: one for informational messages and another for handling exceptions.

Returning to our NetflixApiClient.cs, let's implement what we've outlined so far.

With the current implementation, we meet all our initial objectives:

Flexibility in passing any http/s communication implementation.
Freedom from being tied to any particular logger implementation.
The constructor accepts our X-RapidAPI-Key.

Let's move on to the more exciting parts! 🔥

Implementing Netflix API Methods

The Netflix API we're working with provides seven endpoints:

Search titles - title search (surprise! 😃)
Title lists - returns titles according to defined parameters
Title details - returns title details based on the ID from Search title
Similar titles - returns similar titles also with ID received from Search
Title credits - returns a list of actors and people working on the title
Title media - returns a listing of images, posters, videos
Person details - retrieves information about a given actor or team member. Accepts ID received from Title credits.

As our first method to implement, let's choose Search title, as the other endpoints require IDs returned by this method.

Netflix API: Search titles and Implementation

The Search titles endpoint accepts several parameters, including:

query - searched phrase
order - sorting of results
title type - option to return results only for movies or TV shows or all (All)
country
language
release year (from/to)
rating (min/max)
token - for the next page of results

Let's make a sample request and examine the response from Search titles.

Key Observations:

Status information is provided (e.g., status: 200 for success).
Relevant data is assigned to data.
Separate pagination property includes a prepared URL for the next page and next_page_token.
The total number of results and pages, as well as the number of titles returned per response, are provided.

Inspecting a single title element reveals:

This gives us a good understanding of Search titles. Let's get to the implementation.

Mapping the Response

We'll create a new class to map the JSON response from the API to a SearchTitlesResponse object. In today's world, manual JSON mapping is a thing of the past. Tools like json2csharp make this task a breeze. Let's use it to generate our response class.

Copy the entire JSON and then paste it into json2csharp and click on Convert.

A beautiful response class has been generated for us. We will further enhance it by adding nullable **fields and using **PascalCase

Now it's perfect! Just take a look at the response.

Our class is ready, let's integrate it into our project.

As we see something is missing. To use JsonProperty, we need to install Newtonsoft.Json.

And by the way, we will implement a static method that will convert (deserialize) pure JSON in text form into a SearchTitlesResponse.Root object.

The structure of our project currently looks like:

Great! Now that we can map the JSON to SearchTitlesResponse, it's time to fetch the JSON from the Netflix API.

Let's go to NetflixApiClient and implement the method.

Remember, Search titles can accept numerous parameters, so let's get those implemented.

Quite a long process. Well, let's move on…

However let's STOP here! Instead of building a raw URL string in the client, let's create a separate SearchTitlesRequest class that handles query parameters and returns a formatted URL for communication with the Netflix API.

Let's add another method that will return joined parameters for us.

Yes. In this way, I avoid writing long strings, I prefer to put each parameter separately into an array and then join them with &. It looks better, right? 😃 Let's look at the full implementation of SearchTitles.

We can call the SearchTitles method by passing a SearchTitlesRequest object or using ordinary parameters.

Now the handling of the Search title endpoint looks awesome!🔥

Making IWebClient and ILogger Optional for the User (Dependency Injection)

Before testing our Search method, let's modify one assumption. We gave users the option to implement their own http/s communication and logger. But not everyone might want to do this. Some might prefer a straightforward way to fetch data without extra implementation. Let's accommodate this preference.

Implementing Default WebClient

We add a new DefaultWebClient class in Infrastructure.Implementations, using HttpClient for requests.

Implementing Default Logger

Similarly, we add a DefaultLogger class in the same namespace, providing the simplest implementation of the ILogger interface.

The default logger will simply display messages in the Console. Users can always implement their own logger for different outputs, like file logging or database storage.

Modifying NetflixApiClient Constructor

Since we're not enforcing the use of custom IWebClient or ILogger, we need to adjust the constructors of NetflixApiClient.

With these new constructors, users now have the choice to use the defaults or implement their own!

Testing Search Titles

To test the Netflix API, all we need is the X-RapidAPI-Key and some code.

Running the console application…

… yields our results. 🔥 Everything works as expected. Great job 🤝

Let's also test fetching subsequent pages of results using the provided URL.

We need to modify NetflixApiClient to add a simple variant of the SearchTitles method, named SearchTitlesByUrl, accepting the next_page_url.

Let's modify the test code a bit more in the console application. The modification concerns querying the next page (we have it at hand in NextPageUrl). The querying loop will operate until Data is not empty. Simple and effective 👌

Running the code with modification from above…

…gives us correct results. We can observe this through the titles come from the next (second) page. Brilliant!

What's next? I believe it's time to tackle the Title details endpoint.

What's next?

I believe it's time to tackle the Title details endpoint.

Netflix API: Title Details and Implementation

From the RapidApi documentation for Netflix API, we know that the Title details endpoint requires an id parameter.

As we remember, we can find the id in Search title and List titles. Alright, let's start with mapping the response from Title details. We will use the knowledge we have already acquired!

Visit the Netflix API page on RapidApi.
Choose the Title details endpoint and execute it.
Copy the JSON result.
Use json2csharp to generate the TitleDetailsResponse class.
Remember to set Property Settings as follow
We paste the JSON and click 'Convert' button.
We create a new class in Responses: TitleDetailsResponse and implement the Create method (as before).

Let's see how it looks now

JSON to response object mapping seems to be ready!

Now let's implement the API request method in our NetflixApiClient.

Yes, this simple code is sufficient. This time, we won't implement the creation of the API URL in the response class (TitleDetailsResponse), as the needed URL is very simple. But of course, following good practices, we should do so… Anyways! We need the test code to check if getting TitleDetails works.

And there you have it, a quick and efficient implementation! 😊

Conclusion

Today, we nearly completed an entire library for interacting with the Netflix API.

We added default classes for http/s communication with API and a console-based logger.
By using Dependency Injection, we provided the option for users to create their own versions of an HTTP client and logger through our interfaces IWebClient and ILogger.
Responses are neatly mapped from raw JSON text to Response objects with the help of the json2csharp.com
And the most important result of the project: we are able to very easily retrieve data from the API using our client class - NetflixApiClient.

Everything went smoothly and easily… perhaps even too easily 😉
You can check out the entire project on GitHub:
https://github.com/apiharbor/ApiHarbor.RapidApi.DataOcean.NetflixApi

Next time, we'll build a sample project using this library… OR! we'll write another article expanding the library with some additional interesting features. We'll see.

Thanks for your time ❤️ See you!
Follow me to not miss out on future updates! 🔥

DEV Community: apiharbor

Analyzing Likes Using Instagram API with python - part 3

Analyzing likes using Instagram API with python - part 3

Save requests to Instagram API by adding file caching

Creating plain old python objects (POPO)

Analyzing data from the Instagram API

Displaying the chart based on

Summary

How to create an Instagram API client in python: a step-by-step tutorial

How to Create an Instagram API Client in Python: A Step-by-Step Tutorial - part 2

Our Goal

What value will this application provide?

Necessary Endpoints

Implementation in RapidApiClient Class

Modify the get_user_posts Function

Write the Function to Return People Liking the Post

RapidApiClient Ready for Action!

How to Analyze Instagram Likes: A Simple Python App - part 1

How to publish a python package - Best Practices: A YouTube Channel API Example

setup.py - necessary information about the package

Best Practices

👉 Name

Our choice:

👉 Version

Use Semantic Versioning (SemVer):

Our choice:

👉 Author

Our choice:

👉 Description

Our choice:

👉 Long Description

Our choice:

👉 Keywords

Let's put everything together

Publishing the Package!

✋ Token needed!

Summary

Get YouTube Channel Details API: Testing Connection

📡 Get Youtube Channel details by using __get_request

👨‍💻 Let's test the code!

🔄 Mapping plain JSON to python OBJECT

Recap

Building Python Package: API Client for YouTube Channel Details (RapidAPI)

🧬 The Project Structure

We're creating the structure of our package in Python 3

⌨️ "Pressing (random) keys"

So, let's program! That's what we're paid for (right...? right!?)

Building a Gateway to Netflix API: A Developer's Guide

Introduction: Creating in C# .NET Netflix API Gateway

Setting Up Our Project in Visual Studio

Crafting the NetflixApiClient.cs: Connecting to Netflix API

Implementing IWebClient

Implementing ILogger

Implementing Netflix API Methods

Netflix API: Search titles and Implementation

Mapping the Response

Making IWebClient and ILogger Optional for the User (Dependency Injection)

Implementing Default WebClient

Implementing Default Logger

Modifying NetflixApiClient Constructor

Testing Search Titles

What's next?

Netflix API: Title Details and Implementation

Conclusion

📡 Get Youtube Channel details by using `__get_request`