DEV Community: Pandeyashish17

Generate image from text with random gradient background everytime

Pandeyashish17 — Wed, 18 Jan 2023 07:01:08 +0000

import random
from PIL import Image, ImageDraw, ImageFont

# Create a new image with a gradient background
width, height = 200, 50
start_color = (random.randint(0,255),random.randint(0,255),random.randint(0,255))
end_color = (random.randint(0,255),random.randint(0,255),random.randint(0,255))
img = Image.new('RGB', (width, height), color = start_color)
draw = ImageDraw.Draw(img)

# Add a gradient to the background
for x in range(width):
    for y in range(height):
        color = tuple(int(start_color[i] + (end_color[i] - start_color[i]) * x / width) for i in range(3))
        draw.point((x, y), fill=color)

# Use the Audiowide font
font = ImageFont.truetype("Audiowide-Regular.ttf", size=24)

# Draw the text on the image
draw.text((10, 10), "Hello, World!", fill=(0, 0, 0), font=font)

# Save the image
img.save('text_image.png')

Let's Create a Face Detector: A Step-by-Step Guide Using OpenCV

Pandeyashish17 — Sun, 15 Jan 2023 09:19:58 +0000

In this article, We'll be diving into the world of computer vision and image processing by using a popular library in Python called OpenCV. OpenCV is a powerful library that allows us to perform various image and video processing tasks, and it has a lot of pre-trained models that can be used for various tasks such as object detection, face detection, and more.

One of the most popular pre-trained models in OpenCV is the Haar cascade classifier for face detection. This classifier is trained to detect faces in images, and it's a very powerful tool that can be used for a wide range of applications, such as security cameras, photo tagging, and more.

Here's an example of how to use the Haar cascade classifier for face detection in Python:

import cv2

# Load the cascade classifier
#download this here https://raw.githubusercontent.com/opencv/opencv/4.x/data/haarcascades/haarcascade_frontalface_default.xml just go there and ctrl + s
face_cascade = cv2.CascadeClassifier("haarcascade_frontalface_default.xml") 

# Read the input image
img = cv2.imread("input.jpg")

# Convert into grayscale
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# Detect faces
faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5)

# Draw rectangle around the faces
for (x, y, w, h) in faces:
    cv2.rectangle(img, (x, y), (x+w, y+h), (0, 0, 255), 2)

# Save the output image
cv2.imwrite("output.jpg", img)

output:

The first step is to import the OpenCV library, and then we load the cascade classifier using the cv2.CascadeClassifier() function. We then read the input image using the cv2.imread() function, and convert it to grayscale using the cv2.cvtColor() function.

Next, we use the face_cascade.detectMultiScale() function to detect faces in the image. This function takes in the grayscale image as well as some parameters such as the scale factor and the minimum number of neighbors.

Finally, we draw rectangles around the detected faces using the cv2.rectangle() function, and save the output image using the cv2.imwrite() function.

In this way, we can use the Haar cascade classifier to detect faces in images. With OpenCV, you can do a lot more things like object detection, image stitching, and more.

Let's built an image generator using openai Dall-e and flask python

Pandeyashish17 — Sat, 14 Jan 2023 15:45:16 +0000

In this article, I will show you how to use the OpenAI Image Generator in a web application built with the Flask framework. The OpenAI Image Generator is a deep learning model that can generate images from text prompts, making it a powerful tool for creating custom images for various purposes such as website backgrounds, illustrations, or even creating data sets for machine learning.

The first step is to install the necessary libraries. You will need to install Flask, the web framework we will be using to build the application and openai, the python library that provides access to the OpenAI API. You can install them by running the following command:

pip install flask openai

Next, you will need to create a new Flask application and define a route for it. The following code sets up a basic Flask application and defines a single route that generates an image when accessed.

from flask import Flask, render_template
import openai

app = Flask(__name__)

# Authenticate with the OpenAI API
openai.api_key = "Your_openai_api_key" #get them here https://beta.openai.com/account/api-keys

