DEV Community: Abhilash Panicker

Tkinter vs PyQt: Choosing the Right GUI Library for Your Python Projects

Abhilash Panicker — Mon, 08 May 2023 08:23:58 +0000

When it comes to creating graphical user interfaces (GUIs) for Python applications, Tkinter and PyQt are two of the most popular libraries. Both offer a wide range of features and ease of use, making it difficult to choose between them. In this article, we will compare Tkinter and PyQt, exploring their key differences and advantages, to help you decide which library best fits your project's needs.

1. Overview

a. Tkinter
- Tkinter is the standard GUI library for Python and comes bundled with most Python installations. It is a thin object-oriented layer on top of the Tcl/Tk GUI toolkit. Tkinter is simple and easy to use, making it a popular choice for beginners and small projects.

b. PyQt
- PyQt is a set of Python bindings for the Qt application framework, a popular choice for creating desktop applications. PyQt is known for its flexibility, extensive features, and robustness. It is suitable for large projects and professional applications.

2. Installation and setup

a. Tkinter
- Tkinter is included with most Python installations, making it easy to get started without needing to install any additional packages.

b. PyQt
- PyQt requires a separate installation using pip (e.g., pip install PyQt5). It also needs a compatible version of the Qt library installed on your system.

3. Documentation and community support

a. Tkinter
- Tkinter has extensive documentation and a large community. Many online resources, tutorials, and examples are available to help beginners get started.

b. PyQt
- PyQt also has comprehensive documentation, and its community is growing. Since PyQt is based on the Qt framework, you can find extensive resources related to Qt development, which can be helpful when working with PyQt.

4. Features and capabilities

a. Tkinter
- Tkinter provides basic widgets (buttons, labels, text boxes, etc.) and simple layout management. It is suitable for small projects and simple applications, but it might be limiting for more complex projects.

b. PyQt
- PyQt offers a wide range of advanced features, such as custom widgets, OpenGL integration, multithreading support, and extensive layout management. It is suitable for complex applications and professional projects, where advanced functionality is required.

5. Look and feel

a. Tkinter
- Tkinter's default look and feel is dated and does not always blend well with modern operating systems. However, it is possible to customize the appearance using themes and styles.
- Tkinter example:

b. PyQt
- PyQt applications have a native look and feel on all supported platforms, making them visually appealing and consistent with the user's OS. PyQt also provides advanced styling options, allowing for extensive customization.
- PyQt example:

)

6. Performance

a. Tkinter
- Tkinter has decent performance for small to medium-sized applications. However, it may struggle with larger projects or applications that require rapid updates to the UI.

b. PyQt
- PyQt has better performance compared to Tkinter, making it suitable for larger projects and applications that require fast UI updates.

Conclusion:

Both Tkinter and PyQt have their advantages and are suited for different types of projects. If you are new to GUI programming or working on a small project with basic requirements, Tkinter is a simple and easy-to-use option. However, if you need more advanced features, a native look and feel, or better performance, PyQt is a more suitable choice for larger projects and professional applications. Ultimately, the choice between Tkinter and PyQt depends on your project's requirements and your personal preferences.

About the Author: https://dbugr.vercel.app/

How to connect to D365 CE and stay connected even when token expires

Abhilash Panicker — Sat, 06 May 2023 05:41:47 +0000

To create a simple console application in C# that connects to Dynamics 365 CE with OAuth and refreshes the token when it expires, follow these steps:

Install the required NuGet packages: Install the following NuGet packages using Package Manager Console in Visual Studio or add them manually through the NuGet Package Manager:

Microsoft.IdentityModel.Clients.ActiveDirectory
Microsoft.CrmSdk.CoreAssemblies
Microsoft.CrmSdk.XrmTooling.CoreAssembly

Create a new C# Console Application in Visual Studio.
Create a new project and select "Console App (.NET Core)" or "Console App (.NET Framework)".
Replace the contents of Program.cs with the following code:

using System;
using Microsoft.IdentityModel.Clients.ActiveDirectory;
using Microsoft.Xrm.Sdk;
using Microsoft.Xrm.Tooling.Connector;

namespace Dynamics365OAuthApp
{
    class Program
    {
        // Replace with your Dynamics 365 CE instance URL
        private const string ResourceUrl = "https://<your_instance>.crm.dynamics.com";
        // Replace with your Azure AD tenant ID
        private const string TenantId = "<your_tenant_id>";
        // Replace with your Azure AD application client ID
        private const string ClientId = "<your_client_id>";
        // Replace with your Azure AD application client secret
        private const string ClientSecret = "<your_client_secret>";
        private const string AuthorityUrl = "https://login.microsoftonline.com/" + TenantId;

        static void Main(string[] args)
        {
            var service = GetCrmService();
            if (service != null)
            {
                // Add your code to interact with Dynamics 365 CE
            }
            else
            {
                Console.WriteLine("Failed to connect to Dynamics 365 CE.");
            }
        }

