DEV Community: Md. Fahim Bin Amin

[Boost]

Md. Fahim Bin Amin — Sun, 05 Oct 2025 17:50:46 +0000

Why Cloud Incident Response is Critical for DevOps and IT Teams

Md. Fahim Bin Amin ・ Oct 4

Why Cloud Incident Response is Critical for DevOps and IT Teams

Md. Fahim Bin Amin — Sat, 04 Oct 2025 07:36:22 +0000

Recently major European airports including Heathrow, Brussels, and Berlin, experienced disruptions caused by a cyberattack on Collins Aerospace's cloud-based check-in system, resulting in flight delays and cancellations that affected thousands. This incident is not unique. In June 2025, Google Cloud faced a global outage impacting Gmail and Google Drive. Data breaches have exposed billions of credentials across major platforms, while ransomware and leaks challenged financial institutions and governments worldwide. (Source: Reuters, Bright Defense, Cyble)

These events highlight how frequently cloud incidents occur and the critical need for effective cloud incident response. This article will explain the concept, outline the response process, and review essential tools and best practices to help organizations prepare and react swiftly to cloud security incidents.

What is Cloud Incident Response?

Cloud Incident Response is a specific field of Cyber Security that includes detecting, containing and recovering from security incidents in cloud environments. It also involves a specific set of processes designed to help an organization identify potential threats, eliminate malicious activities, and recover from incidents in a structured, efficient, and timely manner.

Why Cloud Incident Response is Critical for DevOps and IT Teams

This is a very crucial component for all DevOps and IT teams as it serves as a cornerstone for maintaining system reliability and minimizing downtime.

A planned incident response system helps in the rapid detection, reporting and resolution of issues. It stops minor glitches from escalating into major failures.
Timely and effective responses reduce financial losses and operational disruptions.
Quick resolution of problems safeguards the service availability, and it strengthens the customer confidence in the organization's reliability and uptime.
Cloud related incident response demands specialized expertise and tailored processes that address the shared responsibility and cloud native security policies. That is why it cannot be resolved easily by only following traditional approaches.
Every new incident brings an opportunity to learn using post-incident reviews. It helps the team to uncover root causes, drive continuous improvements and enhance team practices.

If an organization has a good and well-structured incident management process, then it allows the team to respond swiftly and effectively.

Key Phases of Cloud Incident Response Process

Although there are no specific key phases in the cloud incident response process, we often divide it into distinct steps.

Detection and Alerting

The first step in incident response is recognizing that a problem exists. This is usually done through some monitoring tools, analyzing logs or automated alerts triggered by unusual changes in performance, security or availability.

Triage and Classification

Once an incident is detected, it must be evaluated to understand its severity and impact. This involves categorizing the incident and prioritizing it by urgency and business risk.

Containment and Mitigation

The next part of it is ensuring that further damage stops immediately. Containment actions may include isolating affected systems, revoking compromised credentials or rolling back potential problematic deployments in production. The goal is to prevent the incident from spreading and buy time for a permanent solution.

Recovery and Service Restoration

Once an incident is contained, teams work to restore the normal service. This may involve redeploying services, scaling backup systems or applying configuration fixes.

Postmortem and Continuous Improvement

After resolution of the incidents, the teams need to hold a postmortem to analyze the root causes, evaluate how well the response actually worked and identify potential improvements in the future. Also, learning from past incidents builds greater resilience against future problems.

Cloud Incident Response Best Practices

Here are some best practices for cloud incident response:

Define Clear Roles and Responsibilities

During an incident, instead of proper resolution, if the team spends time arguing over who is responsible for what, it can delay the entire recovery process, and the impact worsens. Clearly assigning roles ensures a well-organized and coordinated approach.

Use Infrastructure as Code (IaC) for Faster Recovery

IaC tools like Terraform, CloudFormation, or Pulumi allow teams to quickly and reliably rebuild and restore cloud environments using version-controlled templates. This reduces human-made errors and accelerates recovery after a failure or security incident.

Implement Automated Alerting and Escalation Policies

Manual monitoring is not sufficient at all in a dynamic cloud environment. Therefore, automated alerts help to detect issues in real time, and escalation policies ensure that the right team members are notified promptly.

Conduct Regular Runbooks and Chaos Drills

Runbooks offer clear and step-by-step instructions for common incidents, reducing uncertainty and stress under pressure. Chaos drills (which involve intentionally injecting faults or failures into a system to test its ability to withstand unexpected problems) and game days (planned simulations where both systems and teams are tested through realistic failure scenarios) actively simulate failures to test both system robustness and team readiness, helping to identify weaknesses and improve overall preparedness.

Integrate with Monitoring, Logging and IAM

Effective incident response depends on comprehensive visibility. Integration with monitoring and logging tools provides the data necessary to quickly identify root causes. Strong identity and access management practices ensure responders have appropriate access while protecting sensitive systems.

Tools to Support Effective Cloud Incident Response

If you want to respond well to cloud problems, then that means that you have to ensure the availability of the right tools to detect, understand, and fix the issues quickly. Here are some notable tools people use.

Monitoring and Observability

Tools like Datadog, Prometheus, and Grafana.
Show live data, spot unusual behaviour and provide easy-to-read dashboards.

Logging and Tracing

Services such as ELK Stack, Splunk, and AWS CloudWatch Logs.
Record detailed event information.

Alerting and On-Call Management

Platforms like TaskCall and PagerDuty.
Send alerts to the right people immediately.

Infrastructure as Code (IaC)

Tools like Terraform, Pulumi, and CloudFormation.
Help rebuild or update cloud resources fast.

Security and Identity

Utilize Identity Access Management (IAM), Secret Managers, and vulnerability scanners.
Protect systems from unauthorized access and weak settings.

When these tools work together smoothly, teams can respond more quickly and with greater confidence when cloud incidents occur.

How We Built Our Cloud Incident Response Process

Over the next few days I tested some other platforms, but none of them seemed to hit every box in our checklist. Some were missing heartbeats, some status pages or just did not offer enough in conditional routing and workflows. So, I started researching more until I came across TaskCall.

TaskCall had a different layout as well, but the structure of the platform actually allowed us to do more than we were able to with OpsGenie. We managed to deploy a full proof cloud incident response mechanism. Here is a quick summary of the flow we created:

We integrated with all our cloud monitoring services. We were using AWS CloudWatch and Datadog, both of which had built-in integrations with TaskCall. So, the set up was quite quick.
As alerts were generated, incidents were automatically created in TaskCall.

We used conditional routing to suppress false positives. This helped reduce noise and unnecessary interruptions.
TaskCall allowed us to automate validation checks and auto resolve incidents conditioned on their outcome through automated workflows. This was quite impressive as it meant that we could now reduce interruptions even further and only focus on incidents that mattered.

If the incident still remained open, then the on-call management configurations we set up with auto escalation would apply and the team responsible for the issue would be alerted.
While the team got assembled, TaskCall was also able to automatically identify impact on our upstream and downstream dependencies, making it easier for us to identify the root cause.
While all this was happening, it also automatically posted on our status pages (which were again hosted on TaskCall) so our stakeholders stayed updated, reducing the load on our customer support teams.

Conclusion

The workflow we were able to set up with TaskCall is a good example of cloud incident response for sophisticated teams. We built a workflow that utilized automation to identify issues where possible, minimize the time we spend on incidents and streamline communication across the board so we were not interrupted redundantly.

