DEV Community: Suhana Jabin

Our team procrastinated on writing bug reports. So we built an AI to do it for us

Suhana Jabin — Sun, 18 Aug 2024 16:04:58 +0000

1. Case Study : AI for creating Bug Reports

Team Problem:

Keeping track of multiple messages in a team can be quite difficult. Discord, a popular platform for team discussions, can soon become overwhelmed with lengthy conversations, making it difficult to find important messages and at times, you can even forget those discussed points .

Team Solution:

What if there was a way to automatically summarize these messages and convert them into actionable insights?

In this article, we will explore a basic approach to do that—using Python to scrape Discord messages, harnessing the summarization power of Google Gemini (a powerful tool that uses Machine learning models for text generation) , and effortlessly integrating these summaries into GitLab as issues. This process not only saves time but also ensures that your team's most important discussions are efficiently tracked and managed.

How it works

Our approach:

Fetching the discord message chunks from the server.
Summarizing it with the help of Gemini
Creating an issue in the Gitlab repo that contains the summary of selected discord issue.

Let's take a quick look on how to implement this idea:
The whole task is divided into 3 basic sections:

Watch Discord

We are utilizing Discord APIs to helps us gather messages from a Discord channel, so we can later process and summarize them using tools like Gemini. This way, we can quickly organize and make sense of large amounts of information.

We need to create a Bot to get the messages from Discord Channel .
So , let's start by creating a Bot in a new application.

a) Creating a new application

Login to Discord
Navigate to the application page
Click on the "New Application" Button on the top right corner.
Give the application name and create.

b) Setting up your Bot

Navigate to the Bot tab in application page
Provide the username and note the Bot Access Token as we need it in the future for connecting this Bot to the respective discord channel.
If in case you can't see the Bot Access Token , click the Reset Token to generate a new Bot Access Token.
If you want others to invite your Bot to any servers, make sure the public bot is ticked.

Make sure message content intent is ticked to enable your bot to receive messages.

Great! So now you have successfully set up your Bot account.

c) Inviting your Bot into your server

Head to the Oauth2 tab and navigate to the OAuth2 URL Generator section.
Click the Bot checkbox and Bot permission section will appear.
Upon clicking the bot checkbox, there will be another box for providing Bot permissions. Choose the permissions as per your usecase. Be careful when you provide the administrator permission to the bot.
You can see a link will appear in the generated URL section.
Open that url in a new tab and you'll be prompted to select the server.
After you select the server, click authorize and you're done with the Bot creation part!

d) The Coding part!

We need to create a Python script to scrap the discord messages in the specific channel.

i) Make sure you have the right permissions

We need the channel ID for scraping and it can only be obtained when you're granted administrator privilege.

ii) Install the required libraries

pip install discord

iii) Provide the Bot Access Token

bot_token = **os.getenv('DISCORD_BOT_TOKEN')

Bot Access Token is necessary to run the client.

iv) Giving the right permission to the client

intents = discord.Intents.default()

Discord Intents are a way of telling which events your bot wants to receive.
This line creates an Intent object with default settings and by default, the bot will receive a minimal set of events- messages,reactions and basic events.

v) Enabling the message intent

intents.messages = True

This line allows the bot to receive events related to messages.

vi) Configuring Bot Client

client = discord.Client(intents=intents)

This line configures the bot client with the right event permissions.

vii) Defining an event handler in Python


async def on_ready():
    print(f'Logged in as {client.user}')
    guild = discord.utils.get(client.guilds)  # Get the first guild (server) the bot is in
    if guild:
        print(f'Connected to guild: {guild.name}')
        for channel in guild.channels:
            print(f'Channel: {channel.name} (ID: {channel.id})')
    else:
        print('No guilds found.')

    channel = client.get_channel(channel_id)
    if channel:
        async for message in channel.history(limit=100):
            print(f'{message.author}: {message.content}')
    else:
        print('Channel not found.')

Firstly, the client retrieves the first guild/server it is connected to.
Secondly, it checks for the channel with the given channel ID among the list of channels, and if it matches, the client starts an asynchronous loop to fetch the last 100 messages.

To read the rest of the article, visit : https://journal.hexmos.com/bug-description-generator/

Learn How Docker Works via Mocker, a Tiny Python Implementation

Suhana Jabin — Sun, 10 Mar 2024 16:08:27 +0000

Introduction

How about creating a container on your own in a few simple steps?
Wait, what is a container? What is its significance?

A container can be described as a small package that holds all the stuff needed to run a program smoothly, no matter where we put it. Containerization has emerged as a key component of modern software development and deployment in the tech industry.

While many developers are comfortable using existing container solutions like Docker, there's immense value in understanding how containers work under the hood.

A container image is like a package containing everything needed to run an application, including code, libraries, and dependencies. It's arranged in layers, with each layer adding or modifying the previous one. These layers are stacked together to create the complete environment needed for the application to run.

Imagine you're baking a cake. Each ingredient you add flour, eggs, sugar, etc represents a layer in the container image. The final cake is like the complete container image, with all the layers combined to create the finished product. So, just as you can mix and match ingredients to create different cakes, you can layer different components in a container image to create various applications.

A container is a lightweight, portable, and self-sufficient environment that encapsulates an application and its dependencies, enabling consistent and reliable deployment across different environments.

So basically, you need a container image for the functioning of a container.

Whereas Docker is a popular containerization platform that simplifies the process of building, managing, and running containers.

Now, let's look into the basic terminologies regarding the container.

Understanding the basics

In Linux, containers rely on core building blocks such as cgroups and namespaces. These components are essential for tasks like managing resources, isolating processes, and controlling access to the file system, all tailored to suit our specific needs.

Let's take a closer look at namespaces

1. Namespaces

"Namespaces lets you see specific parts of a system."

Namespaces are a Linux Kernel feature that helps in isolating various aspects of a process. They help in creating isolated environments so that they don't interfere with other processes or the host system.

2. Control Groups

While coming to Control Groups, known as Cgroups, are created to set specific constraints around them. Say that you need to limit the memory usage or CPU utilization, we directly use cgroups for this purpose.

"Cgroups help in assigning certain resource restrictions that aid in effective process management and resource utilization."

3. Networking

Networking is a crucial aspect to enable communication between services, ensuring isolation and security, and facilitating scalability and flexibility in modern cloud-native applications.

So the networking part of the container aids in creating virtual network interfaces, manipulating the route table, creating network namespaces, and many more.

This will cover the basics for you, now let's kickstart our container coding journey from scratch.

Pulling the image from Repository

First and foremost, we need an image and this can be pulled from any of the available repositories. So we need a function to pull the container image from the repository.

When it comes to the image, there is another term known as manifest. Manifest contains all the related metadata, image layers, image configuration, OS and related architecture, etc.

These are the functions that are done mainly in the pull function:-

We need to authenticate with the Docker Hub registry to pull a Docker image from a specified repository.
After authentication we need to get the manifest from the repository. The manifest is fetched from the repository layer by layer.
Then these layers are saved within a directory as a JSON file and a separate folder containing the layer features and other additional information.

Rest of the article can be viewed from https://journal.hexmos.com/building-docker-container/