Tag: Python

Posted on

Detection of Currency Notes and Medicine Names for the Blind People Project

OBJECTIVE:-

We have seen blind people facing many problems like fake Currency Notes Detection in our society. So, we have come up with some solutions for some problems they face. As they are blind, they are not able to read the medicine’s name and they always depend on another person for help. Some people take advantage of their disability and cheat them by taking extra money or by giving them less money. And by this Currency Notes Detection project, we are making them independent in terms of medical benefits.

METHODOLOGY: –

To overcome the problem of blind people we have come up with an innovative idea, where we are making use of machine learning, image processing, OpenCV, text-to-speech, and OCR technologies. To make their life comfortable.
In this Currency Notes Detection project, we are using a camera for getting the input, where the inputs are pictures of medicine and currency. These images can be manipulated using image processing and OpenCV. Once the processed image is obtained then it is cropped and thresholding is done, In the next stage we will extract the name of the medicine, then we will convert that text into speech using text-to-speech technology.

Similarly, we will also take pictures of currency, and then by using image processing and machine learning we will compare the picture with a predefined database of the currency that we have already prepared. The next process will be to convert the value of currency into text and then the text is converted into speech using text-to-speech technology.

Block Diagram: –

Technology Used:

  • Image Processing: To extract necessary information
  • OpenCV: To threshold image, color shifting, scanning, and cropping, setting grey level, and extract contours
  • Python 3: To set up the environment and interact with devices
  • OCR (Optical Character Recognition)
  • Machine Learning: Handwritten data is trained in a classifier to process manual marks awarded.

Results

The Detection of Currency Notes and Medicine Names for the Blind People Project can help the blind person in the detection of currency notes and medicine names. By this, the blind person would take care of himself without the help of any caretakers. This would make their life easier and simpler. The talk-back feature used would help them to access the application easily without any complications.

  • This project would help blind people to detect the proper currency that they have received or which they need to give without being cheated for receiving the wrong currency or by avoiding giving the wrong currency. This would make them economically stable and strong
  • Not only in currency detection but also this project would help blind people to recognize the name of the tablet and also help them to know how many dosages they need to take as per the name of the tablet.

This Currency Notes Detection project would help blind persons both in an economical way and in the perspective of health. This would make their life easier and make them confident.

Applications

  • Blind persons will be able to recognize the correct currency without getting cheated in any type of money transaction.
  • Blind persons always need not be dependent on others to know which medicines they need to take at a particular time.

Advantages

  • This project will work on mobile phones only no need to buy any extra things.
  • This work is implemented using TalkBack for android and Voiceover for iOS which means blind people can easily access the application.
  • Easy to set up.
  • Open-source tools were used for this project.
  • Accessible to all devices irrespective of the OS.
  • Cheap and cost-efficient.

Disadvantages

  • It is very difficult to determine whether the currency is a fake one when it is an exact copy of the real currency.
  • For the medicine part, the image should be taken from any side where the name of the medicine is written.

Conclusion

This work shows how visually impaired people (blind persons) can protect themselves from getting cheated in terms of money transactions and also how to reduce the dependency on other people to take the right amount of medicine at the right time Whenever the blind person takes the image using his phone camera the image will be compared with the data set which is created.

After comparing the image if it gets the accuracy above the threshold value then it will give the spoken feedback to the person by saying the value of the currency Similarly in the case of medicine detection extract the name of the medicine and gives the spoken feedback as how many times that person needs to take the medicine, thus making this work as one of the assistants for a blind person.

Future Scope

• Include the data set of photos that contain a person’s images it can also be used to detect a person who has a blind person meets.
• It can also be used to track the blind person using GPS

Posted on

Used Car Price Prediction AI / Machine Learning Project using Python

Abstract

Used Car price prediction using AI / Machine Learning techniques has picked researchers’ interest since it takes a significant amount of work and expertise on the part of the field expert. For a dependable and accurate forecast, a large number of unique attributes are analyzed. We employed 6 different machine learning approaches to develop a model for forecasting the price of used automobiles.