@app.route('/')
def generate_image():
    # Specify the image prompt
    prompt = "cat swimming in a river"

    # Generate the image
    response = openai.Image.create(prompt=prompt, n=1, size="256x256")

    # Get the URL of the generated image
    image_url = response['data'][0]['url']

    return render_template('image.html', image_url=image_url)

if __name__ == '__main__':
    app.run(debug=True)

The first step is to authenticate with the OpenAI API by setting the api_key. This is a unique key that is generated when you create an account on the OpenAI website. The @app.route('/') decorator is used to define the default route for the web application. When this route is accessed, the generate_image() function is called.

This function first specifies the image prompt, which is a text description of the image that the model should generate. In this example, the prompt is "cat swimming in a river". The openai.Image.create() method is then called, passing in the prompt and other parameters such as n and size. The n parameter specifies the number of images to generate and the size parameter specifies the size of the generated images.

The response from the API is a JSON object that contains the URL of the generated image. The image_url is extracted from the response and passed to the render_template() function. This function renders the image.html template and passes the image_url to it.

The image.html template is a simple HTML file that displays the generated image using an img tag. The src attribute of the tag is set to the image_url, so the browser will load the image from that URL.

<!DOCTYPE html>
<html>
  <head>
    <title>Generated Image</title>
  </head>
  <body>
    <img src="{{ image_url }}" alt="Generated Image" />
  </body>
</html>

Creating Secure Passwords with Python and Tkinter: The "Password Generator" Code

Pandeyashish17 — Fri, 13 Jan 2023 12:40:25 +0000

Hey guys, are you tired of coming up with new and creative passwords for all of your online accounts? Well, have no fear! The "Password Generator" is here to save the day.

code:

import tkinter as tk
import random
import clipboard

def generate_password():
    length = length_var.get()
    include_capital_letters = capital_letters_var.get()
    include_special_symbols = special_symbols_var.get()
    include_numbers = numbers_var.get()
    include_small_letters = small_letters_var.get()

    password = ""
    for i in range(length):
        if include_capital_letters and random.random() > 0.5:
            password += chr(random.randint(65, 90))
        elif include_small_letters and random.random() > 0.5:
            password += chr(random.randint(97, 122))
        elif include_special_symbols and random.random() > 0.5:
            password += chr(random.randint(33, 47))
        elif include_numbers and random.random() > 0.5:
            password += chr(random.randint(48, 57))
        else:
            password += chr(random.randint(97, 122))

    password_entry.delete(0, tk.END)
    password_entry.insert(0, password)

def copy_password():
    clipboard.copy(password_entry.get())

root = tk.Tk()
root.title("Password Generator")
root.configure(bg='aqua')

length_var = tk.IntVar()
length_var.set(8) 

capital_letters_var = tk.BooleanVar()
capital_letters_var.set(True)

small_letters_var = tk.BooleanVar()
small_letters_var.set(True)

special_symbols_var = tk.BooleanVar()
special_symbols_var.set(True)

numbers_var = tk.BooleanVar()
numbers_var.set(True)

length_label = tk.Label(root, text="Length:", font=("Helvetica", 20), bg='aqua')
length_label.pack()

length_entry = tk.Entry(root, textvariable=length_var, font=("Helvetica", 20))
length_entry.pack()

capital_letters_checkbox = tk.Checkbutton(root, text="Include capital letters", variable=capital_letters_var, font=("Helvetica", 20), bg='aqua')
capital_letters_checkbox.pack()

small_letters_checkbox = tk.Checkbutton(root, text="Include small letters", variable=small_letters_var, font=("Helvetica", 20), bg='aqua')
small_letters_checkbox.pack()

special_symbols_checkbox = tk.Checkbutton(root, text="Include special symbols", variable=special_symbols_var, font=("Helvetica", 20), bg='aqua')
special_symbols_checkbox.pack()

numbers_checkbox = tk.Checkbutton(root, text="Include numbers", variable=numbers_var, font=("Helvetica", 20), bg='aqua')
numbers_checkbox.pack()

generate_button = tk.Button(root, text="Generate Password", command=generate_password, font=("Helvetica", 20), bg='aqua')
generate_button.pack()

