DEV Community: Rahul Kumar

I wrote an entry for Future Writing Challenge, please give any feedback.

Rahul Kumar — Sun, 30 Mar 2025 15:34:46 +0000

Rahul Kumar

Mar 29 '25

Today You Are Searching for a Dress Mom, Tomorrow You Will Be Designing It.

#futurechallenge #foremfest #ai #technology

Comments

3 min read

Today You Are Searching for a Dress Mom, Tomorrow You Will Be Designing It.

Rahul Kumar — Sat, 29 Mar 2025 19:01:55 +0000

This is a submission for the Future Writing Challenge: How Technology Is Changing Things.

Dear Mom,

I received your message earlier, but I was busy with work so couldn’t figure out the one myself. But my little buddy here found the best among the two glass frames you asked me to choose from. He gave me good enough reason to choose the oval-broad frame as per your face length over the spherical one. His name is ChatGPT. Download it, it's an app on play store.

But wait, since you are buying from the regular, why don't you try their AR feature that allow you to check their glasses on you, live. It's a little bit rough right now but its good enough to give you an idea on how it would look on you. AR is a cool technology, it's on Amazon too, you can put any of their sofa or bed or carpet to check how it looks in our living room. But in coming time we will be able to get better quality of AR with less jank. Today, you have to make peace with their low-quality AR that does the job.

Anyway, I was wondering have you got the enough information on that tablet you were looking for. I think it's much easier to ask ChatGPT in simple language rather than typing long English sentences in Google Search. He will give you all the relevant information anything from salt to the dosage or any long-term side effect that medicine possess. In distant future our AIs will be able to prescribe us medicines on the basis of our symptoms same as what Doctors are doing online these days. The monitoring will be done by our smart watches like devices. The AI will take this information and prescribe us medicines.

Wait, you have sent me the picture of that pretty dress your favorite vlogger was wearing right? I wonder why she hasn't shared the link in the description, maybe not getting paid for wearing that dress 😅. Never mind, I found the link it's pretty cheap in price however it's not in the color you were looking for. I found that using the Google Lens. All you have to do is to take a screenshot and the lens icon will do the rest for you.
We are moving toward the future where we will just be able to design our own clothing, and the machines will prepare it in real time and deliver to us. No more worrying about the missing colors in the future.

I know you might be worried about the privacy using such apps and you might think I am using them as an excuse or trying to shrug away my responsibilities. First, as long as you are not sharing your "top-secret" personal information you will be fine. Keep in mind that ChatGPT do make a mental memory of the stuff you are sharing. But you can delete it. Second, no I am not shrugging off my responsibilities and apps like AI and AR is just making our life easier. I mean how would I find out that vlogger is wearing cheap dress? Anyway, have fun trolling the vlogger in her comment section.

With love,
Your son.

[Cover Photo by Anna Shvets from Pexels.]

Creating an ExpressJs Endpoint to Upload Single Image to Cloudinary

Rahul Kumar — Sun, 23 Mar 2025 16:38:46 +0000

In this tutorial we will explore the easiest way to upload an image to Cloudinary, a firebase alternative to upload images for free.

GitHub URL -> Wallpaper Website MERN

Now let's get to the introduction of technologies that we are needing for this project.

About Cloudinary

Cloudinary is a cloud solution that work as an alternative to firebase when it comes to uploading images. Cloudinary provides its SDK for almost all major languages. Not just through SDK, you can also use their API URL to upload Images directly from frontend, here is the tutorial.
Once file uploaded to their server, Cloudinary provide us with delivery URL that hot link the image that we have uploaded.

About Multer

Multer provides us with API that we need to upload image to our server. In our context we are using Multer to store image into memory as a buffer. You can also use this to upload your image to your local storage instead of Cloudinary. You will find more information through their official documentation.

Making a Backend Cloudinary Uploader is very straight forward. All you need are these few steps:

Creating a frontend that provide a single file uploader.
Making a route to the endpoint.
Creating a middleware using Multer to store file as a buffer in a memory.
Creating an entry point function that points to Cloudinary uploader function and make an entry in mongodb.
Making a function that upload the image stream to Cloudinary.
Converting image buffer into readable stream and then write it into Cloudinary.

Frontend Code

import { useState } from 'react';