        private static IOrganizationService GetCrmService()
        {
            try
            {
                var authenticationContext = new AuthenticationContext(AuthorityUrl);
                var credentials = new ClientCredential(ClientId, ClientSecret);
                var authResult = authenticationContext.AcquireTokenAsync(ResourceUrl, credentials).Result;
                var connectionString = $@"
                    ServiceUri={ResourceUrl};
                    AuthType=OAuth;
                    AccessToken={authResult.AccessToken};
                    ";

                var crmService = new CrmServiceClient(connectionString);
                if (crmService.IsReady)
                {
                    return crmService.OrganizationWebProxyClient != null
                        ? (IOrganizationService)crmService.OrganizationWebProxyClient
                        : crmService.OrganizationServiceProxy;
                }
                Console.WriteLine("Failed to connect: " + crmService.LastCrmError);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: " + ex.Message);
            }

            return null;
        }
    }
}

Make sure to replace <your_instance>, <your_tenant_id>, <your_client_id>, and <your_client_secret> with your own values.

Run the console application Build and run the console application. If successful, it will connect to Dynamics 365 CE using OAuth and return an instance of IOrganizationService which can be used to interact with the Dynamics 365 CE instance.

When the token expires, the CrmServiceClient will automatically refresh the token using the provided ClientCredential. You do not need to worry about manually refreshing the token.

That's it! You now have a simple console application that connects to Dynamics 365 CE with OAuth and automatically refreshes the token when it expires.

Supervised Learning: Understanding the Concepts and Algorithms with Examples

Abhilash Panicker — Wed, 03 May 2023 18:51:17 +0000

Supervised learning is a machine learning technique that involves training a model on a labeled dataset, where each data point is associated with a target label. The goal of supervised learning is to learn a function that maps input features to the corresponding output labels. In this article, we will explore the concepts of supervised learning and discuss some popular algorithms, such as Linear Regression, Logistic Regression, Decision Trees, and Random Forests.

Understanding Supervised Learning:

In supervised learning, we have a dataset consisting of input features and corresponding output labels. We use this dataset to train a model that can predict the output label for new, unseen data points. The goal of supervised learning is to learn a function that maps input features to the corresponding output labels. The input features are also called independent variables, while the output labels are called dependent variables.

Supervised learning can be classified into two types: regression and classification. In regression, we predict a continuous output variable, such as the price of a house based on its features. In classification, we predict a categorical output variable, such as whether an email is spam or not based on its features.

Popular Supervised Learning Algorithms:

Linear Regression:

Linear Regression is a popular algorithm for regression problems, where we want to predict a continuous output variable based on one or more input features. In Linear Regression, we assume a linear relationship between the input features and the output variable. The goal of Linear Regression is to find the line that best fits the data.

import pandas as pd
from sklearn.linear_model import LinearRegression

df = pd.read_csv('data.csv')
X = df[['feature1', 'feature2']]
y = df['target']

model = LinearRegression()
model.fit(X, y)

# Predict on new data
X_new = [[0.5, 0.6], [0.2, 0.3]]
y_pred = model.predict(X_new)

Logistic Regression:

Logistic Regression is a popular algorithm for classification problems, where we want to predict a categorical output variable based on one or more input features. In Logistic Regression, we assume a linear relationship between the input features and the log-odds of the output variable. The goal of Logistic Regression is to find the line that best separates the two classes.

import pandas as pd
from sklearn.linear_model import LogisticRegression

df = pd.read_csv('data.csv')
X = df[['feature1', 'feature2']]
y = df['target']

model = LogisticRegression()
model.fit(X, y)

# Predict on new data
X_new = [[0.5, 0.6], [0.2, 0.3]]
y_pred = model.predict(X_new)

Decision Trees:

Decision Trees are a popular algorithm for both regression and classification problems. In Decision Trees, we build a tree-like model of decisions and their possible consequences. Each internal node of the tree corresponds to a decision on an input feature, while each leaf node corresponds to a predicted output value.

import pandas as pd
from sklearn.tree import DecisionTreeRegressor

df = pd.read_csv('data.csv')
X = df[['feature1', 'feature2']]
y = df['target']

model = DecisionTreeRegressor()
model.fit(X, y)

# Predict on new data
X_new = [[0.5, 0.6], [0.2, 0.3]]
y_pred = model.predict(X_new)

Random Forests:

Random Forests are an ensemble learning method that combines multiple Decision Trees to improve the accuracy and stability of the model. In Random Forests, we build a large number of Decision Trees, each based on a random subset of the input features and training data. The predicted output value is then the average of the predictions of all the trees.

import pandas as pd
from sklearn.ensemble import RandomForestRegressor

df = pd.read_csv('data.csv')
X = df[['feature1', 'feature2']]
y = df['target']

model = RandomForestRegressor()
model.fit(X, y)

# Predict on new data
X_new = [[0.5, 0.6], [0.2, 0.3]]
y_pred = model.predict(X_new)