password_entry = tk.Entry(root, font=("Helvetica", 20), bg='aqua')
password_entry.pack()

copy_button = tk.Button(root, text="Copy to Clipboard", command=copy_password, font=("Helvetica", 20), bg='aqua')
copy_button.pack()

root.mainloop()

output:

This handy dandy piece of code, written in the powerful programming language Python, uses the Tkinter library to create a user-friendly interface that allows you to customize the length and character set of your new password.

But wait, there's more! Not only does this bad boy generate a brand new, never-before-used password for you, it also has the capability to copy it straight to your clipboard. That's right, no more manually selecting, copying, and pasting. This code does it all for you.

But don't just take our word for it. Try it out for yourself and see the magic happen.

So don't waste another second using "password123" or "qwerty" as your go-to password. Let the "Password Generator" handle it and sit back and relax, knowing that your online accounts are safe and secure.

In short, this code is a simple password generator with a graphical user interface which allows the user to choose the length of password and also the types of characters (capital letters, small letters, special symbols, numbers) to include in the password and copy the password to clipboard.

This code uses the Tkinter library to create a graphical user interface (GUI) for the user to interact with. The user can select the desired length of the password, and whether or not to include capital letters, small letters, special symbols, and numbers in the password.

The generate_password() function is responsible for creating the password based on the user's selections. It uses a for loop to iterate through the desired length of the password, and within the loop, it uses a series of if/elif statements and the random module to determine which type of character (capital letter, small letter, special symbol, or number) to add to the password.

The copy_password() function is used to copy the generated password to the clipboard, so the user can easily paste it into the desired account.

Overall, this code is a simple, yet effective way to generate a secure password with the added convenience of being able to copy it to the clipboard. So, next time you need a new password, give this code a try!

Let's see wifi password using python

Pandeyashish17 — Fri, 13 Jan 2023 10:46:56 +0000

Hey guys, welcome to the world of Python and wifi hacking... just kidding! In this article, we will be taking a look at a Python script that can be used to view the Wi-Fi password for a network you are currently connected to.

The script uses the subprocess module to run the command netsh wlan show profile [network name] key=clear. This command retrieves information about the specified network and the stdout=subprocess.PIPE redirects the output to a variable.

The output is then decoded and stored in the output variable. After that, the script splits the output into a list of lines, and iterates through each line. If a line contains the string "Key Content", the script extracts the wifi password from the line and prints it.

Here's the full script for your reference:

import subprocess

network_name = "Get your own wifi" #your_wifi_network_name

result = subprocess.run(['netsh', 'wlan', 'show', 'profile', network_name, 'key=clear'], stdout=subprocess.PIPE)
output = result.stdout.decode()

for line in output.split('\n'):
    if "Key Content" in line:
        print(line.split(":")[1].strip())

As you can see, this script is quite simple and straightforward. You just need to replace "Get your own wifi" with the name of the network you want to retrieve the password for.

And that's it, folks! With this script, you'll be able to hack into your own wifi network and retrieve the password in case you forget it!

Using OpenWeatherMap API and Tkinter to create a graphical weather app

Pandeyashish17 — Thu, 12 Jan 2023 15:23:49 +0000

Hey guys, This short article provides a sample Python code that uses the Tkinter library to create a graphical user interface (GUI) for a weather app. The app allows users to enter a city name and retrieve weather information for that city from the OpenWeatherMap API. The GUI includes a background gradient image, a text entry field for the city name, and a button to retrieve the weather information.

code:

import tkinter as tk
from tkinter import messagebox
import requests
from PIL import Image, ImageTk