Problem statement

With the Coronavirus sway on the lookout, we have seen a lot of changes in the vehicle market. Presently some vehicles are sought after subsequently making them exorbitant and some are not popular and consequently less expensive. With the adjustment of the market due to the Coronavirus 19 effect, people/sellers are facing issues with their past Car Price valuation AI/Machine Learning models. Along these lines, they are searching for new AI models from new information. Here we are building the new car price, valuation model.

The primary point of this Used Car Price Prediction AI / Machine Learning Project is to create a dataset with the help of web scraping and anticipate the cost of a trade-in vehicle given different elements.

The objective of the Project:

1. Data Collection: To scrape the data of at least 5000 used cars from various websites like Olx, cardekho, cars24, auto portal, cartrade, etc.
2. Model Building: To build a supervised machine learning model for forecasting the value of a vehicle based on multiple attributes.

Motivation Behind the Project:

There are a few major worldwide multinational participants in the automobile sector, as well as several merchants. By trade, international companies are mostly manufacturers, although the retail industry includes both new and used automobile dealers. The used automobile market has seen a huge increase in value, resulting in a bigger percentage of the entire market. In India, about 3.4 million automobiles are sold each year on the secondhand car market.

Collecting the data

We have scraped the data for over 5000 cars using Selenium script from 4 different websites from different locations around the country. The websites are as followed:
1. OLX
2. Cars24
3. CarDekho
4. Autoportal

There are 9 columns:

1.’Brand & Model’: It gives us the brand of the car along with its model name and      manufacturing year

2.’Varient’: It gives us a variety of particular car model

3.’Fuel Type’: It gives us the type of fuel used by the car

4.’Driven Kilometers’: It gives us the total distance in km covered by car

5.’Transmission’: It tells us whether the gear transmission is Manual or Automatic

6.’Owner’: It tells us the total number of owners cars had previously

7.’Location’: It gives us the location of the car

8.’Date of Posting Ad’: It tells us when the advertisement for selling that car was posted online

9.’Price (in ₹)’: It gives us the price of the car.

Here ‘Price (in ₹)’ is our target variable.

Reading the dataset

Now we read the dataset into Pandas and since the target column ‘Price’ is of integer data type, we will apply regression algorithms to it.

Data Cleaning

We check for null values and find that there are few in column ‘Variant’ and we will treat them with Mode.
Since all the features are categorical hence we need not check for outliers and skewness.
Exploratory data analysis
Firstly, we will plot the boxplot and distribution plot for the target variable. And find that few outliers need not be treated and the data is tightly distributed with an almost normalized distribution.

Bar graph

Since Brands, Varients, Driven Kilometers & locations have a wide range of values in them, we will not perform bivariate analysis for them as they will not give us any specific details. Now by plotting the graph of Fuel Type, Transmission, and Owner against Price, we conclude that a Car that uses Diesel has automatic Transmission, and Has only 1 owner is more likely to have a high price.

Model building

The models used in training and testing datasets are as followed:

SVR
Linear Regression
SGD Regressor
neighbors Regressor
Decision Tree Regressor
Random Forest Regressor
Only Decision Tree Regressor and Random Forest Regressor are performing well and giving an accuracy of 80.2 % and 87.7%, respectively.

Final model

The accuracy of Model ‘PriceCar’ (Random Forest Regressor) after applying Hyper Tuned Parameters is found to be 87.79% and the score is 0.98 which is quite good.

Conclusion

Here, we can see that all the predicted prices are either equal or nearly equal to the original prices of the car. Hence we conclude that our model ‘price car’ is working very well. And we shall save it for further use.

Limitations of this work and Scope for Future Work

As a part of future work, we aim at the variable choices over the algorithms that were used in the project. We could only explore two algorithms whereas many other algorithms exist and might be more accurate. More specifications will be added to a system or provide more accuracy in terms of price in the system i.e.
1) Horsepower
2) Battery power
3) Suspension
4) Cylinder
5) Torque