Cloud environments provide flexibility, scalability, and speed but also introduce new challenges and risks. Quick, effective incident response is essential to keep operations smooth and maintain customer trust. By following best practices, using proper tools, and embracing automation, DevOps and IT teams can resolve cloud issues faster and with greater confidence.

Thanks for reading. I hope this helps you to understand cloud incident response and how platforms reduce the hassle.

How to Make Images GHIBLIFIED!

Md. Fahim Bin Amin — Fri, 28 Mar 2025 17:05:13 +0000

Currently, Ghibli-type images are trending worldwide. Under the hood, they are nothing but a kind of image transformation, which you can think of as filters or any typical image transformation.

The main difference between regular filters and this is that it is done using AI explicitly. It also adds that special Studio Ghibli type nostalgic feeling around the image.

It is not that much earlier, the hype has escalated rapidly after this feature got released a few hours ago (by the time I am writing this article). People are going crazy finding the website or applications by using which they can transform their existing images into Studio Ghibli-style images.

Two of the most popular sources for doing that are ChatGPT and Grok.

However, today, I am going with Grok as I found that more feasible in terms of free usage right now.

If you are comfortable with watching a step-by-step video tutorial, then you can directly watch the following video I created for you.

The usage criteria are very simple. If you do not have an account yet, you just need to create one on Twitter/X. After signing into your Twitter/X account, you will instantly have access to Grok. You can also create an additional account to use explicitly on https://grok.com/.

Now, attach an image that you want to convert to a Studio Ghibli-style image. In the chatbox, simply write a prompt. For example, you could use the prompt Create a Ghibli-style image using this image.

After that, you have to give it some time as image generation is a very computationally heavy task on GPUs.

Usually, it provides two new images side by side. After the generation is successful, you can download the images!

That's it for today! I would recommend that you do not exploit this AI feature by doing illegal stuff. 😀

How to Unsave All Saved Posts on Facebook in a Few Simple Steps

Md. Fahim Bin Amin — Wed, 30 Oct 2024 15:27:58 +0000

If you're an avid Facebook user, you've probably saved countless posts, videos, and links to revisit later. But sometimes, these saved posts accumulate and become overwhelming. You may decide to unsave them all at once rather than manually unchecking each one, especially if you've amassed a large collection. Here's a step-by-step guide to bulk unsaving all your saved items on Facebook.

Warning:

Before proceeding, note that this method will unsave all the displayed items on the page permanently. Once unsaved, the items will no longer appear in your saved list. There’s no way to retrieve them unless you manually save each post again. Please use this method with caution.

Also, You might need to use allow pasting and hit the Enter key if Facebook warns you before applying any JavaScript commands in the console.

Step-by-Step Guide

Step 1: Scroll Through Your Saved Items

Head over to your Facebook saved items section. This can be accessed by clicking the saved section on the left-hand side of the homepage on the desktop version.
Scroll down to load and display all the saved items that you want to unsave. Facebook only loads a few items at a time as you scroll, so ensure you've loaded everything you wish to unsave.

Step 2: Open the Developer Console

To start the bulk unsaving process, you’ll need to use your browser’s developer console. Here’s how to do that:

On Google Chrome: Press Ctrl + Shift + J (Windows) or Cmd + Option + J (Mac) to open the console.
On Firefox: Press Ctrl + Shift + K (Windows) or Cmd + Option + K (Mac).

Once the console is open, you can start running the necessary JavaScript commands.

Step 3: Open the Context Menu for Each Item

You’ll first need to open the contextual menu (the three dots beside each saved post) for every item on the page. This is where Facebook allows you to unsave individual posts.

Copy and paste the following command into the console and press Enter:

Array.from(document.querySelector('[role=main]').querySelectorAll('[aria-label="More"]')).slice(1).map(e => e.click())

This command finds all the “More” buttons on the page and opens the contextual menu for each saved item.

Step 4: Unsave Each Item

Once the contextual menus have been opened for each saved post, it’s time to bulk unsave them. For that, run the following command in the console:

Array.from(document.querySelectorAll('[role=menuitem]')).map(e => e.click())

This command clicks on the "Unsave" option in every contextual menu that has been opened, removing the items from your saved list.

Important Reminder:

All the items that are displayed on the page will be unsaved permanently. Ensure that you’ve reviewed the items before proceeding with this method.

Final Thoughts

This method saves you the hassle of manually unsaving items one by one. Just remember to scroll through and load all the saved items before running the script to ensure nothing is left behind. Also, since this method affects only the currently displayed items, you may need to scroll and repeat the process if you have a lot of saved posts.

By following these steps, you can easily declutter your Facebook saved items and keep only what truly matters!

You can follow me on GitHub, LinkedIn, YouTube for getting more content like this. Also, my website is always available for you!

Cover: Photo by Nghia Nguyen on Unsplash

Highlight Specific Segment Block as Notice, Tip, Caution, Important & Warning in Markdown

Md. Fahim Bin Amin — Sun, 09 Jun 2024 12:01:14 +0000

Markdown is a very popular scripting language. It is used starting from writing documentation to even creating a complete website. Therefore, almost all of us frequently use this scripting language every once in a while.

However, there are some limitations to this language as well. In some cases, we can not add that much styling or modification to the writing in it. Luckily for us, there are 5 highlighting features for specific segment blocks as Notice, Tip, Caution, Important, and Warning. It is also applicable in GitHub MarkDown as well. In this article, I am going to talk about it in detail.

Video Walkthrough

If you like to watch a complete video with step-by-step guidelines, then you can watch the video right now!

"Note" Specific Block

If you want to highlight information that users should take into account, even when skimming, then it is appropriate for you!

Syntax

> [!NOTE]
> I want the readers to read it carefully as it contains many important docs.

Output:

You see that the preview already has a nice "Note" related symbol also!

If you want to write any Note related segment, then you need to start it with an angle bracket ( > ), and then you need to specify the highlighting block as Note with [!NOTE].
After that, you need to add an angle bracket ( > ) in each new line that you want to include in your specific "Note" block.

If you want to close the Note block, then simply remove the additional angle bracket in the new line. That's all!

"Tip" Specific Block

If you want to provide optional information to help a user to be more successful, then it is appropriate in those scenarios.

Syntax

> [!TIP]
> Use the command line to detect and resolve the errors!

Output:

You see that the preview already has a nice "Tip" related symbol also!

If you want to write any Tip related segment, then you need to start it with an angle bracket ( > ), and then you need to specify the highlighting block as Tip with [!TIP].

After that, you need to add an angle bracket ( > ) in each new line that you want to include in your specific "Tip" block.

If you want to close the Tip block, then simply remove the additional angle bracket in the new line. That's all!

"Warning" Specific Block

If you want to provide critical content demanding immediate user attention due to potential risks, then it is an appropriate block for you.

Syntax

> [!WARNING]
> DON'T DELETE THE `package.json` file!

Output:

You see that the preview already has a nice "Warning" related symbol also!

If you want to write any Warning related segment, then you need to start it with an angle bracket ( > ), and then you need to specify the highlighting block as Warning with [!WARNING].

After that you need to add an angle bracket ( > ) in each new line that you want to include in your specific "Warning" block.

If you want to close the Warning block, then simply remove the additional angle bracket in the new line. That's all!

"Caution" Specific Block

If you want to provide negative potential consequences of an action, then you can use this.

Syntax

> [!CAUTION]
> Don't execute the code without commenting on the test cases.