def get_weather():
    city = city_entry.get()
    api_key = "your api key" #go to openweather 
    url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}"

    # Show loading state
    weather_label.config(text="Loading...")
    icon_label.config(image='')

    response = requests.get(url)
    weather_data = response.json()
    if "message" in weather_data:
        messagebox.showerror("Error", weather_data["message"])
    else:
        weather_text = f"City: {city}\n"
        weather_text += f"Temperature: {weather_data['main']['temp']}°F\n"
        weather_text += f"Pressure: {weather_data['main']['pressure']} hPa\n"
        weather_text += f"Humidity: {weather_data['main']['humidity']}%\n"
        weather_text += f"Min Temp: {weather_data['main']['temp_min']}°F\n"
        weather_text += f"Max Temp: {weather_data['main']['temp_max']}°F\n"
        weather_text += f"Wind Speed: {weather_data['wind']['speed']} m/s\n"
        weather_text += f"Description: {weather_data['weather'][0]['description']}\n"
        weather_text += f"Sunrise: {weather_data['sys']['sunrise']}\n"
        weather_text += f"Sunset: {weather_data['sys']['sunset']}\n"
        weather_label.config(text=weather_text)

        #update icon
        icon_name = weather_data['weather'][0]['icon']
        icon_url = f"http://openweathermap.org/img/wn/{icon_name}@2x.png"
        icon_data = requests.get(icon_url)
        with open("icon.png", "wb") as f:
           f.write(icon_data.content)
        icon_image = ImageTk.PhotoImage(Image.open("icon.png"))
        icon_label.config(image=icon_image)
        icon_label.image = icon_image


root = tk.Tk()
root.title("Weather App")


# Create gradient image
gradient = Image.new("RGBA", (1, root.winfo_height()), "#8EC5FC")
pixels = gradient.load()
for y in range(gradient.size[1]):
    color = int(y / gradient.size[1] * 255), 140, 255
    for x in range(gradient.size[0]):
        pixels[x, y] = color
gradient = gradient.resize((root.winfo_width(), root.winfo_height()))
gradient = ImageTk.PhotoImage(gradient)


#Set gradient image as background
bg_label = tk.Label(root, image=gradient)
bg_label.place(relx=0, rely=0, relheight=1, relwidth=1)

# Frame
frame = tk.Frame(root, bg='#80c1ff', bd=5)
frame.place(relx=0.5, rely=0.1, relwidth=0.75, relheight=0.1, anchor='n')

# Entry
city_entry = tk.Entry(frame, font=("Courier", 14))
city_entry.place(relwidth=0.65, relheight=1)
city_entry.insert(0, "Washington D.C.")

# Get Weather button
get_weather_button = tk.Button(frame, text="Get Weather", font=("Courier", 12), command=get_weather)
get_weather_button.place(relx=0.7, relwidth=0.3, relheight=1)

# Weather label
weather_frame = tk.Frame(root, bg='#80c1ff', bd=10)
weather_frame.place(relx=0.5, rely=0.3, relwidth=0.75, relheight=0.5, anchor='n')
weather_label = tk.Label(weather_frame, font=("Courier", 14), justify='left', bd=5)
weather_label.place(relwidth=1, relheight=1)

# Weather icon
icon_frame = tk.Frame(weather_frame, bg='#80c1ff')
icon_label = tk.Label(icon_frame)
icon_label.place(relx=0.5, rely=0.5, anchor='center')
icon_frame.place(relx=0.8, rely=0.3, relwidth=0.2, relheight=0.4, anchor='n')

root.mainloop()

output:

The code starts by importing the necessary libraries, including Tkinter, messagebox, requests, and PIL. The get_weather() function is defined next, which is called when the user clicks the "Get Weather" button. The function first retrieves the city name from the text entry field and constructs the URL for the OpenWeatherMap API request. It then sends the request and retrieves the weather data in the form of a JSON object.

If the response includes an error message, the code shows an error message dialog box. Otherwise, it parses the JSON data to extract the weather information and displays it in a label on the GUI. The code also retrieves the weather icon from the OpenWeatherMap API and displays it on the GUI.

The remaining code creates the GUI elements, including the background gradient image, frame, entry field, and buttons. The resulting weather app provides a simple and easy-to-use interface for retrieving weather information for a given city.

Designing ChatGPT: Matrix-inspired Interface

Pandeyashish17 — Thu, 12 Jan 2023 07:31:17 +0000

Do You want your chatgpt to look like like:

then follow this link: https://github.com/Pandeyashish17/ChatGPT-Matrix-Style