As we know technologies are improving day by day and there is also advancement in-car technology, so our next upgrade will include hybrid cars, electric cars, and Driverless cars.

Download Used Car Price Prediction AI / Machine Learning Project using Python. For more details about the project feel free to contact the developer at github

Posted on

Vehicle Registration for College Parking Android App & Web Application Project

Here Students can download the source code of Vehicle Registration for CBIT College Parking Android App & Web Application Python Sqlite Project. Complete Project Report, paper Presentation & output Video guide also available to download.

Problem Statement

The Vehicle Registration for College Parking project will consist of 2 main User Interfaces, the mobile application for students to sign up, log in to the app, add vehicles (up to 2 per person) and apply for a parking sticker, delete vehicles and apply for a new CBIT college parking sticker with fine.

The second User Interface is the admin functionalities which will be in a web application developed with python coding and MySQL database. The admin will be able to log in, receive all the applications for vehicle registration, verify and approve, receive fine payments physically, update payment status in the application and issue parking stickers and dismiss any vehicle registration (in case of misbehavior). It will also consist of a statistics page where registration and payment statistics will be displayed based on the date given.

Vehicle Registration for College Parking Use Case Diagram

Activity Diagram for Mobile App:

Activity Diagram for Web App:

DATABASE

The database for the Vehicle Registration for College Parking project was created in MySQL Workbench. 3 tables have been created.

User table

This table will be holding all the credentials of the users and admins. Every user id will be unique.
This data comes in handy when an admin/user tries to log in, if those credentials are authentic then they will be redirected to the dashboard.

Registration table

Holds the data of all the registered vehicles. Every registration id is unique for easy search. Necessary information about the person and vehicle is stored. Registration status can be dismissed, deleted, approved, or pending. The registration date is stored for statistics.

Payments table

Holds the data about the payments made physically. There are 3 criteria for payments – adding back deleted, dismissing vehicle, and for newsticker. Payment status gets updated to ‘paid’ once done physically. The payment date for statistics.

Implementation

Mobile Application (User)

Welcome page

Web Application Home Page:

Download the complete Vehicle Registration for CBIT College Parking Android App & Web Application Python Project Source Code, Project Report, PPT, and Output Video File.

Posted on

Online Healthcare System Python & SQLite Django Framework Web Application Project

ABOUT THE PROJECT

This Online Healthcare System project is a web application that was developed using Python & SQLite database with Django Framework 2.1.5. This Project provides students/patients quick online access to Health Care Centres and Medical Pharmacy shops. The students can get online prescriptions from various doctors, request an ambulance in emergency times, and get information about the medicines available in the Medical Pharmacy Shop.

PROBLEM IDENTIFIED

  • Need for assistance and monitoring of Healthcare in Hostel life as the number of students in the college area will rapidly increase in coming years so management will become difficult to handle.
  • Making the Healthcare process fully automated and online can increase the efficiency of the Health Centre as well as reduce the need for paperwork

THE SOLUTION

  • Online Healthcare System for College Health Centre connecting Students and Residents with Doctors.
  • Online prescriptions availability information.
  • Notifying users of suggestions from time to time.

Project Features

  • User Profile and Information Website Page
  • Login and Registration Website Page
  • Prescription History And Website Page
  • Health Centre Contact Information
  • Prescription and Doctor Specifications
  • Emergency Website Page
  • (Small Scale Medicine Pharmacy Shop)

The technology :

➢ Django Framework 2.1.5 – Python 3.6.8
➢ SQLite
➢ HTML | CSS | Bootstrap
➢ Javascript

Why healthcare?

● Healthcare cannot be neglected and should be given utmost importance by students.
● This Health Care System Python project might be helpful in case of emergency as well as the daily medical needs of the patient.

System Design Document:

Online Healthcare System Activity Diagram

Online Healthcare System Class Diagram

Online Healthcare System Development View Diagram

Online Healthcare System Physical View Diagram

Online Healthcare System Use Case Diagram

The output Screens:

Here students can easily access the complete Online Healthcare System project code, report & Output Video of the project.

For more information regarding the project development please visit the developer’s Online Healthcare System page on GitHub.

Posted on

College Chat Feature Specification Document Project Idea

This is a Chat Feature Specification Document for a College. Here Students can have a chat with the Teaching & Nonteaching Staff (management staff, admin staff, and accounting staff). Here the main motto is to share the resources like media, files, documents, photos, circulars, notifications, etc inside the college.

System Users​:

  • Students
  • Faculty
  • Admin staff
  • Academic staff
  • Configuration staff

System Developer:

Documentation Engineers, Development Engineers, Test Automation Engineers

Roles of System users:

Feedback, communication, resource sharing, roles, channels

Roles of System Developer:

  • Provide security and privacy
  • Maintenance of front-end and back end
  • System development
  • System maintenance

Concepts Regarding ​CHAT (​Mini Project):

Database (To store details of students both day scholars and hostelers, faculty, admin staff, and academic staff)
DBMS (To define constraints and relationships among the student’s faculty interaction, academic staff, and admin staff)
Android development (to make the CHAT app)
Front-end (Programming languages involving OOPs concepts, and also to develop API through, java and python)
Drivers and software installations for connecting front-end and back-end
Security and encryption algorithms for end-to-end encryption of text messages and to maintain CIA concepts of the application
Testing Algorithms & Issues (To avoid errors and Exceptions)

Ideas on CHAT
​ 
For Students:

​Login: Through the registration number send OTP to the college mail id
​Resource sharing: media, files, documents, photos, circulars, notifications
​contact details: phone number etc.,
​profile photo and details: should be the same as e-cap

For Faculty:

Login: Through the registration number send OTP to the college mail id
Resource sharing: media, files, documents, photos, circulars, notifications
Contact details: phone number etc.,
Profile photo: should be the same as e-cap

For Admin:

Nonteaching faculty (managing staff, admin staff, accounting staff) have access to this Section they have complete access to modify the database and change the components of the System

Posted on

Predictive Analytics for Retail Banking Machine Learning Python Project

Retail banking

Typical mass-market banking is used by local clients of local branches of large commercial banks. The services offered include checking and savings accounts, mortgages, personal loans, debit/credit cards. Attention is paid to the customer.

The main problems in this sector are:

Which product is right to recommend to the customer?
What is the best time to sell a product?
What is the most effective channel to communicate with the customer?

PROBLEM STATEMENT

The data in this regard are related to the direct marketing campaigns of the banking institution. Marketing campaigns are based on phone calls. Often multiple contacts with a customer were required to reach the product (term bank deposit) whether to subscribe (‘yes’) or unsubscribe (‘no’). The goal is to know in advance whether the customer will sign up for a term deposit.

ABOUT THE INFORMATION

This is a classic marketing bank data package uploaded to the UCI machine learning repository. The data set provides you with information about the financial institution’s marketing campaign, which you need to analyze to find ways to look for future strategies to improve the bank’s future marketing campaigns.

These are the columns in the data set:

Age: age of the client (quantitative)
Job: Client’s profession – (categorical) (administrator, worker, entrepreneur, housekeeper, manager, retiree, self-employed, service provider, student, technician, unemployed, unknown)
Marital: Client’s marital status – (categorical) (divorced, married, single, unknown, note: divorced means divorced or widowed)
Education: Client’s level of knowledge – (categorical)
By default: Indicates whether the customer has a debt – (categorical) (no, yes)
Balance: average annual balance, in euros (quantitative).
Housing: Does the client have a home loan? – (categorical) (no, yes)
Loan: Is the client a personal loan? – (categorical) (no, yes)
Contact: Contact type – (categorical) (unknown, mobile, phone)
Date: The date of the last contact with the customer.
Month: Last customer contact month – (categorical) (January-December)

CONCLUSION

In the real world, most classification problems are two-sided. Also, data sets have almost no meaning. In this post, we cover strategies to combat unbalanced data sets with missing values. We will also explore different ways to build packages within the sklearn. Here are some exceptions:

Accuracies compared

  • K-nearest Neighbour: 75.3%
  • Logistic Regression: 80.9%
  • Decision Tree: 78.2%
  • Random Forest Classifier: 78%
  • Support vector Machine: 53%


Sometimes we may be willing to give up some model improvements if this estimate is much more complex than the percentage change in metric improvement.
When building ensemble models, try to use as many different good models as possible to minimize the correlation between basic students. We could improve the model of our concentrated ensemble by adding a dense neural network and other types of basic learners, as well as adding more layers to the concentrated model.
Easy Ensemble generally works better than other re-modeling methods.

Download the complete Predictive Analytics for Retail Banking Machine Learning Python Project Source Code, Report, PPT.

For more details about the project visit this page

 

Posted on

Liver Patient Analysis Machine Learning Project

Project description

In India, delays in diagnosing diseases are a major problem due to a lack of medical professionals. The typical scenario, which is mainly in rural and slightly urban areas:

1. A patient who sees a doctor with certain symptoms.
2. The doctor will perform some tests, such as blood and urine tests, depending on the symptoms.
3. The patient undergoes the above tests in the analytical laboratory.
4. The patient takes the reports back to the hospital, where they are examined and diagnosed.

The goal of this project is to reduce some of the delays caused by unnecessary detours between the hospital and the pathology laboratory. Historically, work has been done to detect the onset of heart disease, such as Parkinson’s, and machine learning algorithms have been developed to predict liver disease in patients based on a variety of characteristics.

Problem statement

The problem report is officially defined as follows:

“Considering the data set containing the various attributes of 584 Indian patients, use the functions in the data set and determine a controlled classification algorithm to determine whether a person is suffering from liver disease. This data set contains 416 liver recordings and 167 non-liver recordings. collected in northeastern Andhra Pradesh. This data set contains records of 441 male patients and 142 female patients. Each patient over the age of 89 is “90” years old.

Strategy

This seems to be a classic example of controlled learning. We are given a fixed number of functions for each data point, and our goal is to teach different controlled learning algorithms based on this data, so that when a new data point appears, our best-performing classifier can be used. information point as a positive or negative example. Detailed information on the number and types of algorithms used for training is contained in the “Algorithms and Techniques” section of the “Analysis” section.

Conclusion

Initially, the data set was studied and prepared for inclusion in the classifiers. This was achieved by removing some rows containing zero values, modifying some columns indicating the skewness, and using appropriate conversion techniques (a hot coding) to make the labels more useful for classification purposes. The performance indicators for which the models will be evaluated have been resolved. The data set was then divided into a reading and testing package.

First, a simple predictive and base model (“Logistic Regression”) was developed in the data set to determine the value of the base accuracy. The biggest challenge in implementing this project was in two areas: defining learning algorithms and selecting the appropriate parameters for precise configuration. Initially, making a decision on 3 or 4 methods out of the many choices available at sklearn was very tedious.

Algorithms and Techniques used to develop this Liver Patient Analysis Machine Learning Project are

1. Random Forest Classifier:
2. Gaussian Naive Bayes Classifier
3. Logistic Regression:

Download the complete Liver Patient Analysis Machine Learning Project Python source code, project report, PPT Presentation.

For more details about the project visit this page

Posted on

Student Grade Analysis & Prediction Machine Learning Project

The main objective of this Python project is to Analysis & Prediction the final grade of Portuguese high school students. This is Machine Learning Project and The algorithms used to implement this project are Linear Regression, ElasticNet Regression, Random Forest, Extra Trees, SVM, Gradient Boosted, Baseline.

Problem statement

The problem statement can be defined as follows: Considering the data set containing the attributes of 396 Portuguese students, the available functions of the data set were used and classification algorithms were defined to determine whether the student performed well in the final qualifying exam.

Description of the data set