export default function Submit() {
    const [formData, setFormData] = useState({
        title: '',
        img: null,
    });

    const [selectedImg, setSelectedImg] = useState(null);
    const [loading, setLoading] = useState(false);
    const [error, setError] = useState('');

    // Handle file selection
    const handleFileChange = (e) => {
        setFormData(prev => ({ ...prev, img: e.target.files[0] }));
        setSelectedImg(URL.createObjectURL(e.target.files[0]));
    };

    // Handle text input changes
    const handleChange = (e) => {
        setFormData(prev => ({ ...prev, [e.target.id]: e.target.value }));
    };

    // Handle category selection
    const handleCategoryChange = (e) => {
        setFormData(prev => ({ ...prev, category: e.target.value }));
    };

    // Submit form
    async function handleSubmit(e) {
        e.preventDefault();
        console.log('Submit button clicked');
        setLoading(true)

        if (!formData.img) {
            alert("Please select an image to upload.")
            setLoading(false)
            setError("Enter an image file to proceed")
            return;
        }

        const formDataToSend = new FormData();
        formDataToSend.append("img", formData.img);
        formDataToSend.append("title", formData.title);
        try {
            const res = await fetch('http://localhost:8080/wallpaper/upload', {
                method: 'POST',
                body: formDataToSend
            });
            const data = await res.json();
            console.log("Upload Success:", data);
            setLoading(false)
        } catch (error) {
            setLoading(false)
            setError('Error occurred while uploading wallpaper:', error)
            console.error('Error occurred while uploading wallpaper:', error);
        }
    }

    return (
        <div>
            <form onSubmit={handleSubmit}>
                <h1>Select an image file to upload (supported: .jpg, .png, .webp):</h1>
                <input type="file" id="img" onChange={handleFileChange} accept="image/*" required />

                {formData.img && (
                    <div>
                <img src={selectedImg} alt=""/>

                <label htmlFor="title">Title:</label>
                <input type="text" id="title" onChange={handleChange} required />

                <button type="submit">{loading ? "Uploading Wallpaper...." : "Upload Wallpaper"}</button>
                </div>
                )}


                {error && <p>{error}</p>}
            </form>
        </div>
    );
}

So far, we have made a simple page that have an input to upload image and a button to submit the form.
We have an endpoint http://localhost:8080/wallpaper/upload which we create in next step.

Route to endpoint

import express from 'express';
import {uploadFileMiddleware, uploadWallpaper} from "../somepath.js"
const router = express.Router();
router.post('/upload', uploadFileMiddleware, uploadWallpaper)
export default router;

We have created a route where we can send some data to upload our image.
Now before I start with the actual code, I want to make a quick schema for mongoose.

import mongoose from 'mongoose';

const wallpaperSchema = new mongoose.Schema({
    title:{
        type: String,
        required: true
    },
    img:{
        type: String,
        required: true
    },
    timestamp: {
        type: Date,
        default: Date.now
    }
});

const Wallpaper = mongoose.model('Wallpaper', wallpaperSchema);
export default Wallpaper;

Setting Up Middleware

Let's get to our imaginary somepath.js and set up middleware function.
In order to do that we need to install Multer.
First install Multer.

npm install multer

Importing Multer to our project.

import multer from 'multer';
const storage = multer.memoryStorage()
const upload = multer({storage:storage})
export const uploadFileMiddleware = upload.single('img');

We first create a storage that points to memoryStorage that means we are storing our image as a buffer into memory. And since we are storing it in memory the file size of an image may affect your system performance, but you don't need to worry since image file in many of our case won't go above 20MB (at best).
Then we will make an instance of multer named upload, that is configured to use memoryStorage.
Now we define our middleware. We are uploading a single image i.e., "img" in memory that will be accessible through req.file.

Setting up uploadWallpaper Function

uploadWallpaper is the entry function to upload image to Cloudinary as well creating an entry to mongoDB.

export const uploadWallpaper = async (req, res, next) => {
    console.log("uploadWallpaper");
    try {
        if (!req.file){
            console.error('Image not selected.')
            return next(404, 'Image not selected.');
        }
        const {img, title, altTitle, category, tags} = req.body;

        if (!title) {
            console.error('Title not filled.')
            return next(404, 'Title not filled.');
        }
        const uploadedUrl = await uploadToCloudinary(req.file.buffer, title);
        console.log("uploading wallpaper...");
        if (!uploadedUrl) {
            return next(500, 'failed to upload image to cloudinary');
        }
        console.log("uploadedUrl", uploadedUrl);
        const newWallpaper = await Wallpaper.create({
            title: title,
            img: uploadedUrl.secure_url.toString(),
        });
        res.status(200).send(newWallpaper)
    } catch (error) {
        console.log(error);
        next(error)
    }
}

I have made a next middleware to handle all the message that I need to send as a response.
Here is the code for that, you can put it into your index.js