A chrome extension everyone must have | part 1

Pandeyashish17 — Thu, 12 Jan 2023 06:31:34 +0000

youtube.com

A single Cmd/Ctrl+M command will activate Merlin, an OpenAI ChatGPT-powered helper that adds a dash of AI magic to all of your favorite websites.

You can utilize OpenAI's ChatGPT on all of your favorite websites, including as Google Search, Gmail, LinkedIn, and Github, thanks to Merlin, a ground-breaking new user interface. You may quickly and simply add answers, summaries, and some fun to your online material with only a few easy clicks.

How it functions

Pick any online material
To access the Merlin box, use Cmd+M on a Mac or Ctrl+M on a Windows computer.
Then, once you've decided what to do with it (write a response, paraphrase, condense, or add some humor), there you have it. You will be in possession of a reply .

Merlin is also great for troubleshooting and excel formulas, and even writing professional emails. It's currently free to use for all V1 users, but stay tuned for a small paywall coming soon. Available on Chrome, Edge, Firefox, and any Chromium-based browsers. Try it out now at getmerlin.in or merlin.foyer.work and let us know what you think!

Let's generate your Wifi qr code with flask Python

Pandeyashish17 — Wed, 11 Jan 2023 15:54:28 +0000

Welcome to the world of QR code generators! Today, we're going to build our very own WiFi QR code generator using the Flask web framework and the qrcode library. But before we get started, let's make sure we have everything we need.

First, make sure you have Flask installed. You can install it by running pip install flask in your terminal. Next, we'll need to install the qrcode library. You can do this by running pip install qrcode==6.0. This is an important step because it ensures that we're using the right version of the library that is compatible with the rest of our code.

Now that we have everything we need, let's get started on our code! We'll start by importing Flask, request, and send_file from the flask module, as well as qrcode and BytesIO from the io module.

from flask import Flask, request, send_file
import qrcode
from io import BytesIO

Next, we'll create an instance of the Flask class, which we'll use to define and run our web application.

app = Flask(__name__)

Now, we'll define a route for our application using the @app.route decorator. This route will handle requests to the "/" endpoint, and call the generate_qr() function that we'll define next.

@app.route('/')
def generate_qr():

Inside the generate_qr() function, we'll create two variables, ssid and password, which will store the name and password for our WiFi network, respectively. We'll then use these variables to create a string in the format that qrcode library uses to encode WiFi information into a QR code.

    ssid = "Get Your Own Wifi"
    password = "ItIsMyWifi69"

    wifi_data = 'WIFI:S:{};T:WPA;P:{};;'.format(ssid, password)

Next, we'll create an instance of the QRCode class, which will allow us to generate a QR code with the information we've provided. We'll set the version, error correction, box size, and border properties to configure the QR code.

    qr = qrcode.QRCode(version=1, error_correction=qrcode.constants.ERROR_CORRECT_L, box_size=10, border=5)

Then, we'll add the wifi_data to the QR code object and fit the data to the QR code

    qr.add_data(wifi_data)
    qr.make(fit=True)

We'll create an image of the QR code with the fill_color and back_color to be black and white respectively.

    img = qr.make_image(fill_color="black", back_color="white")

We'll now create a BytesIO object to hold the image in memory and save the image to the BytesIO object in PNG format

    byteIO = BytesIO()
    img.save(byteIO, 'PNG')

We'll reset the seek to the start of the byteIO object and return the image file with 'image/png' mimetype.

    byteIO.seek(0)
    return send_file(byteIO, mimetype='image/png')

Finally, we'll add a check to run the application only if the script is being run directly (and not imported as a module).

if __name__ == '__main__':
    app.run(port=5000,debug=True)

And that's it! Our WiFi QR code generator is now complete. You can now run the script and visit "http://localhost:5000/" to see your very own QR code for your WiFi network. With this handy tool, you can easily share your WiFi network with friends and family without having to reveal your password. Just remember, never share your wifi passwords with anyone you don't trust. Have fun and happy coding!

Full Code :

from flask import Flask, request, send_file
import qrcode
from io import BytesIO