These data reflect the performance of secondary school students in two Portuguese schools. Information attributes (student grades, demographic, social, and school-related characteristics) were collected using school reports and questionnaires. There are two sets of indicators for two different subjects: mathematics (math) and Portuguese (por). [Cortez and Silva, 2008], two data sets were modeled under binary / five-level classification and regression tasks. Important Note: The target attribute G3 has a strong correlation with the G2 and G1 attributes.

Methodology

As universities are prestigious universities, it is a matter of great concern that students stay at these universities. It was found that the majority of students dropped out of university in the first year due to a lack of adequate support for undergraduate courses. For this reason, the first year of a bachelor’s degree is called the “make or break” year. Without finding any support for mastering the course and its complexity, you can lower the student’s motivation and cause him to drop out of the course.

There is a great need to develop an appropriate solution to help students stay in higher education. Early grade forecasting is one of the solutions aimed at monitoring the progress of students in the undergraduate courses of the university and leads to the improvement of the learning process of students on the basis of projected grades.

The use of machine learning with the extraction of educational information improves the learning process of students. Various models can be developed to estimate a student’s grades in registered courses, which will provide valuable information to make it easier for students to stay in those courses. This information can be used for the early identification of students at risk, based on which the system can recommend teachers to pay special attention to those students. This information will also help predict the grades of students in different courses to better monitor their performance in a way that will improve student retention in universities.

Using different packages, such as cuffs, seaborn, and matplotlib, to analyze the data set to predict the final price (G3), to display the data graphically or graphically along with various attributes.

Download the Complete Student Grade Analysis & Prediction Machine Learning Python Project Source code, Report.

For more details regarding the project – Click here

Posted on

Nearby Hotels Python Web Application

This is a simple web application that can be used to search hotels. This application will help in searching nearby hotels and also give weather reports of that place such that they can know the weather details priorly to near that hotel in order to travel. A currency converter is included with which everyone can view hotel prices in their desired currency. Additionally, discount coupons are included, which will help user to access the cheapest hotels nearby.

API’s to be used:

Google maps:

The google maps API fetches the data from google e.g. here Maps API is a server that returns information about a place, an establishment, a geographical location, or a prominent point of interest using an HTTP request. Methods are available for place search, details, and autocomplete queries.

The place API returns in JSON format.

Currency converter:

Planning to use online currency converter API web services. This API allows covering the currency to whatever the users needed.

This API returns data in XML format.

Weather API:

This API forecast the weather near the hotels, which uses information from the Rapid API: this API has all the information like temperature, humidity, wind, etc..

This API returns data in JSON format.

Discount coupon:

Planning develops discount coupon API, which gives what best hotels are available nearby with the best discounts possible.

This API returns data in XML format.

Technologies used:

  • JavaScript
  • HTML
  • CSS
  • Nodejs
  • Python
Posted on

Car Parking System Python Project

The python program should make a car park where it’s a 8×9 grid using [square brackets], the parking space should be filled with colours, and letters to signify its availability and which type of car is parked. For example bikes, trucks, cars, sports cars… etc.

Objectives of the Project:

  • Here the car parking needs to be a code which will make a car parking area.
  • There should be red and green light to indicate if it’s vacant or occupied.
  • [square brackets] should be used to show each parking spot
  • Use different letters to show what kind of vehicle is in the spot. For example car, truck, bike, cycle..etc.

Source Code:

import colorama

from termcolor import colored

options_message = """
Choose:
1. To park a vehicle
2. To remove a vehicle from parking
3. Show parking layout
4. Exit
"""


class Vehicle:

    def _init_(self, v_type, v_number):
        self.v_type = v_type
        self.v_number = v_number
        self.vehicle_types = {1: 'c', 2: 'b', 3: 't'}

    def _str_(self):
        return self.vehicle_types[self.v_type]


class Slot:

    def _init_(self):
        self.vehicle = None

    @property
    def is_empty(self):
        return self.vehicle is None