app.use((err, req, res, next)=> {
    const statusCode = err.statusCode || 500;
    const message = err.message || 'Internal Server Error';
    res.status(statusCode).send({
        success: false,
        status: statusCode,
        error: message
    });

Setting up uploadToCloudinary Function

We are making a function that is uploadToCloudinary we are receiving file name (title) and the image file as a buffer through uploadWallpaper entry function.
Our job is to convert that buffer into a readable stream of data and upload that as a stream to Cloudinary.

We are using cloudinary SDK, if you need more information on that you can check their official documentation.

Before doing that we need certain access-data from Cloudinary that is their Cloud Name, API Key and API Secret. You will find API Key and API secret right from their dashboard through "Go To API Key" button.

You will find the cloud name there as well. You can change your cloud name from Settings > Product Environment if you like to do so.

Let's install Cloudinary to our project now.

npm install cloudinary

In our uploadToCloudinary function, the first order of business is configuring the access-data we have now. I would put this data into an env so uploading it to github doesn't expose my sensitive information to the public.

    cloudinary.config({
        cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
        api_key: process.env.CLOUDINARY_API_KEY,
        api_secret: process.env.CLOUDINARY_API_SEC
    });

In order to check wether your connection is working or not, you can ping to cloudinary using the below code, thanks to this github.

    await cloudinary.api.ping((error, result) => {
        if (error) {
            console.error("Ping failed", error);
        } else {
            console.log("Ping successful:", result);
        }
    });

Our uploadToCloudinary function will return a promise. Inside the promise we will create another function uploadedImage that will connect with upload_stream to upload our image.

        const uploadedImage = cloudinary.uploader.upload_stream(
            {
                resource_type: "image",
                public_id: `wallpaper/${title.trim()}`,
                display_name: title,
                overwrite: false,
                media_metadata: true,
            },
            (err, result) => {
                if (err) {
                    console.log('Error uploading image to server', err)
                    return reject(err)
                }
                else {
                    console.log(result)
                    console.log('Image uploaded successfully', result.secure_url)
                    resolve(result)
                }

            }            
        )

upload_stream works on certain options, you can configure it as per your choice or just use the one I have here.

The public_id however reflect in delivery url as well, it provides the url that has /wallpaper/certainimage.jpg. Thing to note here is wallpaper is not a folder but a prefix.

display_name will display the name of the image in cloudinary media explorer.

media_metadata has some specific informations regarding your image like piexlPerUnitX etc, you most like don't need it but I kept it true in case I may need it later.

You can find more information on it through their official documentation.

Turning this fileBuffer into a Readable Stream

In order to do that, first we need to import Readable from Stream (pretty convenient, eh?)

import {Readable} from "stream"

Then we store the stream into a variable str.

let str = Readable.from(fileBuffer)

Once done, we will pipe this stream into uploadedImage function, that function will now upload the image as a stream.

str.pipe(uploadedImage)

Pipe method will transfer readable stream to writeable stream. Picture what a pipe does in real life with a stream of water (not read and write offcourse) taking water stream from point source to destination that's what we are doing here.

Now we are done with it.
Here is the one uploading page I made for my project.

Clicking Upload Wallpaper will upload this image to Cloudinary with the title I chose.

Here is the url to download this image in case you find it wallpaper worthy!

I will put more tutorials on my dev.to page and I would like to continue this particular project on my website RM Ideas Blog. If you are interested, you can bookmark it for future reading. If you need any help, please add your comment and click on heart button if you liked this tutorial.

DFS Traversal Guide: Easy way to remember DFS Traversel Path

Rahul Kumar — Wed, 19 Jun 2024 15:19:03 +0000

There are two different way to traverse Binary Search Tree and Graph. The first approach is Breadth First Search (BFS) and the second one is Depth First Search (DFS). Both approaches have their own use case but two common objectives one can think of are finding the shortest distance between two nodes and detecting the loop in a tree.

BFS traverse horizontally acrross all levels, while DFS traverse vertically. Since we are traversing vertically, it give us more flexibility in choosing our approach of travelling.
These 3 paths are Pre-order, In-order, and Post-order. Although this flexibility is useful, it can also be confusing. Suppose you forget the order of DFS traversals but remember the rest of the code during an exam or interview. This could be disastrous because the overall code for DFS is relatively straightforward and similar for all three cases.

Depth First Search Traversal Approaches

In today's tutorial we are looking into the easiest way possible to remember DFS traversals.

DFS Pre-Order: In Pre-order DFS we move from Root/Subroots node to the Left node and to the Right node.
DFS In-Order: In In-order DFS we move from Left node to Root/Subroots node and to the Right node.
DFS Post-Order: In Post-order DFS we move from Left node to Right node and then to Root/Subroots node.

Probing the DFS Traversal Approaches to make it Easy to Remember

There are two common things in all three of the statements.

The order of Root/Subroot is changing but Left and Right are constant in simple words, we first move left and then right in all 3 traversals.
The traversal method's name indicate the position of Root/Subroot traversal.

Now let's see this through an example.

We have this BST

DFS Pre-Order

We first do the DFS Pre-order for this bst:

def dfs_in_order():
    results = []

  def traverse(current_node):
    results.append(current_node)
    if current_node.left:
        traverse(current_node.left)
    if current_node.right:
        traverse(current_node.right)

    traverse(root)
    return results

In above code we are adding Root first than traversing left and right if they exist. The output will be [47,21,18,27,76,52,82]

Notice our Root/Subroots is before Left and Right.

DFS In-Order

Doing DFS In-order will give us this result: [18,21,27,47,52,76,82]

Notice our Root/Subroots is in between Left and Right node.

  def traverse(current_node):
    if current_node.left:
        traverse(current_node.left)
    results.append(current_node)
    if current_node.right:
        traverse(current_node.right)

DFS Post-Order

Now we have left with DFS Post-order.

  def traverse(current_node):
    if current_node.left:
        traverse(current_node.left)
    if current_node.right:
        traverse(current_node.right)
    results.append(current_node)

Post-order wil further push results.append() to bottom. The output generated will be [18,27,21,52,82,76,47].

Notice how our Root/Subroots are after Left and Right node.

Conclusion:

Using "In/Pre/Post" prefix will help you determine the position of Root and Subroots in DFS easily. Other than that we are traversing Left to Right in all cases regardless of the position of Root and Subroots.

The Wonders of Python any() and all() function

Rahul Kumar — Wed, 15 May 2024 18:27:04 +0000

Before I start with any() and all() functions, I want to raise a situation where we have to match some text from provided strings.
Say, if we find "brown" and "fox" in this passage
"The quick brown fox jumps over the lazy dog." our program will print "we found it."

So, how do you do that?

Easy enough?
If you say no, we can do the same by storing "fox" and "brown" in a list.

This looks clean.
But,

Python doesn't like it because it doesn't allow a list on the left operand. Why? Because you simply can't find a list of items in a string. It's like checking all your grocery items from one small aisle.

But we can do the inverse of it. Say, we need to find "jump" in the following passages, "The quick brown fox jumps over the lazy dog" and "The five boxing wizards jump quickly."

This will print "we found it" without any error because we are looking for "jump" from two different passages, not the other way around.

But how do we fix our first error? Here Python's any() function comes into play.

This will successfully print "here, we found it!" How? any() is an in-built Python function which returns a boolean.
Since we have "fox" and "brown" in our phrase, the following condition becomes True. Let's dissect a little bit for you in case you are new to Python.

any([phrase in passage for phrase in ["fox", "brown"]])

Look at this line and try to understand what is happening. We are using list comprehension technique to find a phrase in a passage. The phrase will take elements from the list ["fox", "brown"] one by one and check with the passage. It's like writing:

The any() function will return true if either "fox" or "brown" is found in the passage. Otherwise, it returns False. It basically combines the if "fox" in passage or "brown" in passage, in short, the or condition for you.

Now, let's take an example of the all() function. Instead of using any() in the previous code, we are using all() to determine whether all the words in the phrase match those in the passage.

This will print:

This will prints:

all() function is easy to understand once you understood any(). All the all() function does is to check wether all the phrase exist inside the passage or not. If it doesn't, it will return True else False. In our case it prints "we found nothing" since the word "boy" is not in our passage.

In case we remove boy this will print "here we found it".

Conclusion
You can utilize any() in any of your project where your objective is to compare a list of items with a specific phrase of condition. For instance here is one real world example of any() function in selenium. Here we have a list of some common phrases we can found in error pages like 404 or Bad Gateway.

Thats all I wanted to cover in the any() and all() wonders. I hope I am able to make it easier for you to understand.

You can add some real world example in the comments too if you think of any().

Thanks for reading this article and have a great day ahead.

Goodreads Scraping using Python and Selenium

Rahul Kumar — Tue, 12 Apr 2022 19:26:30 +0000

Goodreads is the biggest library of books that allows saving your reading progress. Moreover, you can find a myriad of options for your next read.
Github - https://github.com/rahul-kumar-bly/Goodreads-Scrapper-Alpha

Note - This tutorial is for educational purposes only. No intent to scrape large-scale data from Goodreads. Logos used in cover-image are intellectual properties of Selenium and Goodreads.

Here in this tutorial, we are using Selenium to scrap a list of Must Read books available in their library along with we are going to create a module that allows us to search their website for a particular book.
So, let's get started.

Pre-requisite

In case you are new to selenium first read my how to get started with selenium in python guide, link here. The guide will help you to understand the basics you need to learn Selenium.
Goodreads account is needed for this tutorial along with its email id and password.
You need to have basic idea of Xpath (link).

Now, let's first import all the required modules.

Time to do the basic part now, creating instance of Service and Options class ready to your browser to open goodreads login page.

We will use instance of options later, first we need to check everything is working fine.

Run this script and it open the sign-in page of goodreads. Now, we are going to supply login id and password to this page as without it we are going to have some complication scraping data.

Once you load it will open the same login page but this time it login you and redirect to your profile page.

Let's move to the next step where we start doing scraping.
Our first objective to open a dedicated search page and send a book name and then retrieve a list of books.

This will search 20 books, unlike the first 2 result most of the other are summaries and translations or other related books with same title. So there is no reason to loop through all available pages and display every single result.

Open this link in your browser tab. Hit Ctrl+Shift+C to open inspect element and Ctrl + F inside inspect element window. Paste this code //table/tbody/tr[contains(@itemtype, 'http://schema.org/Book')] and hover over highlighted area. It will highlight a block which includes the cover image, title, rating, and other stuff as in below screenshot.

XPath stands for XML Path-Language.
I am not going into too much detail about Xpath but for starter it is a flexible way to address any part of HTML (well XML originally) which means you can access anything in HTML (or XML) using Xpath.
In our snippet we want to access <tr itemscope="" itemtype="http://schema.org/Book"> so in order to access we need to use relative path //table/tbody/tr tr contains itemptype="http://schema.org/Book" so for the same we will use [contains (@itemtype, 'http://schema.org/Book')] thus the complete code will be //table/tbody/tr[contains (@itemtype, 'http://schema.org/Book')]. There will be other instance of Xpath too in our tutorial that help you understand it better.

We also need to extract book-cover image url since the above code will not provide us with that. The image tag has class with a value bookcover which we can access using the .find_elements() method.
Next step is to create a list and store Title, Auhtor info, Rating, Image as list-tuple which we can achieve using loop.

It's time to display data in our terminal using pandas.

import pandas

and add these three lines of codes

Run and this will generate an excel file like this.

So far we have,

Open Goodreads and login with credentials
Search for a particular book title
Save the data into excel spreadsheet

Selenium Scraping in Python with Installation/Setup Guide

Rahul Kumar — Tue, 29 Mar 2022 17:49:33 +0000

Selenium allows you to automate web-related tasks whether it is fetching data from website (web scraping), filling forms and many more.

All these tasks are performed using a headless browser. A headless browser is nothing more than a browser without visible GUI which allows you to - make HTTP requests and keep session information.

My main focus in doing some basic operations on a website and fetch some information.

Pre-requisite

You should have basic HTML knowledge to understand how selenium works.
Understanding of DOM will be beneficial.

Installation

First Installation, regardless of your platform you need three things to get started.

Selenium Install selenium using pip install selenium
Headless Browser For this tutorial I am using chrome's chromedriver. Alternatively, you can use firefox headless browser called geckodriver. Install Chromedriver from this link. Install Geckodriver from this link.
A web browser with GUI Install Chrome using the following commands

wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo apt install ./google-chrome-stable_current_amd64.deb

Now without further ado let's create our first demo.

Import Selenium packages to your active project

import selenium
from selenium import webdriver
from selenium.webdriver import chrome
from selenium.webdriver.chrome.service import Service

Now let's open a website using.

s = Service("chromedriver.exe")
driver = webdriver.Chrome(service=s)
driver.get("https://rugsforyou.in/")

The Service class demands a path of executable, I have chromedriver.exe in same folder as my python file.
You can also use geckodriver.exe for Firefox.

The webdriver.Chrome creates a new instance of chrome driver.

Now its time to explain a bit about webdriver.

A webdriver is a component of Selenium which accept command and send them to browser to return result. Webdriver.Chrome demands an executable file for chromedriver that I am provide through a reference to Service class.

The .get() method is a way to load a web page in the current browser session. In short it creates an HTTP request for the supplied URL.

Now lets, create a simple automation using selenium. This will open this wonderful eCommerce site and enter a value into search bar and then show the result.
For this we need to import another class By.

from selenium.webdriver.common.by import By

# in continuation to the above code
send_data = driver.find_element(By.CLASS_NAME, value="ms-search-field")
send_data.send_keys("flower")
send_data.submit()

driver.find_element find the web element with class name "ms-search-field".

Using By you can define the locator eg - CLASS_NAME or ID.

The .send_keys("value") holds the value to allow typing into an input field in our case "ms-search-field" is an input field.

The .submit() submits the form.

In order to access the resulting website URL you can use .current_url object. For eg - print(driver.current_url)

Using headless browser

Just add the following command to run this program in headless state.

from selenium.webdriver.chrome.options import Options

# continuation to above code
opts = Options()
opts.headless = True
# change the arguments of Chrome class
driver = webdriver.Chrome(options=opts, service=s)

This will not open chrome browser but still load the data and print the result in terminal.

In order to revert it back to GUI remove options=opts from Chrome().
I now at this point you must be wondering why we have imported so many packages. So let's recap.

All possible LIST Idioms and Operations in Python

Rahul Kumar — Mon, 14 Mar 2022 18:49:06 +0000

I have added possible list operations/idioms available in Python.
Please note I have uploaded images of the code snippet as dev.to default code block offers lame black background with white text. You can find the following code into this github repo.

1. String to List

Code snippet to accept a string paragraph and convert it into list. Might be the most easiest code in the python.

Output:

['Lorem', 'Ipsum', 'is', 'simply', 'dummy', 'text', 'of', 'the',
'printing', 'and', 'typesetting', 'industry.', 'Lorem', 'Ipsum', 
'has', 'been', 'the', "industry's", 'standard', 'dummy', 'text', 
'ever', 'since', 'the', '1500s,', 'when', 'an', 'unknown', 
'printer', 'took', 'a', 'galley', 'of', 'type', 'and', 
'scrambled', 'it', 'to', 'make', 'a', 'type', 'specimen', 'book.']

2. List to String

Not really a list operation but very helpful for begineers.

Output:

Lorem Ipsum is simply dummy text of the printing and typesetting 
industry. Lorem Ipsum has been the industry's standard dummy text 
ever since the 1500s, when an unknown printer took a galley of 
type and scrambled it to make a type specimen book.

3. Integer to List

This code accept an integer and convert it into a list with all items being integer type. You can check the type of variable using print(type(variable_name)).

Output:

[4, 5, 8, 9, 4, 1, 2, 5, 6]

4. List to Integer

You can do this too using the same strategy as in Step 2.

Output:

458941256

5. Dictionary to List

Dictionary is by far the most powerful python data-type for me. So, what I am gonna do is convert the dictionary items and values into a nested list for eg., [[1,"alpha"], [2,"beta"]].

Output:

[[1, 'alpha'], [2, 'beta'], [3, 'gamma'], [4, 'sigma'], [5, 'omega']]

6. Tuple to List

This code will accept a nested tuple into nested list.

Output:

[[1, 'alpha'], [2, 'beta'], [3, 'gamma'], [4, 'sigma'], [5, 'omega']]

7. Find duplicates in the List

A code to find duplicate items in the list, find how many time it is repeated and put the detail into dictionary for eg., {'Lorem': 2, 'Ipsum': 2}.

Output:

{'Lorem': 2, 'Ipsum': 2, 'dummy': 2, 'text': 2, 'of': 2, 
'the': 3, 'and': 2, 'a': 2, 'type': 2}

8. Split String List into pairs

Split string into the pairs, what?
Say, "hello I am working" to ["hello I", "am working"].
Seems easy right? Let's do it.

Output:

['Lorem Ipsum', 'is simply', 'dummy text', 'of the', 'printing 
and', 'typesetting industry.', 'Lorem Ipsum', 'has been', "the 
industry's", 'standard dummy', 'text ever', 'since the', '1500s, 
when', 'an unknown', 'printer took', 'a galley', 'of type', 'and 
scrambled', 'it to', 'make a', 'type specimen', 'book.']

9. List can store Functions inside it

Yes you can store functions inside a list and access it the same way you access a list item, both using for-loop and through indices.

Output:

Hello Rahul how are you !
I AM MAD!

10. Map function with list

In simple words, map accept two iterators and iterate one iterator item with other until no items left. So, I am going to be a little creative and using the greet function from last step for demonstration.

Output:

['Hello, Ram how are you !', 'Hello, Abhishek how are you !', 
'Hello, Rahul how are you !']
[480, 250, 120]

Simple Diary/Note App in Django with User Login

Rahul Kumar — Mon, 07 Mar 2022 15:53:59 +0000

This is a simple note/diary app which allow you to create user account and write notes.

Sample Pictures

Find this on Github

How to add data from CSV file to MySQL using Python

Rahul Kumar — Sat, 05 Mar 2022 12:23:11 +0000

For this tutorial my agenda is:

Fetch data from CSV file

Add data to a list

Insert list data into a MySQL database

This is my CSV file:

Now, I will write a code to first add this data into a list which has dictionaries like this,

dict_list = [{'empid': '1', 'name': 'john', 'phone': '5123'}, {'empid': '2', 'name': 'jane', 'phone': '5124'}, {'empid': '3', 'name': 'doe', 'phone': '5678'}, {'empid': '4', 'name': 'adam', 'phone': '7427'}]

So, let's get started with today's tutorial. Make sure to have data.csv file into the same folder as your python file.
I assume that you have mysql up and running.

Step [1]: Import Required Modules

In this step I will import important modules

import pathlib
import csv
import mysql.connector

Step [2]: Assign file path

Make sure to keep you csv file in current working directory

csv_path = pathlib.Path.cwd() / "data.csv"

Step [3]: Fetch data from the csv file and add to dictionary

This will create a list with dictionaries as shown above

dict_list = list()
with csv_path.open(mode="r") as csv_reader:
    csv_reader = csv.reader(csv_reader)
    for rows in csv_reader:
        dict_list.append({'empid':rows[0], 'name':rows[1], 'phone':rows[2]})

Step [4]: Add a MySQL connection and cursor

Using connection we connect to database and cursor will help performing operations on it

mydatabase = mysql.connector.connect(
    username = 'root',
    password = 'adminuser',
    host = 'localhost',
)

mycursor = mydatabase.cursor()

Step [5]: Create a database and assign it to connection

We're making a database name "myempdb"

mycursor.execute("CREATE DATABASE myempdb")
# add below line inside your connect method 
# database = 'myempdb',

Step [6]: Create table 'emptable' in myempdb

The table will contains 3 rows "empid", "name", "phone"

mycursor.execute("CREATE TABLE emptable (empid INT PRIMARY KEY, name VARCHAR(255), phone INT")

Step [7]: Adding data to database

Add list_dict data to database using loop and closing database

for item in dict_list:
    sql = "INSERT INTO emptable(empid, name, phone) VALUES (%s, %s, %s)"
    val = item['empid'], item['name'], item['phone']
    mycursor.execute(sql, val)
mydatabase.commit()

Step [8]: Fetch the data and display it on terminal

This will show all the data stored in "emptable" into terminal

mycursor.execute('SELECT * FROM emptable')
myresult = mycursor.fetchall()
for x in myresult:
    print(x)

Step [9]: Fetch the data and display it on terminal

This will disconnect the connection to MySQL server

mydatabase.close()

Final code

# fetch data from csv file

import pathlib
import csv
import mysql.connector

csv_path = pathlib.Path.cwd() / "data.csv"

dict_list = list()
with csv_path.open(mode="r") as csv_reader:
    csv_reader = csv.reader(csv_reader)
    for rows in csv_reader:
        dict_list.append({'empid':rows[0], 'name':rows[1], 'phone':rows[2]})


mydatabase = mysql.connector.connect(
    username = 'root',
    password = 'adminuser',
    host = 'localhost',
    database = 'myempdb',
)

mycursor = mydatabase.cursor()

mycursor.execute("CREATE DATABASE myempdb")

mycursor.execute("CREATE TABLE emptable (empid INT PRIMARY KEY, name VARCHAR(255), phone INT")

for item in dict_list:
    sql = "INSERT INTO emptable(empid, name, phone) VALUES (%s, %s, %s)"
    val = item['empid'], item['name'], item['phone']
    mycursor.execute(sql, val)
mydatabase.commit()


mycursor.execute('SELECT * FROM emptable')
myresult = mycursor.fetchall()
for x in myresult:
    print(x)

mydatabase.close()

Django Basic Oversimplified Part - 1

Rahul Kumar — Tue, 15 Feb 2022 12:50:21 +0000

Hi and welcome to Django Basic Oversimplified.

Before I start with the tutorial, let me tell you a little story.
15 days ago I started working on django and I kid you not this is the most intimidating process I have ever faced in my life. There are steps after steps I needed to take before displaying just 2 words on a blank page.

It's not just me but other people too found it baffling. So, once I learned and created 2 small projects I decided to create a simple tutorial to explain what you really need to know in your first try.

In this tutorial I will focus on introduction of various steps used in creating a Django app/website. Again, this post might look scary but trust me its not.

Getting Started with Django
Initializing the Project Folder and App Folder
Defining Views

A short note: I am using WSL2 on top of my Windows 10 Visual Studio Code IDE. I highly recommend you to use WSL2 in case you are in Windows 10 or higher.

Getting Started with Django

Installing necessary files and setting up virtual environment.

Now lets start by creating a folder with whatever name you like, for the sake of this tutorial I am choosing "django-oversimplified".

mkdir django-oversimplified

Now we need to open our visual code in this folder. In order to do that first enter into folder using cd.

cd django-oversimplified
code .

Mind the space between code and .(dot) it will open VS Code into our folder. If this ask for permission, allow it.

Now we have to run virtual environment first install it using

sudo apt virtualenv

You don't need to overthink about virtual environment here. It will pack all our python module inside and make it accessible by the other people who are using our code.

The next step is to activate it.

python3 -m venv .venv
source .venv/bin/activate

The first line means we are creating a folder for virtual environment. Let me explain it further python3 -m means we are accessing a python module which is venv in our case and creating an enivronment directory named .venv. The dot before name will make it hidden.

The second line means we are activating a script which is in activate folder within .venv/bin
There is nothing more you need to know about venv right now. Beside it will carry any module we download or install inside it.

You can use clear command to clear your terminal window.

clear

Now, its time for me to create our first project but before that we need to install django.

pip install django

If you already have django isntalled then this will copy django to your .venv folder.

Till this point we -

Created a directory for our project
Installed PIP and Virtual Environment
Activated Virtual Environment
Downloaded Django

Initializing the Project Folder and App Folder

The first step to your app, setting up urls and running our sample app.

Now we are ready to create our first app but first lets create our project. The project in itself is not your app it does not visualize anything.
In simple words it is a set of settings or configurations which power your django apps or websites you will come to know more about them when we start using them.

django-admin startproject myproject

This will generate a directory and inside another directory with same name and a python file "manage.py".
Its a bit awkward to enter myproject and then working on another myproject directory. So let's remove it and create our project folder right inside django-oversimplified.

rm -r myproject

You can simply delete it but it just a linux command for us. rm is for remove directory and -r flag denotes the directory is not empty.

django-admin startproject myproject .

Mind the space between myproject and .(dot). The dot ensure this directory (django-oversimplified) and ensure the project folder is generated inside our main directory.

Your project folder will look like this.

Time to create an app named 'myapp'.

django-admin startapp myapp

You don't need to worry about subfolder this time as this will be generated inside your main folder.

Now once you expand the myapp folder you will see some bunch of files there.

We are going to work with admin.py, apps.py, models.py, and views.py for this project plus one more file which you will find soon.

Now, lets get back to our settings folder "myproject". In here we are going to work with settings.py and urls.py.

The very first thing I am gonna do is register our app in settings.py. Remember our app name is same as its directory
myapp'.

In settings.py find the INSTALLED_APPS (line 33) list and inside this list enter your app name.

'myapp',

This means we have linked/installed myapp with our project. Save it and close it for now.

Now we are very close to our first app.

Open urls.py this file will ensure the navigations in our app. However, we are going to create another file in our app folder in order to make everything easy.
For this we need to include that particular file in our URLS.py. Just to make it clear the first line of code in **urlpatterns **list ensure the path to admin.

See you urls will be like this 127.0.0.1:8000 and the admin here will be 127.0.0.1:8000/admin/ the extra slash after admin ensure the same on your URL part in browser. We will learn more about it later.

Now what we want to do is to avoid using this file in future so we are going to create a point where we can access all of this file feature right from our app folder.

In our myapp folder create a file, URLS.py.
Now, get back to the project folder and URLS.py and add a piece of code first.

from django.urls import include

and inside your urlpatterns

path('', include('myapp.urls')),

We have pointed our urls.py file inside myapp folder which will handle operations on every url except admin.
So, if you want to handle 127.0.0.1:8000/helloworld/, the urls.py file inside myapp will take care of it.

Now move on to your myapp.urls file and enter the following code

from django.urls import path
urlpatterns = [

]

Till this point we -

Created our project/setting folder
Created an app named myapp
Installed our app in settings.py
Handle the URL behaviors

Defining Views

Creating urls.py file and running our very first hello world app.

Now we are going to design what we call view.
Now, what does it means? is it means we are designing our frontend? Sort of.

Remember Django is not MVC, it is MVT.

M stands for models/database
V stands for views
T stands for template

Just like in MVC the C is controller its exactly what views in our Django.
Controller controls what going to be in your front end it doesn't design the frontend but controls the behavior of it.
The template will display the content to your front-end nevertheless.

This article is getting longer. but don't worry it will become a piece of cake.
Now in our views.py we are going to create a function that display the most anticipated hello world message. But before anything let's ensure everything is working fine. Type,

python manage.py runserver

Click on the url by holding ctrl key or just type 127.0.0.1:8000 in your browser.

If you can see "The install worked successfully" page, well done its working.
If you can't make sure to back-track this tutorial.

It's time to display a hello world message on our home page.
Open your views.py file and enter below code first then I will explain what we just did.

def hello_world(request):
    return HttpResponse("<h1>Hello World</h1>")

Now get to your urls.py (myapp) and enter

from . import views
urlpatterns =[
path('',views.hello_world),
]

This should look something like this.

It will display this.

In the first code block we define a function name hello_world which receive a request.
Now request is whatever you provide to the browser. In our case we are requesting the homepage which means 127.0.0.1:8000 see we are not using requesting any endpoint like /admin/ after the url.

And it returns the httpresponse which in simple word is html.
If you open the page in browser as code (Ctrl+U) you will see the exact same code.

<h1>Hello World</h1>

We have defined a pattern for this file inside the urls.py (myapp).
We used empty '' string to ensure this hello world will display on our homepage and we added our hello_world to make sure it process the function we created for every http://127.0.0.1:8000/ request.

At this point we -

Learn what is views and created one
Link our view to URLS.py file in my app
Accessed our hello world app

This was the part 1 of our Django Basic Oversimplified series. I will get back to you with more forthcoming parts.
What's next?
We will create a site which accept data from user and store it into database and send an email on behalf of it.
Till now, happy coding.

DEV Community: Rahul Kumar

I wrote an entry for Future Writing Challenge, please give any feedback.

Today You Are Searching for a Dress Mom, Tomorrow You Will Be Designing It.

Today You Are Searching for a Dress Mom, Tomorrow You Will Be Designing It.

Creating an ExpressJs Endpoint to Upload Single Image to Cloudinary

About Cloudinary

About Multer

Frontend Code

Route to endpoint

Setting Up Middleware

Setting up uploadWallpaper Function

Setting up uploadToCloudinary Function

Turning this fileBuffer into a Readable Stream

DFS Traversal Guide: Easy way to remember DFS Traversel Path

Depth First Search Traversal Approaches

Probing the DFS Traversal Approaches to make it Easy to Remember

DFS Pre-Order

DFS In-Order

DFS Post-Order

Conclusion:

The Wonders of Python any() and all() function

Goodreads Scraping using Python and Selenium

Pre-requisite

Selenium Scraping in Python with Installation/Setup Guide

Pre-requisite

Installation

Import Selenium packages to your active project

Now its time to explain a bit about webdriver.

Using headless browser

All possible LIST Idioms and Operations in Python

1. String to List

2. List to String

3. Integer to List

4. List to Integer

5. Dictionary to List

6. Tuple to List

7. Find duplicates in the List

8. Split String List into pairs

9. List can store Functions inside it

10. Map function with list

Simple Diary/Note App in Django with User Login

Sample Pictures

How to add data from CSV file to MySQL using Python

Step [1]: Import Required Modules

Step [2]: Assign file path

Step [3]: Fetch data from the csv file and add to dictionary

Step [4]: Add a MySQL connection and cursor

Step [5]: Create a database and assign it to connection

Step [6]: Create table 'emptable' in myempdb

Step [7]: Adding data to database

Step [8]: Fetch the data and display it on terminal

Step [9]: Fetch the data and display it on terminal

Final code

Django Basic Oversimplified Part - 1

Table of Contents

Getting Started with Django

Installing necessary files and setting up virtual environment.

Initializing the Project Folder and App Folder

The first step to your app, setting up urls and running our sample app.

Defining Views

Creating urls.py file and running our very first hello world app.