Conclusion:

In conclusion, supervised learning is a powerful machine learning technique that allows us to predict output labels based on input features. We discussed the concepts of supervised learning, including the difference between regression and classification problems. We also explored some popular supervised learning algorithms, such as Linear Regression, Logistic Regression, Decision Trees, and Random Forests, and provided examples of how to implement them in Python using the Scikit-learn library. By using supervised learning, we can build accurate and reliable models that can make valuable predictions and provide valuable insights for decision-making.

Data Visualization: The Importance of Visualizing Data and How to Use Matplotlib and Seaborn to Create Stunning Visualizations

Abhilash Panicker — Wed, 03 May 2023 18:45:25 +0000

Data visualization is a powerful tool that allows us to communicate complex data insights in a simple and intuitive way. By creating visual representations of data, we can better understand patterns and relationships that might be difficult to discern from raw data alone. In this article, we will discuss the importance of data visualization and how to use libraries such as Matplotlib and Seaborn to create different types of visualizations.

The Importance of Data Visualization:

Data visualization is important for several reasons. Firstly, it allows us to identify patterns and relationships in the data that might not be immediately apparent from looking at raw data. Secondly, it helps to communicate data insights to others in a way that is easy to understand and interpret. Finally, it can help to identify errors or outliers in the data that might otherwise go unnoticed.

Creating Visualizations with Matplotlib:

Matplotlib is a popular data visualization library in Python that provides a wide range of tools for creating static, interactive, and animated visualizations. Here are some examples of how to use Matplotlib to create different types of visualizations:

Line plots:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

plt.plot(x, y)
plt.show()

Scatter plots:

import matplotlib.pyplot as plt
import numpy as np

x = np.random.normal(size=100)
y = np.random.normal(size=100)

plt.scatter(x, y)
plt.show()

Bar charts:

import matplotlib.pyplot as plt

x = ['A', 'B', 'C', 'D', 'E']
y = [10, 15, 20, 25, 30]

plt.bar(x, y)
plt.show()

Creating Visualizations with Seaborn:

Seaborn is a Python library that provides a higher-level interface to Matplotlib, making it easier to create more complex and visually appealing visualizations. Here are some examples of how to use Seaborn to create different types of visualizations:

Line plots:

import seaborn as sns
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x)

sns.lineplot(x, y)
plt.show()

Scatter plots:

import seaborn as sns
import numpy as np

x = np.random.normal(size=100)
y = np.random.normal(size=100)

sns.scatterplot(x, y)
plt.show()

Bar charts:

import seaborn as sns

x = ['A', 'B', 'C', 'D', 'E']
y = [10, 15, 20, 25, 30]

sns.barplot(x, y)
plt.show()

Conclusion:

In conclusion, data visualization is an essential tool for communicating complex data insights in a simple and intuitive way. By using libraries such as Matplotlib and Seaborn, we can create a wide range of visualizations that help to identify patterns and relationships in the data, communicate data insights to others, and identify errors or outliers in the data. By taking the time to properly visualize data, we can gain a deeper understanding of the data and make more informed decisions based on the insights that we discover.

Data Preparation: Techniques for Cleaning, Preprocessing, and Transforming Data for Machine Learning

Abhilash Panicker — Wed, 03 May 2023 18:41:35 +0000

Data preparation is a critical step in the machine learning process that involves cleaning, preprocessing, and transforming data in order to make it suitable for use in machine learning models. In this article, we will discuss the importance of data preparation and the techniques used to clean, preprocess, and transform data for machine learning.

The Importance of Data Preparation:

Data preparation is essential because machine learning models are only as good as the data they are trained on. Poor quality or poorly prepared data can lead to inaccurate or biased models that produce unreliable results. In addition, data preparation can help to reduce noise and redundancy in the data, making it easier for the model to identify relevant patterns and make accurate predictions.

Techniques for Data Cleaning:

Data cleaning involves identifying and correcting errors, inconsistencies, and missing values in the data. This is typically the first step in the data preparation process. Some of the techniques used for data cleaning include:

Removing duplicates: Duplicate data can skew the analysis and produce inaccurate results. To remove duplicates, we can use the Pandas library to drop rows with duplicated values.

import pandas as pd

df = pd.read_csv('data.csv')
df.drop_duplicates(inplace=True)

Handling missing values: Missing values can occur when data is not available or when there are errors in the data collection process. To handle missing values, we can either drop the rows or columns with missing values or impute the missing values with a value that makes sense for the data.

# Dropping missing values
df.dropna(inplace=True)

# Imputing missing values
from sklearn.impute import SimpleImputer

imputer = SimpleImputer(strategy='mean')
df_imputed = pd.DataFrame(imputer.fit_transform(df), columns=df.columns)

Techniques for Data Preprocessing:

Data preprocessing involves transforming the data into a format that can be easily understood by the machine learning algorithm. This may involve scaling the data, encoding categorical variables, and feature engineering. Some of the techniques used for data preprocessing include:

Scaling the data: Scaling involves transforming the data so that it falls within a certain range. This is important because some machine learning algorithms are sensitive to the scale of the data. One way to scale the data is using the MinMaxScaler or StandardScaler from the Scikit-learn library.

# Using MinMaxScaler
from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
scaled_data = scaler.fit_transform(data)

# Using StandardScaler
from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
scaled_data = scaler.fit_transform(data)

Encoding categorical variables: Categorical variables are variables that take on discrete values, such as colors or types of products. Many machine learning algorithms require numerical inputs, so categorical variables must be encoded in order to be used in the model. One way to encode categorical variables is using the OneHotEncoder from the Scikit-learn library.

from sklearn.preprocessing import OneHotEncoder

encoder = OneHotEncoder()
encoded_data = encoder.fit_transform(data)

Techniques for Data Transformation:

Data transformation involves creating new features from the existing features in the data, or reducing the dimensionality of the data. This can help to improve the performance of the machine learning algorithm. Some of the techniques used for data transformation include:

Feature engineering: Feature engineering involves creating new features from the existing features in the data. This may involve combining features, creating interaction terms, or extracting features from text or images.

# Creating interaction terms
data['interaction'] = data['feature1'] * data['feature2']

Dimensionality reduction: Dimensionality reduction involves reducing the number of features in the data while retaining the most important information. This can help to improve the performance of the machine learning algorithm and reduce the risk of overfitting. One popular technique for dimensionality reduction is Principal Component Analysis (PCA).

from sklearn.decomposition import PCA

pca = PCA(n_components=2)
transformed_data = pca.fit_transform(data)

Conclusion:

In conclusion, data preparation is an essential step in the machine learning process that involves cleaning, preprocessing, and transforming data in order to make it suitable for use in machine learning models. Some of the techniques used for data preparation include data cleaning to identify and correct errors, inconsistencies, and missing values; data preprocessing to transform the data into a format that can be easily understood by the machine learning algorithm; and data transformation to create new features from the existing features in the data or reduce the dimensionality of the data. By taking the time to properly prepare data, we can create accurate and reliable machine learning models that produce valuable insights and predictions.

NumPy and Pandas: Essential Tools for Data Analysis and Manipulation

Abhilash Panicker — Wed, 03 May 2023 18:35:34 +0000

Data analysis and manipulation are essential tasks in the world of data science and machine learning. NumPy and Pandas are two Python libraries that provide the necessary tools to perform these tasks efficiently and effectively. In this post, we will discuss the key features of NumPy and Pandas, and provide examples to illustrate their use in data analysis and manipulation.

NumPy:

NumPy (short for Numerical Python) is a library that provides support for large, multi-dimensional arrays and matrices, along with a wide range of mathematical functions to operate on them. NumPy is widely used for scientific computing, data analysis, and machine learning tasks.

One of the key features of NumPy is its support for multi-dimensional arrays. These arrays can have any number of dimensions and can be indexed and sliced in many different ways. For example, let's create a simple 2D array using NumPy:

import numpy as np

arr = np.array([[1, 2, 3],
                [4, 5, 6],
                [7, 8, 9]])

We can access the elements of this array using indexing and slicing:

print(arr[0, 1])  # Output: 2
print(arr[:, 1])  # Output: [2, 5, 8]

NumPy also provides a wide range of mathematical functions for working with arrays, including basic arithmetic operations, statistical functions, and linear algebra operations. For example, we can perform element-wise addition and multiplication of two arrays as follows:

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

c = a + b
d = a * b

print(c)  # Output: [5 7 9]
print(d)  # Output: [4 10 18]

Pandas:

Pandas is a library that provides tools for data analysis and manipulation. It is built on top of NumPy and provides a higher-level interface for working with tabular data.

One of the key features of Pandas is its data structures, which include Series and DataFrame. A Series is a one-dimensional labeled array, while a DataFrame is a two-dimensional labeled data structure with columns of potentially different types. For example, let's create a DataFrame using Pandas:

import pandas as pd

data = {'name': ['Alice', 'Bob', 'Charlie'],
        'age': [25, 30, 35],
        'gender': ['Female', 'Male', 'Male']}

df = pd.DataFrame(data)

We can access the elements of this DataFrame using indexing and slicing:

print(df['name'])  # Output: ['Alice', 'Bob', 'Charlie']
print(df.loc[df['age'] > 30])  # Output: Charlie, 35, Male

Pandas also provides a wide range of tools for manipulating data, including filtering, grouping, sorting, and merging. For example, we can filter the rows of a DataFrame based on a certain condition as follows:

df_filtered = df[df['age'] > 30]
print(df_filtered)  # Output: Charlie, 35, Male

Pandas also provides support for data visualization, through integration with libraries such as Matplotlib and Seaborn. This allows data to be visualized in a wide range of formats, including line plots, scatter plots, histograms, and more.