class Parking:

    def _init_(self, rows, columns):
        self.rows = rows
        self.columns = columns
        self.slots = self._get_slots(rows, columns)

    def start(self):
        while True:
            try:
                print(options_message)

                option = input("Enter your choice: ")

                if option == '1':
                    self._park_vehicle()

                if option == '2':
                    self._remove_vehicle()

                if option == '3':
                    self.show_layout()

                if option == '4':
                    break

            except ValueError as e:
                print(colored(f"An error occurred: {e}. Try again.", "red"))

        print(colored("Thanks for using our parking assistance system", "green"))

    def _park_vehicle(self):
        vehicle_type = self._get_safe_int("Available vehicle types: 1. Car\t2. Bike\t3. Truck.\nEnter your choice: ")

        if vehicle_type not in [1, 2, 3]:
            raise ValueError("Invalid vehicle type specified")

        vehicle_number = input("Enter vehicle name plate: ")
        if not vehicle_number:
            raise ValueError("Vehicle name plate cannot be empty.")
        vehicle = Vehicle(vehicle_type, vehicle_number)

        print('\n')
        print(colored(f"Slots available: {self._get_slot_count()}\n", "yellow"))
        self.show_layout()
        print('\n')

        col = self._get_safe_int("Enter the column where you want to park the vehicle: ")
        if col <= 0 or col > self.columns:
            raise ValueError("Invalid row or column number specified")

        row = self._get_safe_int("Enter the row where you want to park the vehicle: ")
        if row <= 0 or row > self.rows:
            raise ValueError("Invalid row number specified")

        slot = self.slots[row-1][col-1]
        if not slot.is_empty:
            raise ValueError("Slot is not empty. Please choose an empty slot.")

        slot.vehicle = vehicle

    def _remove_vehicle(self):
        vehicle_number = input("Enter the vehicle number that needs to be removed from parking slot: ")
        if not vehicle_number:
            raise ValueError("Vehicle number is required.")

        for row in self.slots:
            for slot in row:
                if slot.vehicle and slot.vehicle.v_number.lower() == vehicle_number.lower():
                    vehicle: Vehicle = slot.vehicle
                    slot.vehicle = None
                    print(colored(f"Vehicle with number '{vehicle.v_number}' removed from parking", "green"))
                    return
        else:
            raise ValueError("Vehicle not found.")

    def show_layout(self):
        col_info = [f'<{col}>' for col in range(1, self.columns + 1)]
        print(colored(f"|{''.join(col_info)}|columns", "yellow"))

        self._print_border(text="rows")

        for i, row in enumerate(self.slots, 1):
            string_to_printed = "|"
            for j, col in enumerate(row, 1):
                string_to_printed += colored(f"[{col.vehicle if col.vehicle else ' '}]",
                                             "red" if col.vehicle else "green")
            string_to_printed += colored(f"|<{i}>", "cyan")
            print(string_to_printed)

        self._print_border()

    def _print_border(self, text=""):
        print(colored(f"|{'-' * self.columns * 3}|{colored(text, 'cyan')}", "blue"))

    def _get_slot_count(self):
        count = 0
        for row in self.slots:
            for slot in row:
                if slot.is_empty:
                    count += 1
        return count

    @staticmethod
    def _get_slots(rows, columns):
        slots = []
        for row in range(0, rows):
            col_slot = []
            for col in range(0, columns):
                col_slot.append(Slot())
            slots.append(col_slot)
        return slots

    @staticmethod
    def _get_safe_int(message):
        try:
            val = int(input(message))
            return val
        except ValueError:
            raise ValueError("Value should be an integer only")


def main():
    try:
        print(colored("Welcome to the parking assistance system.", "green"))
        print(colored("First let's setup the parking system", "yellow"))
        rows = int(input("Enter the number of rows: "))
        columns = int(input("Enter the number of columns: "))

        print("Initializing parking")
        parking = Parking(rows, columns)
        parking.start()

    except ValueError:
        print("Rows and columns should be integers only.")

    except Exception as e:
        print(colored(f"An error occurred: {e}", "red"))


if _name_ == '_main_':
    colorama.init()  # To enable color visible in command prompt
    main()