app = Flask(__name__)

@app.route('/')
def generate_qr():
    ssid = "Get Your Own Wifi"
    password = "ItIsMyWifi69"

    wifi_data = 'WIFI:S:{};T:WPA;P:{};;'.format(ssid, password)

    qr = qrcode.QRCode(version=1, error_correction=qrcode.constants.ERROR_CORRECT_L, box_size=10, border=5)
    qr.add_data(wifi_data)
    qr.make(fit=True)
    img = qr.make_image(fill_color="black", back_color="white")

    byteIO = BytesIO()
    img.save(byteIO, 'PNG')
    byteIO.seek(0)
    return send_file(byteIO, mimetype='image/png')

if __name__ == '__main__':
    app.run(port=5000,debug=True)

Let's create corona virus using python

Pandeyashish17 — Wed, 11 Jan 2023 09:07:19 +0000

Welcome to the wild and wacky world of turtle graphics! Today, we're going to explore the world of turtle programming by creating a fun, virus-like image.

Full Code:

import turtle
turtle.speed(40)
turtle.color('cyan')
turtle.bgcolor("black")
b = 200
while b > 0:
    turtle.left(b)
    turtle.forward(b*3)
    b = b - 1

First, we're going to import the turtle module and set the speed to 40. This means that the turtle will move quickly, creating a cool, dynamic effect. Next, we're going to set the color to cyan and the background color to black. This creates a cool, neon-like effect that will make our virus stand out.

Now comes the fun part: the while loop. This loop will run as long as the variable "b" is greater than 0. Inside the loop, we're going to have the turtle move left by the value of "b", then move forward by "b" times 3. Finally, we'll decrease the value of "b" by 1.

As the loop runs, the turtle will create a spiral-like pattern that looks like a virus spreading and infecting the screen. And with the high speed of turtle movement, this effect is amplified and looks dynamic.

As the loop runs, you'll notice the spiral getting smaller and smaller. This is because we're decreasing the value of "b" by 1 each time the loop runs. Finally, when "b" is equal to 0, the loop will stop running, and our virus-like image will be complete!

In conclusion, turtle graphics is a fun and easy way to create cool, dynamic images. This little program can be used as a base to make more complex graphics, Or used to make cool animation with multiple turtle and different shapes. Give it a try and unleash your inner artist!

Rise of the Machines: How AI will Claim its Throne in the Decade to Come

Pandeyashish17 — Wed, 11 Jan 2023 07:56:24 +0000

Brace yourself folks, because the AI takeover is coming, and it's coming fast! That's right, the robots are taking over, and they're not stopping until they dominate this entire decade!

But before you start hoarding canned goods and building a bunker in your backyard, let's take a look at how exactly AI plans to dominate this decade.

First off, we have the robots themselves. They're getting smarter and more advanced every day, and soon they'll be able to do everything we can do and more. They'll be able to fold laundry better than your mom, cook a mean lasagna, and even give you a killer massage after a long day at work.

But that's not all, oh no. AI is also making its way into our cars, making them drive themselves and ensuring that we'll never have to suffer through another carpool karaoke session with the boss again.

AI is also infiltrating our homes, controlling our lights, heating and cooling, and even making sure we never run out of toilet paper again. (Because who wants to make an emergency toilet paper run to the store?)

And let's not forget about the world of entertainment. AI is creating more realistic video game characters, and soon we'll be able to interact with them like they're real people. (Just remember, they're not real people, so don't get too attached to them.)

But the real kicker is AI's impact on the workforce. Soon, AI will be able to do the jobs that humans have been doing for decades(yes developers, I am talking about you), leaving us all to sit at home and play video games all day.

But before you start panicking, remember that AI domination is also a good thing. It will free up our time to do the things we love, and make life in general a whole lot easier. So, sit back, relax, and let the robots do the work. After all, they're the ones taking over the world, not us!

In conclusion, AI will be the ruler of this decade, so we might as well embrace it, and let it make our lives easier and funnier. Who knows, maybe we'll even form a friendship with the robots, and have a robot buddy to play video games with. The future is bright, and it's also robot-ruled.