In conclusion, NumPy and Pandas are essential tools for anyone working with data in Python

Building a Simple Pomodoro Timer in C# on Ubuntu/Windows with .NET Core

Abhilash Panicker — Mon, 01 May 2023 06:47:30 +0000

Introduction:

The Pomodoro Technique is a popular time management method that involves breaking work into intervals (usually 25 minutes) separated by short breaks. In this blog post, we'll create a simple Pomodoro Timer application called TaskTracker using C# and .NET Core on Ubuntu. You can perform this on Windows with the same steps. The application will run in the console, displaying messages when it's time to work and when it's time to take a break.

Prerequisites:

Before we start, make sure you have .NET Core SDK installed on your Ubuntu machine. If you don't, follow the instructions at https://docs.microsoft.com/en-us/dotnet/core/install/linux-ubuntu to install it.

Step 1: Create a new console application

Open a terminal and type the following command to create a new console application:

dotnet new console -o TaskTracker
cd TaskTracker

Step 2: Edit Program.cs

Open the Program.cs file in your favorite text editor or IDE. The file should look like this:

using System;

namespace TaskTracker
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

Step 3: Create a Timer class

Create a new file named Timer.cs in the TaskTracker folder and add the following code:

// Timer.cs
using System;
using System.Timers;

namespace TaskTracker
{
    public class Timer
    {
        private readonly int _interval;
        private readonly Timer _timer;

        public event EventHandler TimerFinished;

        public Timer(int interval)
        {
            _interval = interval;
            _timer = new Timer(_interval * 1000);
            _timer.Elapsed += Timer_Elapsed;
        }

        public void Start() => _timer.Start();

        public void Stop() => _timer.Stop();

        private void Timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            _timer.Stop();
            TimerFinished?.Invoke(this, EventArgs.Empty);
        }
    }
}

The Timer class defines a custom timer that triggers an event when the specified interval elapses. We'll use this class to manage work and break intervals.

Step 4: Create a Task class

Create a new file named Task.cs in the TaskTracker folder and add the following code:

using System;

namespace TaskTracker
{
    public class Task
    {
        private readonly Timer _workTimer;
        private readonly Timer _breakTimer;
        private int _completedCycles;

        public Task(int workMinutes, int breakMinutes)
        {
            _workTimer = new Timer(workMinutes);
            _breakTimer = new Timer(breakMinutes);

            _workTimer.TimerFinished += WorkTimerFinished;
            _breakTimer.TimerFinished += BreakTimerFinished;
        }

        public void Start() => _workTimer.Start();

        private void WorkTimerFinished(object sender, EventArgs e)
        {
            Console.WriteLine("Work time is over. Take a break!");
            _breakTimer.Start();
        }

        private void BreakTimerFinished(object sender, EventArgs e)
        {
            _completedCycles++;
            Console.WriteLine($"Break time is over. Completed cycles: {_completedCycles}. Time to work!");
            _workTimer.Start();
        }
    }
}

The Task class manages work and break cycles using two instances of the Timer class. It starts the work timer and, when it finishes, starts the break timer. This cycle repeats indefinitely.

Step 5: Modify Program.cs

Update Program.cs to use the Task class:

// Program.cs
using System;

namespace PomodoroTimer
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Pomodoro Timer!");

            int workMinutes = 25;
            int breakMinutes = 5;

            var pomodoro = new Pomodoro(workMinutes, breakMinutes);
            pomodoro.Start();
            Console.WriteLine("Press any key to exit the timer.");
Console.ReadKey();
}
}
}

Step 6: Build and run the application

In the terminal, navigate to the TaskTracker folder and execute the following commands:

dotnet build
dotnet run

The application will start, and the Task timer will begin with the default 25 minutes of work time and 5 minutes of break time. You'll see console messages indicating when it's time to work and when it's time to take a break. Press any key to exit the application.

Conclusion:

In this blog post, we created a simple C# TaskTracker application using .NET Core on Ubuntu. The application uses a custom Timer class to manage work and break intervals and a Pomodoro class to manage cycles. The console application provides a minimalistic interface to help users stay focused and manage their time effectively using the Pomodoro Technique.

Renaming Folders in a Python Project with a Simple Script

Abhilash Panicker — Mon, 01 May 2023 03:03:10 +0000

Introduction:

Managing folder names in a project can sometimes become tedious, especially when you want to change the naming convention. In this tutorial, we'll show you how to create a Python script to rename folders in your project quickly and efficiently.

In our example, we will rename folders with the pattern "01_Lesson_Introduction" to "01_Introduction". We'll use the os and re libraries in Python to accomplish this task.

Creating the Python Script:

Start by importing the required libraries:

import os
import re

Now, define a function called rename_folders that takes one argument, path, which is the path to the directory containing the folders you want to rename.

def rename_folders(path):

Inside the function, create a list of directories in the provided path using a list comprehension.

    dir_list = [d for d in os.listdir(path) if os.path.isdir(os.path.join(path, d))]