Output:

You see that the preview already has a nice "Caution" related symbol also!

If you want to write any Caution related segment, then you need to start it with an angle bracket ( > ), and then you need to specify the highlighting block as Warning with [!CAUTION].

After that you need to add an angle bracket ( > ) in each new line that you want to include in your specific "Caution" block.

If you want to close the Caution block, then simply remove the additional angle bracket in the new line. That's all!

"Important" Specific Block

If you want to provide crucial information necessary for users to succeed, then you can use this.

Syntax

> [!IMPORTANT]  
> Read the contribution guideline before adding a pull request.

Output:

You see that the preview already has a nice "Important" related symbol also!

If you want to write any Important related segment, then you need to start it with an angle bracket ( > ), and then you need to specify the highlighting block as Warning with [!IMPORTANT].

After that you need to add an angle bracket ( > ) in each new line that you want to include in your specific "Important" block.

If you want to close the Important block, then simply remove the additional angle bracket in the new line. That's all!

Conclusion

Thank you for reading the entire article. I hope you have learned something new here.
If you have enjoyed the procedures step-by-step, then don't forget to let me know on Twitter/X or LinkedIn. I would appreciate it if you could endorse me for some relevant skillsets on LinkedIn. I would also recommend you to subscribe to my YouTube channel for regular programming related content.
You can follow me on GitHub as well if you are interested in open source. Make sure to check my website (https://fahimbinamin.com/) as well.
Thank you so much! 😀

Default Parameter Value in JavaScript Functions

Md. Fahim Bin Amin — Tue, 21 May 2024 14:46:44 +0000

In JavaScript, we can define default values in the function's parameter to safeguard it from returning NaN.

Let me give you an example of this,

Let's say, we are using a function called sum:

function sum (a, b) {
    return(a + b);
}

This function simply receives two values as arguments and returns their summation value.

Therefore, we get:

sum(2, 3) // returns 5

However, for some reason, if the user does not provide the value of any parameter as an argument, then it becomes NaN as the default value of all the parameters is Undefined in JavaScript.

Therefore, the following scenario can happen:

Here, as we didn't provide the value for the second parameter in the argument, it takes the default value for variable b as Undefined. Therefore, 5 + Undefined returns NaN.

However, let's say, we provide a default parameter value for the second variable for now (b) to ZERO (b = 0), then we get the following output for the same input:

function sum (a, b = 0) {
    return(a + b);
}

sum (5);

Here, you see that we have explicitly specified the initial (default) parameter value for the variable b as 0. Therefore, if we do not pass any value during function calls, the default argument value for variable b becomes 0.

As 5 + 0 = 5, we get 5 as the output.

However, this does not change anything crucial other than safeguarding the function.

If we call the function with all the values in it via arguments, it works flawlessly.

function sum (a, b = 0) {
    return(a + b);
}

sum (2, 10);

Here, although the initial (default) value for the second variable was zero (0), the updated value was 10 which was passed during the function call as argument value. The updated value overwrites the initial/default value. Therefore, all the calculation works seamlessly.

Sometimes, we like to provide default values in all the function parameters if we want to avoid these Undefined type calculations in the output.

I hope you have learned something new today! Thank you for reading. 😊

Remove Unnecessary Warnings in Tensorflow GPU

Md. Fahim Bin Amin — Tue, 09 Apr 2024 09:07:32 +0000

If you don't want unnecessary warning messages to distract you when using Tensorflow GPU, simply use:

import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'

It won't show you the unnecessary warnings anymore like code block 1.

Skull Stripping 3D MRI Brain Image

Md. Fahim Bin Amin — Tue, 30 Jan 2024 11:25:11 +0000

What is Skull Stripping?

Skull stripping, also known as brain extraction, is a preprocessing step that removes the skull and other non-brain tissues from MRI scans. It's a crucial step in the analysis of many MRI neurological images, such as tissue classification and image registration.

Skull stripping is a key area of study in brain image processing applications. It's a preliminary step in many medical applications, as it increases the speed and accuracy of diagnosis.

Skull stripping involves segmenting brain tissue (cortex and cerebellum) from the surrounding region (skull and nonbrain area). It's a preprocessing step for the cortical surface reconstruction process. This procedure takes an intensity-normalized image and deforms a tessellated ellipsoidal template into the shape of the inner surface of the skull.

What are we going to do exactly with the 3D MRI Brain images?

I was researching on the early detection of the Alzheimer's Disease. Therefore, I was working on the 3D MRI images of the human brain. Therefore, let's say, I have the raw 3D MRI brain image like below.

The output would be like below.

I want to get the brain mask that has been applied in the skull stripping process on my raw 3D image.
I want the preprocessed skull-stripped image that only has the brain portion excluding any non-brain tissues.

Why Skull Stripping is a necessary thing in human brain-related research?

Skull stripping, also known as brain extraction or skull-stripped segmentation, is a necessary step in human brain-related research for several reasons:

Isolation of Brain Tissue: The skull contains bones and other tissues that are not relevant to many types of brain analysis, such as MRI or fMRI studies. Removing the skull allows researchers to focus specifically on the brain tissue itself, which is the primary object of study in neuroimaging research.

Improved Accuracy: Skull stripping improves the accuracy of brain imaging analysis by removing non-brain tissues that can interfere with the interpretation of results. This interference can occur due to artifacts or inaccuracies introduced by including non-brain tissues in the analysis.

Reduced Computational Load: Including the skull in the analysis increases the computational load required for processing brain images. By removing the skull, researchers can streamline the analysis process, making it more efficient and reducing computational resources.

Enhanced Visualization: Skull stripping improves the visualization of brain structures in neuroimaging data. It allows for clearer and more precise rendering of brain images, which is essential for accurately identifying and studying various brain regions and structures.

Standardization: Skull stripping helps standardize neuroimaging data processing pipelines across different studies and research groups. By employing consistent skull stripping techniques, researchers can ensure comparability and reproducibility of results, facilitating collaboration and meta-analyses in the field.

Overall, skull stripping is a critical preprocessing step in human brain-related research, enabling more accurate analysis, improved visualization, and enhanced comparability of neuroimaging data.

How can Skull Stripping be performed using Python?

There are many ways to apply skull stripping to 3D MRI images. There are also a lot of Python modules that help us to do that.

However, in this article, I am going to use a very simple code to apply the skull stripping on a basic level using ANTsPy.

For this, we are going to use a helper file that would help us scale up our process.

Let me give it a name, helpers.py.

Helpers

import matplotlib.pyplot as plt

from ipywidgets import interact
import numpy as np
import SimpleITK as sitk
import cv2

def explore_3D_array(arr: np.ndarray, cmap: str = 'gray'):
  """
  Given a 3D array with shape (Z,X,Y) This function will create an interactive
  widget to check out all the 2D arrays with shape (X,Y) inside the 3D array. 
  The purpose of this function to visual inspect the 2D arrays in the image. 

  Args:
    arr : 3D array with shape (Z,X,Y) that represents the volume of a MRI image
    cmap : Which color map use to plot the slices in matplotlib.pyplot
  """

  def fn(SLICE):
    plt.figure(figsize=(7,7))
    plt.imshow(arr[SLICE, :, :], cmap=cmap)

  interact(fn, SLICE=(0, arr.shape[0]-1))


def explore_3D_array_comparison(arr_before: np.ndarray, arr_after: np.ndarray, cmap: str = 'gray'):
  """
  Given two 3D arrays with shape (Z,X,Y) This function will create an interactive
  widget to check out all the 2D arrays with shape (X,Y) inside the 3D arrays.
  The purpose of this function to visual compare the 2D arrays after some transformation. 

  Args:
    arr_before : 3D array with shape (Z,X,Y) that represents the volume of a MRI image, before any transform
    arr_after : 3D array with shape (Z,X,Y) that represents the volume of a MRI image, after some transform    
    cmap : Which color map use to plot the slices in matplotlib.pyplot
  """

  assert arr_after.shape == arr_before.shape

  def fn(SLICE):
    fig, (ax1, ax2) = plt.subplots(1, 2, sharex='col', sharey='row', figsize=(10,10))

    ax1.set_title('Before', fontsize=15)
    ax1.imshow(arr_before[SLICE, :, :], cmap=cmap)

    ax2.set_title('After', fontsize=15)
    ax2.imshow(arr_after[SLICE, :, :], cmap=cmap)

    plt.tight_layout()

  interact(fn, SLICE=(0, arr_before.shape[0]-1))


def show_sitk_img_info(img: sitk.Image):
  """
  Given a sitk.Image instance prints the information about the MRI image contained.

  Args:
    img : instance of the sitk.Image to check out
  """
  pixel_type = img.GetPixelIDTypeAsString()
  origin = img.GetOrigin()
  dimensions = img.GetSize()
  spacing = img.GetSpacing()
  direction = img.GetDirection()

  info = {'Pixel Type' : pixel_type, 'Dimensions': dimensions, 'Spacing': spacing, 'Origin': origin,  'Direction' : direction}
  for k,v in info.items():
    print(f' {k} : {v}')


def add_suffix_to_filename(filename: str, suffix:str) -> str:
  """
  Takes a NIfTI filename and appends a suffix.

  Args:
      filename : NIfTI filename
      suffix : suffix to append

  Returns:
      str : filename after append the suffix
  """
  if filename.endswith('.nii'):
      result = filename.replace('.nii', f'_{suffix}.nii')
      return result
  elif filename.endswith('.nii.gz'):
      result = filename.replace('.nii.gz', f'_{suffix}.nii.gz')
      return result
  else:
      raise RuntimeError('filename with unknown extension')


def rescale_linear(array: np.ndarray, new_min: int, new_max: int):
  """Rescale an array linearly."""
  minimum, maximum = np.min(array), np.max(array)
  m = (new_max - new_min) / (maximum - minimum)
  b = new_min - m * minimum
  return m * array + b


def explore_3D_array_with_mask_contour(arr: np.ndarray, mask: np.ndarray, thickness: int = 1):
  """
  Given a 3D array with shape (Z,X,Y) This function will create an interactive
  widget to check out all the 2D arrays with shape (X,Y) inside the 3D array. The binary
  mask provided will be used to overlay contours of the region of interest over the 
  array. The purpose of this function is to visual inspect the region delimited by the mask.

  Args:
    arr : 3D array with shape (Z,X,Y) that represents the volume of a MRI image
    mask : binary mask to obtain the region of interest
  """
  assert arr.shape == mask.shape

  _arr = rescale_linear(arr,0,1)
  _mask = rescale_linear(mask,0,1)
  _mask = _mask.astype(np.uint8)

  def fn(SLICE):
    arr_rgb = cv2.cvtColor(_arr[SLICE, :, :], cv2.COLOR_GRAY2RGB)
    contours, _ = cv2.findContours(_mask[SLICE, :, :], cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

    arr_with_contours = cv2.drawContours(arr_rgb, contours, -1, (0,1,0), thickness)

    plt.figure(figsize=(7,7))
    plt.imshow(arr_with_contours)

  interact(fn, SLICE=(0, arr.shape[0]-1))

Additional required modules and libraries

We also need some modules and Python libraries so that we can create our model based on them.

I can simply create a text (.txt) file named requirements.txt where I can simply write down all the individual module/library names in separate lines.

ipykernel
ants
ipywidgets
matplotlib
opencv-python
jupyter
notebook
antspyx
SimpleITK
antspynet

Notebook

We can use VSCode or any other Python IDEs for writing our code. But I like to use the Jupyter Notebook as we can run different segments of our code separately. Also, all of the outputs stay in the same notebook.

You can also use the Google Colab notebook for free! Kaggle Notebook can also be used for free.

If you use the Google Colab, then you need to mount the drive to Notebook so that you can directly access all the files from your Google Drive.

# Connect Google Drive with Colab
from google.colab import drive
drive.mount('/content/drive')

Now we can simply install all the required modules/libraries that are listed on our requirements.txt file.

# Install necessary components
! pip install -r requirements.txt

This will install all the packages/modules that are listed on that specific text file. If you need more modules to install, you can simply add the name in that text file. If you need a specific version of a library, then you can also do that in the text file.

Now we can import modules in our code. Let me check whether it has successfully installed the AntsPy and SimpleITK or not. Those two are very important libraries for our task.

%matplotlib inline
# matplotlib will be displayed inline in the notebook

import os
import sys

sys.path.append('/content/drive/MyDrive/MRI_Image_Processing/notebooks')
# appending the path to include our custom helper
import helpers
from helpers import *
import ants
import SimpleITK as sitk
print(f'AntsPy Version = {ants.__version__}')
print(f'SimpleITK version = {sitk.__version__}')

Output:

AntsPy Version = 0.4.2
SimpleITK version = 2.3.1

The rest of the code with their output and necessary comments are given below:

# Define the base directory by getting the directory name of the specified path
BASE_DIR = os.path.dirname("/content/drive/MyDrive/MRI_Image_Processing/")

# Print the path to the project folder
print(f'project folder = {BASE_DIR}')

Output

project folder = /content/drive/MyDrive/MRI_Image_Processing

import os

# Define the directory path
directory_path = '/content/drive/MyDrive/MRI_Image_Processing/assets/raw_examples/'

# Initialize an empty list to store filenames
raw_examples = []

# Iterate through files in the directory and add filenames with extensions to raw_examples list
for filename in os.listdir(directory_path):
    # Check if the path refers to a file (not a subdirectory)
    if os.path.isfile(os.path.join(directory_path, filename)):
        raw_examples.append(filename)

# Display the updated raw_examples list
print(raw_examples)

Output:

['ADNI_136_S_0184_MR_MPR____N3__Scaled_2_Br_20081008132905229_S18601_I119714.nii.gz', 'ADNI_136_S_0195_MR_MPR____N3__Scaled_Br_20090708095227200_S65770_I148270.nii.gz', 'ADNI_136_S_0184_MR_MPR____N3__Scaled_Br_20080123103107781_S18601_I88159.nii.gz', 'ADNI_136_S_0086_MR_MPR____N3__Scaled_Br_20070815111150885_S31407_I67781.nii.gz', 'ADNI_136_S_0195_MR_MPR____N3__Scaled_2_Br_20081008133516751_S12748_I119721.nii.gz', 'ADNI_136_S_0184_MR_MPR____N3__Scaled_2_Br_20081008132712063_S12474_I119712.nii.gz', 'ADNI_136_S_0195_MR_MPR____N3__Scaled_Br_20080123103529723_S19574_I88164.nii.gz', 'ADNI_136_S_0184_MR_MPR-R____N3__Scaled_Br_20080415154909319_S47135_I102840.nii.gz', 'ADNI_136_S_0196_MR_MPR____N3__Scaled_Br_20070215192140032_S13831_I40269.nii.gz', 'ADNI_136_S_0195_MR_MPR____N3__Scaled_Br_20071113184014832_S28912_I81981.nii.gz', 'ADNI_136_S_0196_MR_MPR____N3__Scaled_Br_20070809224441151_S31829_I66740.nii.gz', 'ADNI_136_S_0086_MR_MPR____N3__Scaled_Br_20081013161936541_S49691_I120416.nii.gz', 'ADNI_136_S_0195_MR_MPR____N3__Scaled_2_Br_20081008133704276_S19574_I119723.nii.gz', 'ADNI_136_S_0086_MR_MPR____N3__Scaled_Br_20070215172221943_S14069_I40172.nii.gz', 'ADNI_136_S_0184_MR_MPR____N3__Scaled_Br_20070215174801158_S12474_I40191.nii.gz', 'ADNI_136_S_0195_MR_MPR-R____N3__Scaled_Br_20071110123442398_S39882_I81460.nii.gz', 'ADNI_136_S_0184_MR_MPR____N3__Scaled_Br_20090708094745554_S64785_I148265.nii.gz', 'ADNI_136_S_0195_MR_MPR____N3__Scaled_Br_20070215185520914_S12748_I40254.nii.gz', 'ADNI_136_S_0195_MR_MPR-R____N3__Scaled_Br_20081013162450631_S47389_I120423.nii.gz', 'ADNI_136_S_0184_MR_MPR-R____N3__Scaled_Br_20070819190556867_S28430_I69136.nii.gz']

Above, we can see all the necessary input data that we want to process.

from antspynet.utilities import brain_extraction

# Initialize an empty list to store the generated probabilistic brain masks
prob_brain_masks = []

# Loop through all items in the raw_examples list
for raw_example in raw_examples:
    # Create the full file path by joining the base directory with the path to the specific image file
    raw_img_path = os.path.join(BASE_DIR, 'assets', 'raw_examples', raw_example)

    # Read the image using AntsPy's image_read function, specifying reorientation to 'IAL'
    raw_img_ants = ants.image_read(raw_img_path, reorient='IAL')

    # Print the shape of the image as a numpy array in the format (Z, X, Y)
    print(f'shape = {raw_img_ants.numpy().shape} -> (Z, X, Y)')

    # Display the 3D array using a custom function 'explore_3D_array' with the image array and a specified colormap
    explore_3D_array(arr=raw_img_ants.numpy(), cmap='nipy_spectral')

    # Generate a probabilistic brain mask using the 'brain_extraction' function
    # The 'modality' parameter specifies the imaging modality as 'bold'
    # The 'verbose' parameter is set to 'True' to display detailed progress information
    prob_brain_mask = brain_extraction(raw_img_ants, modality='bold', verbose=True)

    # Append the generated probabilistic brain mask to the list
    prob_brain_masks.append(prob_brain_mask)

    # Print the filename or any relevant information about the current image (optional)
    print(f"Probabilistic Brain Mask for: {raw_example}")

    # Print the probabilistic brain mask
    print(prob_brain_mask)

    # Visualize the probabilistic brain mask using the 'explore_3D_array' function
    # This function displays the 3D array representation of the brain mask
    explore_3D_array(prob_brain_mask.numpy())

    # Generate a binary brain mask from the probabilistic brain mask using a threshold
    brain_mask = ants.get_mask(prob_brain_mask, low_thresh=0.5)

    # Visualize the original image overlaid with the brain mask contour
    explore_3D_array_with_mask_contour(raw_img_ants.numpy(), brain_mask.numpy())

    # Define the output folder path by joining the base directory with the 'assets' and 'preprocessed' directories
    out_folder = os.path.join(BASE_DIR, 'assets', 'preprocessed')

    # Create a subfolder within the 'preprocessed' directory named after the raw file (without extension)
    out_folder = os.path.join(out_folder, raw_example.split('.')[0])  # Create folder with name of the raw file

    # Create the output folder if it doesn't exist already
    os.makedirs(out_folder, exist_ok=True)  # Create folder if it doesn't exist

    # Generate a filename by adding the suffix 'brainMaskByDL' to the original raw file name
    out_filename = add_suffix_to_filename(raw_example, suffix='brainMaskByDL')

    # Create the full output file path by joining the output folder with the generated filename
    out_path = os.path.join(out_folder, out_filename)

    # Print the relative path of the input raw image file (excluding the base directory)
    print(raw_img_path[len(BASE_DIR):])

    # Print the relative path of the output file (excluding the base directory)
    print(out_path[len(BASE_DIR):])

    # Save the brain mask to a file
    brain_mask.to_file(out_path)

    # Create a masked image by applying the binary brain mask ('brain_mask') to the original image ('raw_img_ants')
    masked = ants.mask_image(raw_img_ants, brain_mask)

    # Visualize the 3D array representation of the masked image
    explore_3D_array(masked.numpy())

    # Generate a filename by adding the suffix 'brainMaskedByDL' to the original raw file name
    out_filename = add_suffix_to_filename(raw_example, suffix='brainMaskedByDL')

    # Create the full output file path by joining the output folder with the generated filename
    out_path = os.path.join(out_folder, out_filename)

    # Print the relative path of the input raw image file (excluding the base directory)
    print(raw_img_path[len(BASE_DIR):])

    # Print the relative path of the output file (excluding the base directory)
    print(out_path[len(BASE_DIR):])

    # Save the masked image ('masked') to a file specified by 'out_path'
    masked.to_file(out_path)

Conclusion

The output is very huge.

But you can check the entire project from here: FahimFBA/skull-stripping-3D-brain-mri/

FahimFBA / skull-stripping-3D-brain-mri

Apply Skulll Stripping to any 3D Brain MRI images

skull-stripping-3D-brain-mri

Apply Skulll Stripping to any 3D Brain MRI images

View on GitHub

Also, you will find a warning in the output like below:

WARNING:tensorflow:5 out of the last 5 calls to <function Model.make_predict_function.<locals>.predict_function at 0x792af6defe20> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.

I can solve it for you. But I am leaving this task for you to resolve! 😉

You can find my raw data and the preprocessed data in the assets directory.

The complete notebook with all the outputs is here!

Some sample images of the output images are given below.

Make sure to ⭐ the repository if you like this!

Cheers! 😊

How To Create GUI Window Using Python's Tkinter

Md. Fahim Bin Amin — Fri, 22 Dec 2023 08:55:00 +0000

You can create GUI (Graphical User Interface) based applications using Tkinter (Tkinter is a graphical user interface (GUI) library for Python scripts. It's the only framework built into the Python standard library and is included in all standard Python distributions). In this article, I will show you how you can create a very basic simple GUI window in Python just using a few lines of code. I have also created a video for you! 😊

Video Tutorial

This Python script creates a basic graphical user interface (GUI) application using tkinter, a standard GUI toolkit in Python.

Code

import tkinter as tk
import tkinter.font as tkFont


class App:
    def __init__(self, root):
        # Setting the title
        root.title('My First GUI Window')
        # Setting the window size
        height = 720
        width = 1280
        screenheight = root.winfo_screenheight()
        screenwidth = root.winfo_screenwidth()
        alignstr = '%dx%d+%d+%d' % (width, height, (screenwidth - width)/2, (screenheight - height)/2)
        root.geometry(alignstr)
        root.resizable(width = False, height = False)

if __name__ == "__main__":
    root = tk.Tk()
    app = App(root)
    root.mainloop()

Output

Let's break down the script:

Import Statements

import tkinter as tk: Imports the tkinter module and gives it an alias tk. This module provides classes and methods to create GUI elements.
import tkinter.font as tkFont: Imports the font submodule from tkinter. It's used to deal with fonts, though it's not explicitly used in this script.

Class Definition: `App`

class App:: Defines a new class App, which will contain the components of the GUI.

Constructor: `init`

def __init__(self, root):: The constructor of the App class. It initializes a new instance of the class. root is the main window of the application, typically an instance of Tk.

Inside the Constructor

Setting Title: root.title("undefined"): Sets the title of the window to "undefined".
Setting Window Size:
- width=600 and height=500: Sets the width and height of the window in pixels.
- screenwidth = root.winfo_screenwidth() and screenheight = root.winfo_screenheight(): Retrieves the width and height of the screen.
- alignstr = '%dx%d+%d+%d' % (width, height, (screenwidth - width) / 2, (screenheight - height) / 2): Creates a string to specify the size and position of the window. It centers the window on the screen.
- root.geometry(alignstr): Applies the size and position settings to the window.
- root.resizable(width=False, height=False): Disables resizing of the window.

Main Block

if __name__ == "__main__":: Checks if the script is being run directly (not imported as a module).
- root = tk.Tk(): Creates the main window (root) of the application.
- app = App(root): Instantiates the App class with root as the argument.
- root.mainloop(): Starts the main event loop of the program. This keeps the window open and waits for user interaction.

Limitations and Further Development

The script only sets up a window without any widgets (like buttons, labels, or text fields).
To make it a functional application, you would need to add widgets inside the App class.
The script also does not handle any events or user interactions.

This is a foundational script for a tkinter application, providing a window setup, but it lacks the interactive components typical of GUI applications.

I will try to make more videos and articles on Python Tkinter-based projects later.

A Helper Agent That Became My Friend

Md. Fahim Bin Amin — Mon, 04 Dec 2023 13:08:35 +0000

The title seems pretty intuitive and clickbait, right? But I promise that it isn't!

As an open-source contributor, I struggle to check out all the GitHub notifications I get each hour. Sometimes, it burns me out to check them on a daily basis, and I also get a lot of notifications from people complaining about not checking their issues or pull requests.

Pull requests are one of the most important things in our lives if we are developers. Pull requests can contain a fix of a bug that you have been struggling to resolve for a very long time. Pull requests can contain new enhancement features, documentation, and a lot of things that can not be described in sentences.

As for me, I find pull requests need more attention than the issues themselves. Why is that? Let me clarify.

Pull requests indeed require significant attention in the software development process. Here are a few reasons why they might demand more focus than issues:

Complexity: Pull requests often involve changes across multiple files or even entire systems. They may include multiple solutions or features, making them more intricate than individual issues.
Code Quality and Review: Pull requests necessitate thorough code reviews to ensure the quality, correctness, and adherence to coding standards. This involves analyzing the changes made, checking for bugs, and ensuring that the code integrates smoothly with the existing codebase.
Integration and Testing: Pull requests need to be integrated into the main codebase seamlessly. This involves running various tests to ensure that the changes do not introduce new bugs or regressions.
Collaboration and Discussion: Pull Requests are often the focus of collaboration between team members. Discussions, suggestions, and improvements might occur within the PR itself, making it a focal point for teamwork and iteration.
Impact on the Project: Unlike issues, which often describe problems or feature requests, pull requests directly implement changes. Their impact on the project can be more profound, making careful attention essential.
Merge Process: Before merging a pull request, it's essential to consider the implications it might have on the codebase and the project as a whole. Handling conflicts and ensuring a smooth merge is critical.

While issues define problems or tasks, pull requests represent the proposed solutions or changes to address those issues. Hence, they demand more attention due to their direct influence on the codebase and the project's progress.

As we need to do most of the tasks manually in the pull requests, it takes a lot of time and effort to check them.

What if we had an Artificial Intelligence agent that does the job for us? That sounds interesting, in fact too amazing and too good to be true, right?

Well, luckily for me, I have already found an interesting tool that does exactly what I struggle to do in the pull requests. That is none other than the PR Agent of Codium AI.

Now, I know that a lot of you are thinking about the existing GitHub copilot. Don't get me wrong, I was there too. I was an avid Copilot user, but after checking out CodiumAI, I have become their fan, to be honest. The detailed comparison can take a lot of pages here, but I am going to make it simple so that you can get to know the differences at a glance.

GitHub Next (Copilot for Pull Request)	PR Agent of Codium AI
Closed Source	Open Source
Limited amount of commands	Supports many commands
Supports only GitHub	Supports all Git platforms
Supports GitHub only	Supports GitHub and IDEs

How To Add Codium AI's PR Agent Into Your GitHub Repository

There are many ways to add the PR agent to your new or existing GitHub repository, but I find it useful to do that as a GitHub action. If you are interested in checking the other available installation methods, then you can simply head over to their official documentation where they described each of them really well.

I will specifically show the hands-on procedure of how you can do that too.

You have to create a .github directory in your repository's root directory. In that .github directory/folder, you can create another sub-directory/folder named workflows which is useful especially when you are planning to use multiple workflows in a repository. For the sake of this article, I am creating a brand new repository named test-pr-agent on GitHub.
The new repository has been created.
For all of the later tasks, you can directly use your browser and make the changes, or you can also open the VSCode dev edition on your browser/codespace. You can also make the changes locally after cloning the repository. I like to work on local machines, therefore, I will clone the repository and make the changes.
For cloning my repository, I would simply copy the SSH URL.
Now I will open my terminal. You can use any terminal you want. Then you can also change the directory if you want to clone the repository in a different location. For example, I am changing my current directory to the Desktop as I want to clone the repository in my Desktop directory.
Make sure that you already have configured your local machine for GitHub usage, like installing Git if you are on Windows, adding the SSH keys, and so on. To clone the repository, I can simply use the git clone SSH-URL command. For me, it is git clone git@github.com:FahimFBA/test-pr-agent.git
As I already have the VS Code installed on my local machine, I can simply open the VS Code in that cloned repository's directory.
For now, I am creating a new yml file under .github/workflows/. I am naming the file as pr_agent.yml. You can give it other names if you want, but you can not keep space between the words in the file name. After this, the file is residing within .github/workflows/pr_agent.yml.
Now I can copy the relevant lines of code from the official documentation.

on:
  pull_request:
  issue_comment:
jobs:
  pr_agent_job:
    runs-on: ubuntu-latest
    permissions:
      issues: write
      pull-requests: write
      contents: write
    name: Run pr agent on every pull request, respond to user comments
    steps:
      - name: PR Agent action step
        id: pragent
        uses: Codium-ai/pr-agent@main
        env:
          OPENAI_KEY: ${{ secrets.OPENAI_KEY }}
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Now I can simply commit the changes and push to the origin.
Maybe you can already understand that we need to enable the GitHub action to write settings on the repository. We also need to generate our OpenAI Key and add that as a repository secret in the GitHub repository.
Every GitHub repository has a specified GitHub token, and that is generally used as GITHUB_TOKEN in the code. But we need to enable the write access from that specific repository settings. To do that, simply head over to the GitHub repository in your browser, and go to the Settings tab.
Click on the Actions menu and then click on the General submenu.
Make sure that you have selected Allow all actions and reusable workflows within the Actions permission section.
You can keep the Fork pull request workflows from outside collaborators section as it was. I keep it in Require approval for first-time contributors.
Make sure to select Read and write permissions within the Workflow permissions section. Also, make sure that you have added a tick (✅) mark in the Allow GitHub Actions to create and approve pull requests section.
Click Save to save all newly customized settings.
Now we need the API Key from OpenAI. Simply head over to the official website to get the API key. Login to your OpenAI/ChatGPT account.
We need to generate a new secret API key to use in that repository. Simply click on "Create new secret key".
Give a name to your new secret key so that you can understand afterward which key you used for the PR-agent. For me, let me name it "PR-agent secret key". Then click on "Create secret key". This will provide you with a new secret key. Make sure to copy it, as we need it right after this. Also, it is a sensitive key, therefore, make sure no one else gets to know this key. For security purposes, I have also tried to hide the key. Click on "Done".
Now head over to your repository where you have added the yml file to use the PR-agent. Go to the repository settings, Click on "Secrets and variables" and lastly click on "Actions".
Click on "New repository secret".
Now paste your OpenAI Secret key in the Secret box and give it a name that you used in the yml file. As I used OPENAI_KEY as the variable name in the yml file, I am going to give the same name here as well.
Click on "Add secret". Now you are good to go!

Let us test it out!

Now it is the time to check whether that is working or not. For simplicity, I am creating a new branch locally where I am making some changes. Later I am going to add a new pull request.

Now you see that the PR-Agent has already started working in the PR.

I can call the CodiumAI-Agent by mentioning it with a @ and I can pass the pre-defined commands. For now, let's see what it reviews on the new pull request.

I can simply use @CodiumAI-Agent /review, and then click on "Comment".

The PR-agent has started working instantly, and I can also check that from the Actions > Workflows tab.

Now you see that the PR-agent has responded to my comment with an eye emoji (👀), and it immediately provided me with its review. It also gives feedback, how to use, instructions, etc. data so that others can also use it.

After calling once, the PR-agent would become available in the mentions, and you can call it using the @.

Currently available commands for the PR-agent are:

You can tag @CodiumAI-Agent in a comment '@CodiumAI-Agent' and add one of the following commands:
/review: Request a review of your Pull Request.
/describe: Update the PR title and description based on the contents of the PR.
/improve [--extended]: Suggest code improvements. Extended mode provides a higher quality feedback.
/ask <QUESTION>: Ask a question about the PR.
/update_changelog: Update the changelog based on the PR's contents.
/add_docs: Generate docstring for new components introduced in the PR.
/generate_labels: Generate labels for the PR based on the PR's contents.
You can also see the tools guide for more details.

I love asking questions using this!

On a serious note

Enough chatting! Now it is the time to test it in action. I am working on a project named AssistMe.

Now I am going to integrate PR-agent into this existing repository, and then I am going to check whether it performs well on the older Pull Requests.

Voila! 🎊

It also works with the earlier pull requests.

Test: review Old pull request 1

Test: add_docs Old pull request 2

Test: improve Old pull request 3

Conclusion

Thanks for reading the entire article. Now you see how I scaled up my open source project progress and made myself more productive while CodiumAI's PR-Agent is doing my task for me more efficiently!

It's really a blessing to have this type of AI tool for us. Surprisingly enough, CodiumAI's PR-agent also offers a free tier, and the examples I have shown above, all of them have been done using the free tier account. So, just think how many things can be done if you want to scale it more!

This is it for today. Hope to see you again someday.

Cheers! 🥂

Cover Image Credit: Photo by Kenny Eliason on Unsplash

How to Start Learning Python

Md. Fahim Bin Amin — Sun, 05 Nov 2023 16:00:57 +0000

If you are thinking about learning Python, then this article is for you.

Why You Should Learn Python

Learning Python is a smart thing to do for various reasons:

Versatility and Popularity

Python is a widely used, versatile programming language that is applicable in diverse domains such as web development, data analysis, artificial intelligence, machine learning, scientific computing, automation, and more.

It's also one of the most popular languages out there these days, so it's a smart programming language to learn.

Many job positions across different industries require Python skills. So learning Python increases your employability and job market competitiveness.

Data Analysis and Visualization

Python has a robust ecosystem of libraries and tools (like Pandas, NumPy, Matplotlib, and Seaborn) for data analysis and visualization. These skills are in high demand as businesses increasingly rely on data-driven insights.

Machine Learning and AI

Python is a preferred language for machine learning and artificial intelligence due to libraries like TensorFlow, PyTorch, and scikit-learn. Understanding Python is essential for anyone interested in these rapidly evolving fields.

Web Development

Python has frameworks like Django and Flask that simplify web development, making it a great choice for both beginners and experienced developers looking to build web applications.

Automation and Scripting

Python's simplicity and readability make it an excellent choice for automating tasks and writing scripts. It can be used to automate repetitive tasks, saving time and effort.

Community and Support

Python has a vast and active community. While you're learning it, you'll have access to a wealth of tutorials, documentation, and forums which makes it easier to learn and solve problems.

Easy to Learn

Python is known for its clear and readable syntax, making it easier for beginners to learn and understand basic programming concepts.

Problem-Solving Skills

Learning Python teaches you essential problem-solving and algorithmic thinking skills that are transferable to other programming languages and domains.

Future-Proofing

As technology advances, Python remains at the forefront of emerging trends due to its adaptability and continuous development.

As you can see, learning Python can equip you with essential skills needed in various industries. It'll also enhance your career prospects, and enable you to contribute to current and future technological advancements.

How to Write Your First Python Code 🙌

When we start learning any programming language, we begin by writing "Hello World" in the terminal.

This is very easy, and it gives us the pleasure of doing something in a programming language, even if we've just started learning that language.

So we're going to do this in Python – but first, I would like to explain some prerequisites that you'll need on your computer.

How to install Python on your machine

There are many ways to code on your computer, or even on your phone – I'm not joking!

Nowadays, it is very easy to code even from your smartphone or a tablet, as there are a ton of websites that help you write, debug, and run your code directly from a browser.

If you think that your computer/device might not be good enough for installing the programming software locally, then you can easily use any cloud-based popular platforms. Among these, GitHub Codespace and Replit are my favorites. You can check them out too:

If you want to set up Python locally on your machine, then you are in luck because there are a ton of resources widely available on the internet to guide you through.

I have also written an depth article to show you the whole process step by step. You can read that article directly from here if you'd like. I also included a video tutorial to help you out.

If you are a Linux user, then Python already comes pre-installed. You can check whether you have Python installed on your system by using the command python3 --version also.

And if you are a Mac user, then you can check out this guide to help you get Python installed and make sure you have the latest version.

There are various ways to write Python code on your local machine. You can use Notepad, Notepad++, Sublime Text, VS Code, or any other text editor. You can also use IDEs like PyCharm.

I will use VS Code for this article. If you're doing the same, you'll want to install the Python extension in VS Code.

We will install more extensions later if we need them.

How to Create a Python File

If we want to create a file for writing Python code, we have to ensure that we add the .py as the extension to the file name.

When you're naming your file, there are a few things to keep in mind. For example, you can add spaces between two words in the file name, but that is not recommended. Instead, you can either use an underscore ( _ ), use camel case ( firstName ), or use the snake case ( first_name ) to better handle spaces.

For now, I am creating a file named Main.py. In that file, I'll write my first Python code:

print("Hello World")

This prints the string in the terminal:

Hello World

We use the print function whenever we want to print something in the terminal. We use single quotes or double quotes in the print function, and we write whatever we want to print in the terminal within the quotes.

This also gives the exact output.

Hello World

Just keep in mind that there are certain scenarios when we should use single quotes and double quotes. But you don't need to worry about that right now – you can learn those later.

Just note that you can't mix the two types of quotes in a single print statement. If you are using single quotes at the start, for example, then make sure you use single quotes for the end. The same thing is applicable in the case of double quotes as well.

Video Walkthrough

I have started a complete Python playlist to teach you Python from basic to advanced. As I am currently a final year computer science student in the Machine Learning major, and I am also researching Machine Learning, Artificial Intelligence, and Neural Networks along with some relevant technologies. This also helps me to keep my knowledge fresh and updated continuously.

The first video from that specific playlist demonstrates everything I have told you up until now. Make sure to watch the video here:

Conclusion

Thank you for reading the entire article.

If you have any questions please let me know by reaching out on Twitter or LinkedIn.

You can also follow me on:🎁GitHub: FahimFBA🎁YouTube: @FahimAmin.

If you are interested then you can also check my website: https://fahimbinamin.com/

Happy Coding! 😊

How To Convert Multiple Images Into A Single PDF File Using 4 Lines of Python Code

Md. Fahim Bin Amin — Tue, 18 Jul 2023 18:51:57 +0000

Today, you will create a project that will grab all of the image files from a particular directory and create a single PDF file including all of the images.

The interesting thing about Python is, you will need only 4 lines of code to achieve that! So, let's get started, shall we?

💡 Detailed Article

I have written the complete article on freeCodeCamp. Make sure to read that too!

Python Project – How to Convert Multiple Images into a Single PDF File

Creating projects is the best way to learn a programming language. It is fun and it's a creative way to learn new things. Whenever I try to learn a new language or new technology, I try to create a project, whether it's a small byte-sized or big proj...

freecodecamp.org

📺 Video Guideline

I know that many of you like to watch video instead of following a complete article. Fear not! I have also created a complete video tutorial just for you!

🎯 Pre Requisite

Simply create a new folder for the project. Please make sure that you do not keep any spaces in the folder's name.
Keep some image files in that directory. For this project, I am going to use the .jpg image files. Therefore I would suggest you to do the same thing!
You can download the royalty free images from Unsplash or Pexels. Keep in mind that our project can't handle large image files. Therefore, try to download those image files which are smaller in file size. You can select small files during downloading them from Unsplash.
Now simply open the Visual Studio Code. If you want, then obviously you can use other text editors or IDEs. But for simplicity, I like to use widely used free software. And VS Code is the best in this sector.
Create a Python file where you will write down the entire code with me. I am going to create a file named Script.py.
Install the package/library named img2pdf. This library is used for converting images to PDF via direct JPEG inclusion. You can check this website for more details. I am going to install it using pip. Simply open a terminal and use the command, pip install img2pdf.

💻 Code

import os
import img2pdf
with open("ImageContainingBook.pdf", "wb") as file:
    file.write(img2pdf.convert([i for i in os.listdir("C:\\Users\\fahim\\Desktop\\ImageToPdf") if i.endswith(".jpg")])) # Change the file directory accordingly

⭐ The complete project is available on GitHub.

Here, I imported two necessary packages first, os and img2pdf. Then I need to specify exactly in which file format and file name I want to place my image files. As I want to generate a PDF file to include all of my image files, I have specified that.

Then I need to specify what I want to do with the file. I want to write in that file and I want the conversion functionality of the img2pdf library. In my specified directory, there might be a lot of different files and that is natural. But as I only want to convert the image files which have a .jpeg extension in them, I need to specify that explicitly. Also, I definitely need to include the file directory where it will get all of the images.

🏃‍♂️ Run

If you have the Code Runner extension installed on your VS Code, then you can simply run the file using that extension.

As my filename is Script.py and I am using my Windows machine, my command would be python Script.py. If you are a Linux or Mac user, then use the command python3 Script.py or python3 filename.py.

💁‍♂️ Conclusion

I hope you have enjoyed this short article. 😊

If you have any questions then please let me know using Twitter or LinkedIn.

You can also follow me on:
🎁GitHub: FahimFBA
🎁YouTube: @FahimAmin

If you are interested then you can also check my website: https://fahimbinamin.com/

Have a great day! 😊

🖼️ Cover: Photo by Christina Morillo: https://www.pexels.com/photo/woman-programming-on-a-notebook-1181359/

DEV Community: Md. Fahim Bin Amin

[Boost]

Why Cloud Incident Response is Critical for DevOps and IT Teams

Md. Fahim Bin Amin ・ Oct 4

Why Cloud Incident Response is Critical for DevOps and IT Teams

What is Cloud Incident Response?

Why Cloud Incident Response is Critical for DevOps and IT Teams

Key Phases of Cloud Incident Response Process

Detection and Alerting

Triage and Classification

Containment and Mitigation

Recovery and Service Restoration

Postmortem and Continuous Improvement

Cloud Incident Response Best Practices

Define Clear Roles and Responsibilities

Use Infrastructure as Code (IaC) for Faster Recovery

Implement Automated Alerting and Escalation Policies

Conduct Regular Runbooks and Chaos Drills

Integrate with Monitoring, Logging and IAM

Tools to Support Effective Cloud Incident Response

Monitoring and Observability

Logging and Tracing

Alerting and On-Call Management

Infrastructure as Code (IaC)

Security and Identity

How We Built Our Cloud Incident Response Process

Conclusion

How to Make Images GHIBLIFIED!

How to Unsave All Saved Posts on Facebook in a Few Simple Steps

Warning:

Step-by-Step Guide

Step 1: Scroll Through Your Saved Items

Step 2: Open the Developer Console

Step 3: Open the Context Menu for Each Item

Step 4: Unsave Each Item

Important Reminder:

Final Thoughts

Highlight Specific Segment Block as Notice, Tip, Caution, Important & Warning in Markdown

Video Walkthrough

"Note" Specific Block

Syntax

"Tip" Specific Block

Syntax

"Warning" Specific Block

Syntax

"Caution" Specific Block

Syntax

"Important" Specific Block

Syntax

Conclusion

Default Parameter Value in JavaScript Functions

Remove Unnecessary Warnings in Tensorflow GPU

Skull Stripping 3D MRI Brain Image

What is Skull Stripping?

What are we going to do exactly with the 3D MRI Brain images?

Why Skull Stripping is a necessary thing in human brain-related research?

How can Skull Stripping be performed using Python?

Helpers

Additional required modules and libraries

Notebook

Conclusion

FahimFBA / skull-stripping-3D-brain-mri

Apply Skulll Stripping to any 3D Brain MRI images

skull-stripping-3D-brain-mri

How To Create GUI Window Using Python's Tkinter

Video Tutorial

Code

Output

Import Statements

Class Definition: App

Constructor: __init__

Inside the Constructor

Main Block

Limitations and Further Development

A Helper Agent That Became My Friend

How To Add Codium AI's PR Agent Into Your GitHub Repository

Let us test it out!

Currently available commands for the PR-agent are:

On a serious note

Conclusion

Class Definition: `App`

Constructor: `init`