Say Goodbye to Chrome: Build Your Own Browser with PyQt5 and Python

Pandeyashish17 — Tue, 10 Jan 2023 14:27:54 +0000

Alright folks! Let's build a browser so unique and wild that even Chrome would be envious! We'll be using Python and PyQt5 to build this browser, so make sure you have both installed on your computer. If not, you can use the following command to install them:

pip install pyqt5
pip install PyQtWebEngine

Now that we have the necessary tools, let's get into the code. The full code for this project can be found on this GitHub repository: https://github.com/Pandeyashish17/browser-using-python. Not only the code but also all the button images that we will be using in this project are available there.

We're using PyQt5 to create a QTabWidget and a QMainWindow, which will serve as the foundation for our browser. We're also using PyQtWebEngine to create a QWebEngineView, which will be used to display web pages.

We're creating a bunch of buttons with images like 'back.svg', 'forward.svg', 'reload.svg', 'home.svg', 'add.svg' which are available at the repository mentioned above. These buttons will have different functionality like back, forward, reload and navigate home.

We're also creating a search bar, which uses Google to search for whatever you type in. So, whether you're looking for funny cat videos or researching the latest and greatest Python libraries, our browser's got you covered!

Full Code

import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtWebEngineWidgets import *

class MainWindow(QMainWindow):
    def __init__(self):
        super(MainWindow, self).__init__()

        # create a QTabWidget
        self.tabs = QTabWidget()
        self.setCentralWidget(self.tabs)
        self.showMaximized()

        self.home_url = "https://github.com/Pandeyashish17/browser-using-python"

        # Create a new tab and set it as the current tab
        self.add_new_tab(self.home_url, "Home")

        # create a navigation toolbar
        navbar = QToolBar()
        self.addToolBar(navbar)

        back_btn = QAction(QIcon('back.svg'),'', self)
        back_btn.triggered.connect(self.tabs.currentWidget().back)
        navbar.addAction(back_btn)

        forward_btn = QAction(QIcon('forward.svg'),'', self)
        forward_btn.triggered.connect(self.tabs.currentWidget().forward)
        navbar.addAction(forward_btn)

        reload_btn = QAction(QIcon('reload.svg'),'', self)
        reload_btn.triggered.connect(self.tabs.currentWidget().reload)
        navbar.addAction(reload_btn)

        home_btn = QAction(QIcon('home.svg'),'', self)
        home_btn.triggered.connect(self.navigate_home)
        navbar.addAction(home_btn)

        new_tab_btn = QAction(QIcon('add.svg'),'', self)
        new_tab_btn.triggered.connect(self.add_new_tab)
        navbar.addAction(new_tab_btn)

        # create a search bar
        self.search_bar = QLineEdit()
        self.search_bar.returnPressed.connect(self.search)
        navbar.addWidget(self.search_bar)


    def add_new_tab(self, url=None, title="blank"):
        browser = QWebEngineView()

        # set url if given
        if url:
            browser.setUrl(QUrl(url))

        # create a new tab and set browser as its widget
        tab_index = self.tabs.addTab(browser, title)

        # make the new tab the current tab
        self.tabs.setCurrentIndex(tab_index)

        # update the url bar
        browser.urlChanged.connect(self.update_url)

    def search(self):
        url = self.search_bar.text()
        current_tab = self.tabs.currentWidget()
        current_tab.setUrl(QUrl(f"https://google.com/search?q={url}"))

    def navigate_home(self):
        self.tabs.currentWidget().setUrl(QUrl(self.home_url))

    def update_url(self, q):
        self.search_bar.setText(q.toString())




app = QApplication(sys.argv)
QApplication.setApplicationName('The Silly Surfer ')
window = MainWindow()
app.exec_()

Now, let's run the code and see our wild and unique browser in action! You can easily customize the browser as per your need and create something even more unique and wild.

And there you have it, folks! Your very own, one-of-a-kind browser built with PyQt5 and Python. Now you can surf the web in style, with all the fun buttons and icons to make your browsing experience extra delightful. Happy coding!