Next, start a loop that iterates through each folder in the dir_list:

    for folder in dir_list:

In the loop, try to match the folder name to a given regular expression pattern:

        match = re.match(r"(\d{2})_Lesson_(.+)", folder)

If there's a match, create a new folder name using the matched groups:

        if match:
            new_folder_name = f"{match.group(1)}_{match.group(2)}"

Then, construct the full paths for the current folder and the new folder name:

            src = os.path.join(path, folder)
            dst = os.path.join(path, new_folder_name)

Rename the folder using the os.rename function and print the renamed folder's source and destination paths for confirmation:

            os.rename(src, dst)
            print(f"Renamed folder '{src}' to '{dst}'")

Finally, provide the path to your project folder and call the rename_folders function:

project_path = "/path/to/your/project"
rename_folders(project_path)

Remember to replace "/path/to/your/project" with the actual path to your project folder.

Conclusion:

In this tutorial, we demonstrated how to create a Python script to rename folders in a project using the os and re libraries. This script can save you time when managing folder names and help keep your project organized.

Always remember to backup your project folder before running any scripts that modify its contents, just in case something goes wrong.

Building a Pomodoro Timer for Ubuntu in Python

Abhilash Panicker — Thu, 27 Apr 2023 13:49:46 +0000

The following can be used as a code along but the project has been moved to : https://github.com/abpanic/Task-Tracker
It has more features, being used by almost 35 SDK Engineers for daily Task management and I will provide a code along for it in addition to creating executables for distribution

I had to install Ubuntu on my personal machine and spend some time up-skilling. I learnt about the Pomodoro Technique for better time management and realised that there was a need for an app for Ubuntu since none of the apps provided the functionality I wanted.

Hence, the project started of and the completed component in its alpha version is here: https://abpanic.github.io/PomodoroTimer/
In this blog post, I'll be discussing the build process of a custom Pomodoro Timer created for my use case. Let's dive into the details.

The Build Process

Installing Pre-requisite

Visual Studio Code

I started by creating a new file in Visual Studio Code with the filename "PomodoroTimer.py" and added an initial scaffolding to outline the main components of the application. The starter code looks like this:

import tkinter as tk

class PomodoroTimer:
    def __init__(self, master):
        self.master = master
        master.title("Pomodoro Timer")

        # Create timer label
        self.timer_label = tk.Label(master, text="00:00", font=("Arial", 48))
        self.timer_label.pack(pady=50)

        # Create timer control buttons
        self.start_button = tk.Button(master, text="Start", command=self.start_timer)
        self.start_button.pack(side="left", padx=10)

        self.pause_button = tk.Button(master, text="Pause", command=self.pause_timer, state="disabled")
        self.pause_button.pack(side="left", padx=10)

        self.stop_button = tk.Button(master, text="Stop", command=self.stop_timer, state="disabled")
        self.stop_button.pack(side="left", padx=10)

    def start_timer(self):
        pass

    def pause_timer(self):
        pass

    def stop_timer(self):
        pass

root = tk.Tk()
app = PomodoroTimer(root)
root.mainloop()

The starter code is just the scaffolding of the application, and it's okay not to have all the components functionally coded in the first go. However, running the starter code in VSCode should launch the app, as we kick off and it should launch fine as it did.

Next, I added the rest of the code components to ensure the application is functional and performs the tasks it's supposed to. As you can see the start, pause and stop timer function was missing so was the timer and state of the app. We also added countdown and timer label

import tkinter as tk    
class PomodoroTimer:    
    def __init__(self, master): 
        ...//code here remains the same 
        master.title("Pomodoro Timer")  
        self.seconds_left = 25 * 60  # 25 minutes   
        self.is_running = False 
        ...//code here remains the same     
    def countdown(self):    
        if self.seconds_left > 0 and self.is_running:   
            self.seconds_left -= 1  
            self.update_timer_label()   
            self.master.after(1000, self.countdown)  # Call this method again after 1000 ms (1 second)  
    def update_timer_label(self):   
        minutes, seconds = divmod(self.seconds_left, 60)    
        self.timer_label.configure(text=f"{minutes:02d}:{seconds:02d}") 
    def start_timer(self):  
        if not self.is_running: 
            self.is_running = True  
            self.start_button.config(state="disabled")  
            self.pause_button.config(state="normal")    
            self.stop_button.config(state="normal") 
            self.countdown()    
    def pause_timer(self):  
        if self.is_running: 
            self.is_running = False 
            self.start_button.config(state="normal")    
            self.pause_button.config(state="disabled")  
    def stop_timer(self):   
        if self.is_running or self.seconds_left != 25 * 60: 
            self.is_running = False 
            self.seconds_left = 25 * 60 
            self.update_timer_label()   
            self.start_button.config(state="normal")    
            self.pause_button.config(state="disabled")  
            self.stop_button.config(state="disabled")   
if __name__ == "__main__":  
    root = tk.Tk()  
    ...//code here remains the same

Now, the application is coming up nicely, and we can run it from the terminal with python3 PomodoroTimer.py.

The application launches and the timer starts. However, a Minimum Viable Product (MVP) should have features that go beyond basic functionality. It should include features in the initial phase that make users want to use it more.

So, I focused on two unique features to set it apart from other Pomodoro timers available in the Ubuntu snap store:

An alarm sound that the user can hear, allowing them to reset the timer.
The ability to launch the application with a double click on Ubuntu.

To implement these features, I made the following changes:

Adding Alarm Sound

I used the pygame library to add the alarm sound feature:

import tkinter as tk
import pygame

class PomodoroTimer:
    def __init__(self, master):
        ...//code here remains the same 

        pygame.mixer.init()

    def countdown(self):
        if self.seconds_left > 0 and self.is_running:
           ...//code here remains the same  
            self.master.after(1000, self.countdown)  # Call this method again after 1000 ms (1 second)
        elif self.is_running:
            self.play_alarm()

    ...//code here remains the same 

    def stop_timer(self):
        if self.is_running or self.seconds_left != 25 * 60:
            ...//code here remains the same 
            self.pause_button.config(state="disabled")
            self.stop_button.config(state="disabled")

    def play_alarm(self):
        pygame.mixer.music.load("alarm_sound.wav")  # Replace "alarm_sound.wav" with the path to your sound file
        pygame.mixer.music.play()

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

Making the Application Executable with Double Click on Ubuntu

To make the Python script executable with a double click on Ubuntu, I followed these steps:

Add a shebang line to the script. Open your Python script (PomodoroTimer.py) in a text editor and add the following line to the very top of the file:

#!/usr/bin/env python3

This line tells the operating system to use Python 3 to run the script.

Save and close the file.

Make the script executable. Open a terminal window and navigate to the directory where the script is located. Then, run the following command:

chmod +x PomodoroTimer.py

This command grants the script executable permissions.

Associate the script with the Python interpreter.

To make sure your script opens with Python when double-clicked, you need to associate .py files with the Python interpreter. To do this, follow these steps:

a. Right-click on the PomodroTimer.py file and select "Properties" from the context menu.

b. In the "Properties" window, navigate to the "Open With" tab.

c. Find the "Python 3" interpreter in the list of applications. If you don't see it, click "Show other applications" and find it in the extended list.

d. Select "Python 3" and click the "Set as default" button.

Double click the script: Now you should be able to double-click the PomodoroTimer.py file to run the script.
(Optional) Create a desktop shortcut.

Right-click on your desktop and select "Create a new launcher here" or "Create Launcher" (the wording may differ depending on your Ubuntu version).

In the "Create Launcher" window, fill in the details:

a. Type: Select "Application" from the dropdown menu.

b. Name: Enter a name for the shortcut, such as "Pomodoro Timer".

c. Command: Click the "Browse" button and navigate to the location of your PomodoroTimer.py file. Select the file and click "Open".

d. (Optional) Icon: Click the icon placeholder to choose an icon for the shortcut.

Click "OK" or "Create" to create the desktop shortcut.

With these enhancements, it's now time to work on creating a distributable version of the pilot application.

To convert the Python script into a Debian package (.deb file), I followed these steps:

Install required tools. Open a terminal and run the following commands to install the necessary tools:

sudo apt update
sudo apt install dh-python devscripts debhelper

Create a directory structure for the package. Replace your_package_name with a name for your package, and run the following commands:

mkdir -p your_package_name/usr/src/your_package_name
mkdir -p your_package_name/usr/bin
mkdir -p your_package_name/debian

Then, move your Python script (PomodoroTimer.py) to the your_package_name/usr/src/your_package_name directory.

Create a script to run the application. In the your_package_name/usr/bin directory, create a new file called your_package_name (without any file extension). In this file, add the following content:

#!/bin/sh
/usr/bin/python3 /usr/src/your_package_name/PomodoroTimer.py

Save the file and make it executable by running:

chmod +x your_package_name/usr/bin/your_package_name

Create a debian/control file. In the your_package_name/debian directory, create a new file called control. Add the following content to the file, replacing the placeholder text with your package details:

Source: your_package_name
Section: utils
Priority: optional
Maintainer: Your Name <your.email@example.com>
Build-Depends: debhelper (>=9), dh-python, python3
Standards-Version: 3.9.8

Package: your_package_name
Architecture: all
Pre-Depends: dpkg (>= 1.16.1), python3
Depends: ${shlibs:Depends}, ${misc:Depends}, ${python3:Depends}
Description: Short description of your package
 Long description of your package.

Create a debian/rules file. In the your_package_name/debian directory, create a new file called rules. Add the following content to the file:

#!/usr/bin/make -f

%:
    dh $@ --with python3 --buildsystem=pybuild --system=setuptools

Save the file and make it executable by running:

chmod +x your_package_name/debian/rules

Create a debian/changelog file. Add the following content to the file, replacing the placeholder text with your package details:

your_package_name (1.0-1) unstable; urgency=low

  * Initial release.

 -- Your Name <your.email@example.com>  <current_date>

Replace with the current date in the format Mon, DD MMM YYYY HH:MM:SS +ZZZZ.

Create setup.py file. Create a setup.py file in the root directory of your project with the following content:

from setuptools import setup, find_packages

setup(
    name="pomodorotimer",
    version="1.0",
    packages=find_packages(),
    entry_points={
        'console_scripts': [
            'pomodorotimer=pomodorotimer:main',
        ],
    },
)

Replace pomodorotimer:main with the appropriate module and function name for your application entry point.

Create a debian/compat file. Creating create a new file called compat in the debian directory with the following content:

This sets the compatibility level to 10, which should work with the tools you are using.

Build the Debian package. Navigate to the root of your your_package_name directory in the terminal and run the following command:

dpkg-buildpackage -us -uc

If the build is successful, a .deb file will be generated in the parent directory of your your_package_name folder.

Now, I have a .deb file that I can distribute and install on Debian-based systems using the dpkg -i your_package_name.deb command.

How to add a Credly Badge page to your site

Abhilash Panicker — Sun, 19 Mar 2023 11:52:46 +0000

Hello there!

I recently created a portfolio website for myself at https://dbugr.vercel.app/. While working on it, I faced the challenge of showcasing my various badges and certifications online, as a traditional 2-page resume wouldn't allow me to include all of them. That's where having a portfolio website comes in handy, as it allows recruiters to easily view my credentials separately.
In this post, I will walk you through how I created a separate page for my badges and certificates, complete with badge images and links to the Credly website for verification.

Step 1: Save the Credly page

To get started, I went to the Credly website and saved the page where all my badges are listed. For me, that page is https://www.credly.com/users/abhilash-panicker/badges. By saving this page, I was able to have access to the complete list of all my badges, along with the images of each badge. Additionally, I could obtain the links to each badge individually, making it easier to access the relevant information from the Credly site.

Step 2: Remove non-relevant sections:

Next, I investigated the downloaded HTML file and removed the non-relevant sections. Luckily, I found that the badge names were available in JSON format, which made my life much easier.
Here's an example of what I found:

accepted_badges: [
  {
    id: "f809e5ce-7e81-4790-8797-d287430a497e",
    name: "IBM Machine Learning Specialist - Associate",
    template: "57fdad10-d407-4f3e-bafb-754d565c52c2",
    created_by_id: "d5a90a02-5fe7-4915-a42d-8273c91cab0f",
    created_by_name: "IBM",
    issued_at: "2022-10-06",
    image: "/Badges-Credly_files/Machine_Learning_Specialist_-_Foundational.png",
    desc: "",
    skills: "",
  },
  // more badges...
]

With this information, I was able to put the data in a file and create an object with all the badge information, which I could then iterate through in the next step.

Step 3: Create a separate page for certifications

Once I had gathered all the necessary information about my badges and certifications, I created a separate page on my website dedicated to displaying them. I titled the page "Certifications" and designed it to include a section on the side that would allow users to easily navigate to the websites where they could view my academic projects and badges.

To achieve this, I used a nested div element and the Tailwind CSS framework to create a left side section for the page. The code for this section looks like this:

{/* Social Buttons */}

  {/* Social Links */}
  <h1>
    Links to my Certifications:
  </h1>



        <a href="https://www.credly.com/users/abhilash-panicker/badges">
          →

          <div className="text-lg text-gray-500 font-mono relative overflow-hidden dark:text-gray-300">
            <div className="absolute h-0.5 w-full bg-gray-400 bottom-0 transform -translate-x-24 group-hover:translate-x-0 transition duration-300"></div>
            Credly
          </div>
        </a>
      </div>
    </div>
    <div className="flex flex-row justify-start items-center">
      <div>
        <a href="https://eportfolio.mygreatlearning.com/abhilash-panicker"
           className="flex flex-row items-center space-x-4 group"
        >
          <div className="my-4">&rarr;</div>
          <div className="text-lg text-gray-500 font-mono relative overflow-hidden dark:text-gray-300">
            <div className="absolute h-0.5 w-full bg-gray-400 bottom-0 transform -translate-x-24 group-hover:translate-x-0 transition duration-300"></div>
            GreatLearning
          </div>
        </a>
      </div>
    </div>

As you can see, I used the certData object to iterate through and display each badge as a grid component. To create the grid, I separated each badge's CSS element and used the code below:

Credly Badges:

    {certData.accepted_badges.map((badg, idx) =&gt; (

    ))}

Conclusion: This is how you can too have a certifications page on your portfolio website and it can help showcase your skills and accomplishments since it is considered as an important part equivalent to experience while hiring. Feel free to try this on your own. Hope you enjoying reading.