Prerequisites for Java Word Count Application

This word count project requires a solid understanding of Java programming fundamentals, particularly working with Java Swing for GUI development. Knowledge of event handling and text manipulation in Java is essential for implementing the functionality of the Word Count Application.

Project File Structure of Java Word Count Application

The Word Count Application in Java consists of the following:

WordCountApp.java

• The entry point of the application.
• Initialises and displays the WordCountUI.

WordCountUI.java

• Implements the main GUI interface using JFrame, JTextArea, JButton, and various Swing components.
• Allows users to input text, dynamically updates word count on key release events, and provides a button for manual word count updates.
• Utilises WordCounter class to compute word counts.

WordCounter.java

• It contains a static method called countWords that calculates the number of words in a given text string.
• Handles edge cases such as empty input gracefully.

Step-by-Step Implementation of Java Word Count

WordCountUI Class

Components Used:

• JFrame: Main application window.
• JTextArea: Text area for user input.
• JButton: Button to trigger word count updates.
• JScrollPane: Allows scrolling within the text area.

Event Handling:

• KeyListener: Updates word count on text area key release events.
• ActionListener (for JButton): Triggers word count update when the button is clicked.

Layout and Design:

• Utilises BorderLayout and FlowLayout to organise components effectively.
• Customises fonts, colours, and dimensions for aesthetic and functional purposes.

Source Code and Explanation of Java Word Count

WordCountApp.java

1. Package and Class Definition

package com.mycompany.wordcountapp; 
public class WordCountApp {

Explanation:
In this section, the WordCountApp class is defined within the com.mycompany.wordcountapp package. This class serves as the entry point for the Word Count Application.

2. main Method

 public static void main(String[] args) { 
 WordCountUI wordCountUI = new WordCountUI(); 
 wordCountUI.show(); 
 } 
}

Explanation:
The main method is the entry point of the application. It instantiates a WordCountUI object, which initializes the user interface for the word count application (WordCountUI is explained in detail in the next section). It then calls the show() method to display the UI to the user.

WordCountUI.java

1. Class and Fields Declaration

package com.mycompany.wordcountapp; 
import javax.swing.*; 
import java.awt.*; 
import java.awt.event.*; 
public class WordCountUI { 
 private JFrame mainFrame; 
 private JTextArea textArea; 
 private JButton wordCountButton;

Explanation:
This section starts by importing the necessary packages (javax.swing.* and java.awt.*). The WordCountUI class is declared, which is responsible for creating the graphical user interface (GUI) of the Word Count Application. It declares three main fields: mainFrame (the application's main window frame), textArea (for user input of text), and wordCountButton (to trigger the word count action).

2. Constructor (WordCountUI())

 public WordCountUI() { 
 mainFrame = new JFrame("Word Count Application"); 
 mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
 textArea = new JTextArea(15, 40); 
 textArea.setFont(new Font("Arial", Font.PLAIN, 24)); 
 textArea.setLineWrap(true); 
 textArea.setWrapStyleWord(true); 
 textArea.addKeyListener(new KeyAdapter() { 
 @Override 
 public void keyReleased(KeyEvent e) { 
 updateWordCount(); 
 } 
 }); 
 JScrollPane scrollPane = new JScrollPane(textArea); 
 wordCountButton = new JButton("Word Count: 0"); 
 wordCountButton.setFont(new Font("Arial", Font.BOLD, 28));  wordCountButton.setBackground(new Color(100, 180, 255));  wordCountButton.setForeground(Color.WHITE); 
 wordCountButton.setFocusPainted(false); 
 wordCountButton.setPreferredSize(new Dimension(300, 60));  wordCountButton.addActionListener(new ActionListener() {  @Override 
 public void actionPerformed(ActionEvent e) { 
 // Button action listener logic can be added here if required  } 
 });

Explanation:
The constructor initialises the WordCountUI object. It starts by setting up the main frame (mainFrame) with a title and default close operation. Then, it initialises the text area with specific dimensions and formatting (font, line wrap, word wrap). A KeyListener is added to the textArea to listen for key releases, triggering the updateWordCount() method whenever the user types or modifies the text. The textArea is wrapped in a JScrollPane (scrollPane) to enable scrolling if the text overflows. Next, the wordCountButton is initialised with text, font, background, and foreground colour settings. An ActionListener is added to the button to define its behaviour when clicked.

3. UI Layout Setup

 JPanel panel = new JPanel(); 
 panel.setBackground(new Color(240, 240, 240)); 
 panel.setLayout(new BorderLayout()); 
 panel.add(scrollPane, BorderLayout.CENTER);
 JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));  buttonPanel.setBackground(new Color(240, 240, 240));  buttonPanel.setBorder(BorderFactory.createEmptyBorder(10, 0, 20, 0));  buttonPanel.add(wordCountButton); 
 mainFrame.getContentPane().setBackground(new Color(240, 240, 240));  mainFrame.getContentPane().setLayout(new BorderLayout());  mainFrame.getContentPane().add(panel, BorderLayout.CENTER);  mainFrame.getContentPane().add(buttonPanel, BorderLayout.SOUTH);  mainFrame.pack();

Explanation:
This section sets up the layout of the GUI components. It creates two JPanel containers (panel and buttonPanel) to organise the elements within the main frame (mainFrame). The panel is set with a BorderLayout to hold the scrollPane (containing a textArea) at the centre of the frame. The buttonPanel, using FlowLayout, is placed at the bottom (BorderLayout.SOUTH) of the frame and adds the wordCountButton. The main content pane of mainFrame is configured with these panels to arrange the UI components accordingly. Finally, mainFrame.pack() is called to resize the frame based on its contents.

4. updateWordCount() Method

 updateWordCount(); 
 } 
 private void updateWordCount() { 
 String text = textArea.getText(); 
 int wordCount = WordCounter.countWords(text); 
 wordCountButton.setText("Word Count: " + wordCount);  }

Explanation:
The updateWordCount() method updates the word count displayed on the wordCountButton. It retrieves the current text from the text area, calculates the number of words using the WordCounter.countWords() method, and sets the text of wordCountButton to display the updated word count.

5. show() Method

 public void show() { 
 mainFrame.setVisible(true); 
 }

Explanation:
The show() method makes the main frame (mainFrame) visible to the user by setting its visibility to true. This method is called after the UI components are initialised and set up in the constructor.

6. main Method

 public static void main(String[] args) { 
 SwingUtilities.invokeLater(new Runnable() { 
 public void run() { 
 new WordCountUI().show(); 
 } 
 }); 
 } 
}

Explanation:
The main method is the entry point of the application. It ensures that all Swing-related operations are performed on the Event Dispatch Thread (EDT) by invoking SwingUtilities.invokeLater(). Inside the run() method, a new instance of WordCountUI is created and its show() method is called to display the GUI to the user.

WordCounter.java

1. Class Definition and Method

package com.mycompany.wordcountapp; 
public class WordCounter { 
 public static int countWords(String text) { 
 if (text == null || text.isEmpty()) { 
 return 0; 
 } 
 String[] words = text.split("\\s+"); 
 return words.length; 
 } 
}

Explanation:
This section defines the WordCounter class, which provides utility methods for counting words in a text. The countWords(String text) method takes a String parameter text, checks if it is null or empty, and returns zero if true. If the text is not empty, it splits the text into an array of words using whitespace (\\s+) as a delimiter and returns the length of the array, representing the number of words in the text.

Java Word Count Application Output

Conclusion

The Java Swing Word Count Application project demonstrates how Java can be used to create a tool that counts words as you type. It’s designed to be user-friendly and practical, making it a valuable learning experience in Java GUI programming.

Word Count Application using Java was originally published in DataFlair on Medium, where people are continuing the conversation by highlighting and responding to this story.

The following are the applications of the project:

• Allow users to add entries to the database
• Allow users to delete entries in the database
• Allows sorting the entries as well

The user-interface components are:

• An add button which allows users to add entries to the database
• A delete button which deletes the entries from the database.

About the Android Timetable Manager Project

The Timetable Manager is an Android application that helps users efficiently manage their daily tasks and organise their schedules. This application is built with integration to Firebase, which will also provide security for your entries. The rules you publish will also be available to the users only and can be changed at any time.

Prerequisites For the Android Timetable Manager

Before we begin the project, we need to be aware of some prerequisites.

• OOP Concepts(Inheritance, Abstraction, etc..)
• An Android Virtual Device or a USB-connected device for running the application
• Android Studio
• Understanding of JAVA/Kotlin

Android Timetable Manager File Structure:

Let’s check the steps to build a tourist guide application in Android Studio.

• First, we have to add Firebase to the project.
• Go and add the name of your project's package to Firebase.
• Run the signingReport on the Android Studio Terminal and add the SHA-1 fingerprint to Firebase.
• Download the google-services.json and paste it into your app directory in the Project.

Implementation of the Android Timetable Manager

Let’s start the implementation of the project.

Step 1: Setting up the Project

Create a new project in Android Studio:

• Open Android Studio and select “Start a new Android Studio project.”
• Choose “Empty Activity” and set the project name, package name, and save location.
• Configure the project with the desired SDK and language (Java or Kotlin).

Step 2: Designing the UI

activity_main.xml:

Code:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   tools:context=".MainActivity">


   <androidx.recyclerview.widget.RecyclerView
       android:layout_width="match_parent"
       android:layout_height="match_parent"
       android:padding="3dp"
       android:clipToPadding="false"
       android:layout_marginBottom="60dp"
       android:id="@+id/recycler_view"
       tools:listitem="@layout/timetable_item"/>


   <com.google.android.material.floatingactionbutton.FloatingActionButton
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:id="@+id/fab"
       android:src="@drawable/baseline_add_24"
       android:layout_margin="16dp"
       android:contentDescription="add_timetable_entry"
       android:layout_alignParentBottom="true"
       android:layout_alignParentEnd="true"/>


</RelativeLayout>

Explanation:

• We add a RecyclerView and retrieve the data from timetable_item.xml to display in a list manner.
• Add a button to add the entries to the database.

timetable_item.xml:

Code:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:orientation="vertical"
   android:padding="8dp">


   <TextView
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:id="@+id/tv_Subject"
       android:text="Subject"
       android:textSize="18sp"
       android:textStyle="bold"/>


   <TextView
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:id="@+id/tv_Time"
       android:text="Time"
       android:textSize="16sp"
       android:textStyle="bold"/>


   <Button
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="-"
       android:id="@+id/btnDelete"
       android:textStyle="bold"
       android:textSize="16sp"
       android:layout_gravity="end"/>


</LinearLayout>

Explanation:

• We add a TextView for displaying the subject and time through a RecyclerView.
• We add a delete button to delete the entries from the database.

Step 3: Implementing the Functionality

MainActivity.java:

Code:

package com.example.timetablemanager;


import androidx.annotation.NonNull;
import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;


import android.content.DialogInterface;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.Toast;


import com.google.android.material.floatingactionbutton.FloatingActionButton;
import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.ValueEventListener;


import java.util.ArrayList;
import java.util.List;


public class MainActivity extends AppCompatActivity {
   private RecyclerView recyclerView;
   private TimetableAdapter adapter;
   private FloatingActionButton fab;
   private DatabaseReference databaseReference;


   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       recyclerView=findViewById(R.id.recycler_view);
       recyclerView.setLayoutManager(new LinearLayoutManager(this));
       recyclerView.setHasFixedSize(true);
       recyclerView.addItemDecoration(new ItemDecoration(0));


       adapter=new TimetableAdapter();
       recyclerView.setAdapter(adapter);
       databaseReference= FirebaseDatabase.getInstance().getReference("timetable");
       fab=findViewById(R.id.fab);
       fab.setOnClickListener(new View.OnClickListener() {
           @Override
           public void onClick(View v) {
               openAddTimetableEntryDialog();
           }
       });


       loadTimetableEntries();
       adapter.setOnItemClickListener(new TimetableAdapter.OnItemClickListener() {
           @Override
           public void onDeleteClick(TimetableEntry entry) {
               deleteTimetableEntry(entry);
           }
       });
   }


   private void deleteTimetableEntry(TimetableEntry entry) {
       databaseReference.child(entry.getId()).removeValue();
   }


   private void loadTimetableEntries() {
       databaseReference.addValueEventListener(new ValueEventListener() {
           @Override
           public void onDataChange(@NonNull DataSnapshot snapshot) {
               List<TimetableEntry> entries=new ArrayList<>();
               for(DataSnapshot postSnapshot:snapshot.getChildren()){
                   TimetableEntry entry=postSnapshot.getValue(TimetableEntry.class);
                   entries.add(entry);
               }
               adapter.setEntries(entries);
           }


           @Override
           public void onCancelled(@NonNull DatabaseError error) {
               Toast.makeText(MainActivity.this,error.getMessage(), Toast.LENGTH_SHORT).show();
           }
       });
   }


   private void openAddTimetableEntryDialog() {
       AlertDialog.Builder builder=new AlertDialog.Builder(this);
       builder.setTitle("Add Timetable Entry");


       LinearLayout layout=new LinearLayout(this);
       layout.setOrientation(LinearLayout.VERTICAL);


       final EditText subjectInput=new EditText(this);
       subjectInput.setHint("Subject");
       layout.addView(subjectInput);


       final EditText timeInput=new EditText(this);
       timeInput.setHint("Time");
       layout.addView(timeInput);


       builder.setView(layout);


       builder.setPositiveButton("Add", new DialogInterface.OnClickListener() {
           @Override
           public void onClick(DialogInterface dialog, int which) {
               String subject=subjectInput.getText().toString();
               String time=timeInput.getText().toString();
               addTimetableEntry(subject,time);
           }
       });
       builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
           @Override
           public void onClick(DialogInterface dialog, int which) {
               dialog.cancel();
           }
       });
       builder.show();
   }
   private void addTimetableEntry(String subject, String time)
   {
       String id=databaseReference.push().getKey();
       TimetableEntry entry=new TimetableEntry(id,subject,time);
       databaseReference.child(id).setValue(entry);
   }
}

Explanation:

• addTimetableEntry(): Adds entries to the Firebase Realtime Database
• openAddTimetableEntryDialog(): adds the subject and time entries to the database. Also sets various dialogues for positive and negative outcomes.
• deleteTimetableEntry(): Deletes entries in the database.

TimetableEntry.java:

Code:

package com.example.timetablemanager;


public class TimetableEntry {
   private String id;
   private String subject;
   private String time;


   public TimetableEntry(){


   }
   public TimetableEntry(String id, String subject, String time)
   {
       this.id=id;
       this.subject=subject;
       this.time=time;
   }


   public String getSubject() {
       return subject;
   }


   public void setSubject(String subject) {
       this.subject = subject;
   }


   public String getTime() {
       return time;
   }


   public void setTime(String time) {
       this.time = time;
   }


   public String getId() {
       return id;
   }


   public void setId(String id) {
       this.id = id;
   }
}

Explanation:

• Used to add getters and setters for various variables such as id, time and subject.

TimetableAdapter.java

Code:

package com.example.timetablemanager;


import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.TextView;


import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;


import java.util.ArrayList;
import java.util.List;


public class TimetableAdapter extends RecyclerView.Adapter<TimetableAdapter.TimetableHolder> {
   private List<TimetableEntry> entries=new ArrayList<>();
   private OnItemClickListener listener;


   @NonNull
   @Override
   public TimetableHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
       View itemView=LayoutInflater.from(parent.getContext()).inflate(R.layout.timetable_item,parent,false);
       return new TimetableHolder(itemView);
   }


   @Override
   public void onBindViewHolder(@NonNull TimetableHolder holder, int position) {
       TimetableEntry currententry=entries.get(position);
       holder.textViewSubject.setText(currententry.getSubject());
       holder.textViewTime.setText(currententry.getTime());
   }


   @Override
   public int getItemCount() {
       return entries.size();
   }
   public void setEntries(List<TimetableEntry> entries)
   {
       this.entries=entries;
       notifyDataSetChanged();
   }




   class TimetableHolder extends RecyclerView.ViewHolder{
       private TextView textViewSubject;
       private TextView textViewTime;
       private Button deletebutton;


       public TimetableHolder(View itemView){
           super(itemView);
           textViewSubject=itemView.findViewById(R.id.tv_Subject);
           textViewTime=itemView.findViewById(R.id.tv_Time);
           deletebutton=itemView.findViewById(R.id.btnDelete);


           deletebutton.setOnClickListener(new View.OnClickListener() {
               @Override
               public void onClick(View v) {
                   int position=getAdapterPosition();
                   if(listener!=null && position!=RecyclerView.NO_POSITION)
                   {
                       listener.onDeleteClick(entries.get(position));
                   }
               }
           });
       }
   }
   public interface OnItemClickListener{
       void onDeleteClick(TimetableEntry entry);
   }
   public void setOnItemClickListener(OnItemClickListener listener)
   {
       this.listener=listener;
   }
}

Explanation:

• Used to inflate the data items received in the activity_main.xml through RecyclerView
• CustomAdapter for RecyclerView

Android Timetable Manager Output

Conclusion

We have successfully made a Timetable Manager, which serves its purpose of adding tasks and entries and helps to organise them. They can also be deleted from both the app and the Firebase Console.

Manage Your Timetable using Android. was originally published in Wiki Flood on Medium, where people are continuing the conversation by highlighting and responding to this story.

Managing downloaded content is made simple for users by providing them with the option of where to store the photo. This project streamlines the Instagram photo download process by providing a helpful tool for quickly saving favourite material to a user’s PC.

Prerequisites for Python Instagram Photo Downloader Project

To implement this project successfully, you should have:

• Python Programming: A fundamental understanding of Python that covers functions, data structures, grammar, and object-oriented programming.
• Tkinter: knowledge of Tkinter for managing events, handling widgets (buttons, labels, etc.), generating GUI windows, and organising layouts with grid or pack managers.
• Instaloader: Instaloader library for downloading photos from Instagram.
• Both Tkinter and Instaloader libraries should be installed in your Python environment.

Step by Step Python Instagram Photo Downloader Implementation

Import Necessary Libraries and Modules

import tkinter as tk
from tkinter import messagebox
import instaloader
import os

Explanation:

• The tkinter library is imported as tk for ease of use. Tkinter is the standard GUI toolkit for Python.
• The messagebox and filedialog submodules from Tkinter are imported to display messages to the user and to select download directories, respectively.
• instaloader is imported for downloading Instagram photos.

Function to Download Photo

def download_photo():
    link = entry.get()
    if not link:
        messagebox.showerror("Error", "Please enter a valid Instagram post link.")
        return
    
    try:
        # Extracting shortcode from the link
        shortcode = link.split("/")[-2]


        # Creating an instance of Instaloader
        loader = instaloader.Instaloader()
        
        # Getting the current working directory
        download_directory = os.getcwd()
        
        # Downloading the post
        loader.download_post(instaloader.Post.from_shortcode(loader.context, shortcode), target=download_directory)
        
        messagebox.showinfo("Success", f"Photo downloaded successfully to {download_directory}!")
    except Exception as e:
        messagebox.showerror("Error", f"An error occurred: {e}")

Explanation:

• The download_photo function retrieves the link from the entry widget and extracts the shortcode from the link.
• An Instaloader instance is created to download the post.
  The post is downloaded to the current directory, and a success message
• is displayed. If an error occurs, an error message is shown.

Setting Up the GUI

root = tk.Tk()
root.title("Instagram Photo Downloader")
root.geometry("400x200")
root.resizable(False, False)


# Adding a frame for better layout
frame = tk.Frame(root, bg="#f0f0f0")
frame.place(relwidth=1, relheight=1)


# Header label
header_label = tk.Label(frame, text="Instagram Photo Downloader", font=("Helvetica", 16), bg="#f0f0f0")
header_label.pack(pady=20)


# Label for the entry widget
entry_label = tk.Label(frame, text="Enter Instagram Post Link:", font=("Helvetica", 12), bg="#f0f0f0")
entry_label.pack(pady=5)


# Entry widget for the link
entry = tk.Entry(frame, width=50, font=("Helvetica", 12))
entry.pack(pady=5)


# Download button
download_button = tk.Button(frame, text="Download Photo", font=("Helvetica", 12), bg="#4caf50", fg="white", command=download_photo)
download_button.pack(pady=20)


# Run the main loop
root.mainloop()

Explanation:

• The root window is set up with a fixed size and a title.
• A frame is used to manage the layout more effectively and set a background color.
• The header label, entry label, entry widget, and download button are created and styled with consistent fonts and colors.
• The download_button is connected to the download_photo function.

Complete Code

import tkinter as tk
from tkinter import messagebox
import instaloader
import os


# Function to download photo
def download_photo():
    link = entry.get()
    if not link:
        messagebox.showerror("Error", "Please enter a valid Instagram post link.")
        return
    
    try:
        # Extracting shortcode from the link
        shortcode = link.split("/")[-2]


        # Creating an instance of Instaloader
        loader = instaloader.Instaloader()
        
        # Getting the current working directory
        download_directory = os.getcwd()
        
        # Downloading the post
        loader.download_post(instaloader.Post.from_shortcode(loader.context, shortcode), target=download_directory)
        
        messagebox.showinfo("Success", f"Photo downloaded successfully to {download_directory}!")
    except Exception as e:
        messagebox.showerror("Error", f"An error occurred: {e}")


# Setting up the GUI
root = tk.Tk()
root.title("Instagram Photo Downloader")
root.geometry("400x200")
root.resizable(False, False)


# Adding a frame for better layout
frame = tk.Frame(root, bg="#f0f0f0")
frame.place(relwidth=1, relheight=1)


# Header label
header_label = tk.Label(frame, text="Instagram Photo Downloader", font=("Helvetica", 16), bg="#f0f0f0")
header_label.pack(pady=20)


# Label for the entry widget
entry_label = tk.Label(frame, text="Enter Instagram Post Link:", font=("Helvetica", 12), bg="#f0f0f0")
entry_label.pack(pady=5)


# Entry widget for the link
entry = tk.Entry(frame, width=50, font=("Helvetica", 12))
entry.pack(pady=5)


# Download button
download_button = tk.Button(frame, text="Download Photo", font=("Helvetica", 12), bg="#4caf50", fg="white", command=download_photo)
download_button.pack(pady=20)


root.mainloop()

Python Instagram Photo Downloader Output

Conclusion

This project shows how to download Instagram photographs using the Instaloader module and develop a graphical user interface (GUI) using Python’s Tkinter library. The end product is a valuable application called Instagram Photo Downloader. With Tkinter, users can input an Instagram post link in an intuitive UI. The downloading procedure is managed by Instaloader, which makes saving Instagram photographs easier. Users need to input the post link; the application downloads the photo independently.

This is a practical application for anyone who wants to save their favourite Instagram photographs directly to their computer, thanks to its user-friendly layout and effective performance.

Create an Instagram Photo Downloader using Python. was originally published in Data Science Flood on Medium, where people are continuing the conversation by highlighting and responding to this story.

Need for Python Measurement Converter

Measurement converters help bridge the gap between different measurement systems used worldwide. In areas where precision and accuracy are essential, reliable converters prevent errors that could compromise project integrity.

About the Python Measurement Converter

The Python project aims to develop a user-friendly measurement converter tool that can handle a wide range of measurement types. The tool will be designed to support conversions between multiple measurement systems.

Prerequisites for the Python Measurement Converter

To run this Python project, the following prerequisites must be met:

• Python: The user must have Python installed on their system.
• tkinter Library: This library is used to make a Windows GUI.

Step-by-Step Explanation of the Python Measurement Converter Code

1. The first step is to import the necessary libraries, which in this project are “Tkinter.” This library helps create GUIS, and the “ttk” module within Tkinter helps improve widget styling.

import tkinter as tk
from tkinter import ttk

2. The “Measurement_Converter” class inherits from tk.Tk and initialise the main window with a title and a particular geometry.

class Measurement_Converter(tk.Tk):
    def __init__(self):
        super().__init__()
        self.title("Measurement Converter")
        self.geometry("400x300")

3. This dictionary, “conversionFunctions”, helps map measurement types with their corresponding conversion functions.

self.conversionFunctions = {
            'Length' : self.lengthConversion,
            'Time' : self.timeConversion,
            'Area' : self.areaConversion,
            'Mass/Weight' : self.massConversion,
            'Temperature' : self.tempConversion,
            'Plane Angle' : self.angleConversion,
            'Pressure' : self.pressureConversion
        }

4. The mentioned code is used to create the GUI for the Measurement Converter, including the measurement type, input value, input unit, converted unit, and result.

self.type = ttk.Label(self, text="Measurement Type: ")
        self.type.grid(column=0, row=0, padx=10, pady=10)
        self.typesMeasurement = tk.StringVar()
        self.type_drop = ttk.Combobox(self, textvariable=self.typesMeasurement)
        self.type_drop['values'] = list(self.conversionFunctions.keys())
        self.type_drop.grid(column=1, row=0, padx=10, pady=10)
        self.type_drop.bind('<<ComboboxSelected>>', self.update_units)


        self.labelInput1 = ttk.Label(self, text="Input: ")
        self.labelInput1.grid(column=0, row=1, padx=10, pady=10)
        self.labelValueInput = tk.StringVar()
        self.labelEntryInput = ttk.Entry(self, textvariable=self.labelValueInput)
        self.labelEntryInput.grid(column=1, row=1, padx=10, pady=10)


        self.conversionUnitLabel = ttk.Label(self, text="From Unit: ")
        self.conversionUnitLabel.grid(column=0, row=2, padx=10, pady=10)
        self.fromUnit = tk.StringVar()
        self.fromUnit_drop = ttk.Combobox(self, textvariable=self.fromUnit)
        self.fromUnit_drop.grid(column=1, row=2, padx=10, pady=10)


        self.conversionUnitLabel = ttk.Label(self, text="To Unit: ")
        self.conversionUnitLabel.grid(column=0, row=3, padx=10, pady=10)
        self.toUnit = tk.StringVar()
        self.toUnit_drop = ttk.Combobox(self, textvariable=self.toUnit)
        self.toUnit_drop.grid(column=1, row=3, padx=10, pady=10)


        self.buttonConvert = ttk.Button(self, text="Convert", command=self.convert)
        self.buttonConvert.grid(column=0, row=4, padx=10, pady=10)


        self.labelResult = ttk.Label(self, text="Result:")
        self.labelResult.grid(column=0, row=5, padx=10, pady=10)
        self.answerResult = ttk.Label(self, text="")
        self.answerResult.grid(column=1, row=5, padx=10, pady=10)

5. This function updates the available units in the ComboBoxes based on the selected measurement type.

def update_units(self, event):
        typesMeasurement = self.typesMeasurement.get()
        units = []
        if typesMeasurement == 'Length':
            units = ['meters', 'kilometers', 'miles', 'feet', 'inches', 'centimeters']
        elif typesMeasurement == 'Time':
            units = ['sec', 'min', 'hrs', 'days']
        elif typesMeasurement == 'Area':
            units = ['square meters', 'square kilometers', 'hectares', 'acres', 'square miles']
        elif typesMeasurement == 'Mass/Weight':
            units = ['grams', 'kilograms', 'pounds', 'ounces']
        elif typesMeasurement == 'Temperature':
            units = ['C', 'F', 'K']
        elif typesMeasurement == 'Angle':
            units = ['degrees', 'radians']
        elif typesMeasurement == 'Pressure':
            units = ['Pascals', 'atm', 'bar', 'psi']


        self.fromUnit_drop['values'] = units
        self.toUnit_drop['values'] = units

6. This function retrieves the user input, calls the appropriate conversion function, and displays the result.

def convert(self):
        typesMeasurement = self.typesMeasurement.get()
        input_value = float(self.labelValueInput.get())
        first_unit = self.fromUnit.get()
        second_unit = self.toUnit.get()


        if typesMeasurement in self.conversionFunctions:
            result = self.conversionFunctions[typesMeasurement](input_value, first_unit, second_unit)
            self.answerResult.config(text=str(result))

7. Each of the conversion functions performs unit conversions using predefined conversion factors.

def lengthConversion(self, value, first_unit, second_unit):
        convert_measure = {
            'meters': 1,
            'kilometers': 1000,
            'miles': 1609.34,
            'feet': 0.3048,
            'inches': 0.0254,
            'centimeters': 0.01
        }
        return value * convert_measure[first_unit] / convert_measure[second_unit]


    def timeConversion(self, value, first_unit, second_unit):
        convert_measure = {
            'sec': 1,
            'min': 60,
            'hrs': 3600,
            'days': 86400
        }
        return value * convert_measure[first_unit] / convert_measure[second_unit]


    def areaConversion(self, value, first_unit, second_unit):
        convert_measure = {
            'square meters': 1,
            'square kilometers': 1e6,
            'hectares': 1e4,
            'acres': 4046.86,
            'square miles': 2.59e6
        }
        return value * convert_measure[first_unit] / convert_measure[second_unit]


    def massConversion(self, value, first_unit, second_unit):
        convert_measure = {
            'grams': 1,
            'kilograms': 1000,
            'pounds': 453.592,
            'ounces': 28.3495
        }
        return value * convert_measure[first_unit] / convert_measure[second_unit]


    def tempConversion(self, value, first_unit, second_unit):
        if first_unit == 'C':
            if second_unit == 'F':
                return value * 9/5 + 32
            elif second_unit == 'K':
                return value + 273.15
        elif first_unit == 'F':
            if second_unit == 'C':
                return (value - 32) * 5/9
            elif second_unit == 'K':
                return (value - 32) * 5/9 + 273.15
        elif first_unit == 'K':
            if second_unit == 'C':
                return value - 273.15
            elif second_unit == 'F':
                return (value - 273.15) * 9/5 + 32


    def angleConversion(self, value, first_unit, second_unit):
        convert_measure = {
            'degrees': 1,
            'radians': 57.2958
        }
        return value * convert_measure[first_unit] / convert_measure[second_unit]


    def pressureConversion(self, value, first_unit, second_unit):
        convert_measure = {
            'Pascals': 1,
            'atm': 101325,
            'bar': 100000,
            'psi': 6894.76
        }
        return value * convert_measure[first_unit] / convert_measure[second_unit] 

8. This code creates an instance of the “Measurement Converter” class and runs the application.

if __name__ == "__main__":
    app = Measurement_Converter()
    app.mainloop()

Python Measurement Converter Output

1. This is the launch page for the activity, which displays four entries: measurement type, input, and the units from and to, along with a single “convert” button and a result section.

2. The user has entered all the entries and pressed the convert button to produce the result.

3. This is the final stage of the application, which provides the output of the input entries and enables the user to utilise this result as needed.

Conclusion

This project resulted in the creation of a graphical user interface application using Python’s “tkinter” library to convert various measurements. Measurement Converter allows users to convert values between units, including length, time, area, mass/weight, temperature, plane angle, and pressure.

Create a Measurement Converter using Python. was originally published in ProjectsFlood on Medium, where people are continuing the conversation by highlighting and responding to this story.

About Java Color Picker Application

The Color Picker is a simple graphical user interface (GUI) Java application that allows users to choose a color and change the color of the text. It provides an interactive way to select colors using Java’s built-in JColorChooser dialogue, demonstrating the use of Swing components and event handling.

Color Picker App Functionalities

• Text Display: The application shows a label with customizable text.
• Color Selection: Users can click a button to open a color chooser dialog.
• Real-time Update: The text color changes immediately upon color selection.
• Responsive Layout: The app utilises FlowLayout for a simple and responsive design.

Prerequisites for Color Picker App

• IDE Used: IntelliJ IDEA Community Edition 2024.1
• Java should be installed on the machine.
• Basic knowledge of Java and Swing.

Steps to Create a Color Picker App

Import necessary packages

• We import Java Swing and AWT packages to create GUI components and handle events.

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

Create a custom JFrame class

• We extend JFrame and implement ActionListener to create the main application window and handle button clicks.
• Then, we define a JLabel for text display and a JButton to open the color chooser. When the user clicks on the button, the JColorChooser dialog is activated, which opens a new window with the title ”Choose color” and a default color selected as black.
• We then set up the frame with a title, layout, close operation, and size and added the components.

public class MyFrame extends JFrame implements ActionListener {
   JLabel label;
   JButton button;
   MyFrame(){
       label = new JLabel();
       label.setText("Change Color of this text :)");
       label.setBackground(Color.WHITE);
       label.setFont(new Font("Times New Roman", Font. PLAIN,50));
       label.setOpaque(true);


       button = new JButton("Choose Color");
       button.addActionListener(this);


       this.setTitle("Color Picker");
       this.setLayout(new FlowLayout());
       this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       this.setSize(500,500);
       this.add(button);
       this.add(label);
       this.pack();
       this.setVisible(true);
   }

Implement the action listener for color selection

• In the actionPerformed method, we use “If Else” to check if the button was clicked.
• If the button is clicked, we show the JColorChooser dialog.
• After the user chooses a colour, it is loaded in color “c,” using which the color of the Foreground, that is, the text color, is set the same as the user selected.

 @Override
   public void actionPerformed(ActionEvent e) {
       if(e.getSource()==button){
           JColorChooser cc = new JColorChooser();
           Color c = JColorChooser.showDialog(null,"Choose color",Color.BLACK);
           label.setForeground(c);
       }
   }
}

Main method in a separate class:

• An instance of MyFrame is created to run the application.

public class Main{
   public static void main(String[] args) {
       new MyFrame();
   }
}

Complete Code

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;


public class MyFrame extends JFrame implements ActionListener {
   JLabel label;
   JButton button;
   MyFrame(){
       label = new JLabel();
       label.setText("Change Color of this text :)");
       label.setBackground(Color.WHITE);
       label.setFont(new Font("Times New Roman", Font. PLAIN,50));
       label.setOpaque(true);


       button = new JButton("Choose Color");
       button.addActionListener(this);


       this.setTitle("Color Picker");
       this.setLayout(new FlowLayout());
       this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
       this.setSize(500,500);
       this.add(button);
       this.add(label);
       this.pack();
       this.setVisible(true);
   }
   @Override
   public void actionPerformed(ActionEvent e) {
       if(e.getSource()==button){
           JColorChooser cc = new JColorChooser();
           Color c = JColorChooser.showDialog(null,"Choose color",Color.BLACK);
           label.setForeground(c);
       }
   }
}

Java Color Picker App Output

• When the main class is ruined, a window with the title “Color Picker” pops up, with a button that changes the color of the text.

• After pressing the button, the following dialog of JColorChooser pops up.

• Users can choose any color.

• After pressing ok, the color chosen is applied to the text.

Conclusion

This project demonstrates the creation of a user-friendly Color Picker application using Java Swing. It showcases the use of JFrame, JLabel, JButton, and JColorChooser components. The application allows users to interactively change the color of displayed text, providing a practical example of event handling and GUI updates in Java Swing. This project is an excellent starting point for learning about Java GUI development. It can be extended with additional features like saving color choices or applying colors to different UI elements.

Java Color Picker Project was originally published in Tutorials Flood on Medium, where people are continuing the conversation by highlighting and responding to this story.

A regex query tool is a software utility designed to help create, test and execute regular expressions. Regular Expressions are sequences of characters that form search patterns and are primarily used for string matching and manipulation.

Need for a Python Regex Query Tool

There is a need to develop a regex query tool because working with regular expressions entails intricate work that demands precision. Regex patterns are expressed in a cryptic, specialised format that is difficult to correct for more complex cases. Mistakes in the use of regular expressions (regex) are likely to result in incorrect results when analysing data, and it may require a significant amount of resources to identify the problem. Hence, a regular expression (regex) query tool is needed.

About Python Regex Query Tool

This Python project aims to develop a user-friendly regular expression (regex) query tool. The tool will allow users to input and test regular expressions against various sample texts.

Prerequisites for Python Regex Query Tool

To run this project, the following prerequisites must be met:

• Python: The user must have Python installed on their system.
• Understanding of Regex: A solid grasp of regex syntax and operations.
• tkinter Library: This library is used to make a Windows GUI.

Step by Step Explanation of the Code

The following set of Python code assists in developing a basic GUI application in the Python language using the Tkinter toolkit for a regular expression (regex) query tool.

Here is a detailed explanation of the code:

Importing Necessary Libraries

import tkinter as tkin
from tkinter import ttk
from tkinter import scrolledtext
import re

• tkinter: It is used to create the application window
• ttk: It provides access to the Tk themed widget set.
• scrolledtext: It creates scrollable text areas for entering the text to search.
• re: It is used to compile and search for patterns within text.

Class Definition and Initialisation

class RegexQueryTool:
    def __init__(self, root):
        self.root = root
        self.root.title("Regex-Query-Tool")
        self.create_widgets()

The ‘RegexQueryTool’ class contains all the functionality of the regex query tool. The constructor initialises the main window and sets its title. It is also called the ‘create_widgets’ method, which sets up the user interface.

Creating Widgets

 def create_widgets(self):
        self.regex_label = ttk.Label(self.root, text="Enter Regex Pattern:")
        self.regex_label.grid(column=0, row=0, padx=10, pady=5, sticky=tkin.W)
        self.regex_entry = ttk.Entry(self.root, width=50)
        self.regex_entry.grid(column=1, row=0, padx=10, pady=5)
        self.text_label = ttk.Label(self.root, text="Enter Text to Search:")
        self.text_label.grid(column=0, row=1, padx=10, pady=5, sticky=tkin.W)
        self.text_area = scrolledtext.ScrolledText(self.root, width=50, height=10, wrap=tkin.WORD)
        self.text_area.grid(column=1, row=1, padx=10, pady=5)
        self.search_button = ttk.Button(self.root, text="Search", command=self.search_regex)
        self.search_button.grid(column=1, row=2, padx=10, pady=10, sticky=tkin.E)
        self.result_label = ttk.Label(self.root, text="Results:")
        self.result_label.grid(column=0, row=3, padx=10, pady=5, sticky=tkin.W)
        self.result_area = scrolledtext.ScrolledText(self.root, width=50, height=10, wrap=tkin.WORD)
        self.result_area.grid(column=1, row=3, padx=10, pady=5)

The ‘create_widgets’ function helps create the labels and input boxes for Regex Pattern input, Text to Search Input, Search Button, and Results Display.

Search Function

def search_regex(self):
        pattern = self.regex_entry.get()
        text = self.text_area.get("1.0", tkin.END)
        self.result_area.delete("1.0", tkin.END)
        try:
            match_phrase = re.findall(pattern, text)
            if match_phrase:
                for match in match_phrase:
                    self.result_area.insert(tkin.END, match + "\n")
            else:
                self.result_area.insert(tkin.END, "No match_phrase found.")
        except re.error as e:
            self.result_area.insert(tkin.END, f"Regex error: {e}")

This method helps search for words or phrases in the input text according to the provided regular expression and displays the results in the output section.

Starting the Main Event Loop

if __name__ == "__main__":
    root = tkin.Tk()
    app = RegexQueryTool(root)
    root.mainloop()

It helps create the main window and starts the Tkinter event loop, which waits for user interaction.

Python Regex Query Tool Output

1. This is the initial state of the Regex Query Tool application upon launch. The window contains three labeled entry fields: one for the regex pattern, one for the text to search and one for the results. The “Search” button is displayed below the entry fields, ready for the user to input the text.

2. The user has entered a regex pattern sentence into the first entry field. The entry field labeled “Enter Text to search” is filled with the user’s input, and the “Search” button is now ready to be clicked to process this text.

3. In this step, the user has clicked the “Search” button after entering the text. The application is processing the request. The entry fields remain visible, but the output text field remains empty while the request is processed.

4. After processing the text, the application displays the output text in the second field, labelled “Results”. The user can now use this text as needed.

Summary

The regex query tool is essential for anyone working with regular expressions. In this project, we are developing a tool using Python and Tkinter that helps users understand regular expressions. The above code yields an accessible and user-friendly regex query tool.

Python Project — Regex Query Tool was originally published in PythonFlood on Medium, where people are continuing the conversation by highlighting and responding to this story.

ClickOmania, also known as SameGame, is a popular tile-matching puzzle game that originated in the 1980s. In the traditional version: The game board is filled with tiles of different colors.

Players click on groups of two or more adjacent tiles of the same color. When clicked, these tiles disappear, and the tiles above fall to fill the gaps. In most cases, the objective is to remove a majority of the tiles if not all, which makes a player the winner.

This is achieved by accumulating points depending on the number of tiles cleared with every move — more tiles cleared mean more points scored. The difficulty level increases significantly as the number of remaining matching groups decreases.

Over time, ClickOmania has had many versions that differ in board size; some have unique special tile effects, while others have different scoring systems.

Need for Python ClickOmania Game

ClickOmania-style games serve several purposes:

• Entertainment: They provide a fun, engaging puzzle experience.
• Cognitive exercise: These games can help improve pattern recognition and strategic thinking.
• Stress relief: The simple mechanics and satisfying tile-clearing can be relaxing.
• Time management: They’re excellent for short gaming sessions or passing time.

About Python ClickOmania Game

Vampire Frenzy takes the concept of ClickOmania and adds a vampire twist.

But it goes beyond just changing the visuals:

• Instead of clearing groups of same-coloured tiles, players match pairs of vampire-related items like fangs or chalices, creating a focus on memory-matching over group-clearing gameplay, similar to Concentration.
• The vampire theme isn’t just for show; it’s integrated into gameplay mechanics. Your life meter is represented by a count of “Souls.” Successful matches boost the Soul count and reduce the number of “prey,” while mismatches lower the Soul count, adding risk to every move.
• The main objective is to match all pairs before running out of Souls, creating a more narrative-driven environment than typical ClickOmania games.
• The game uses a darker color scheme, vampire-related item names, and features like high score tracking to add replay value and competition.

By combining Python ClickOmania, memory games, and vampire lore elements, Vampire Frenzy offers a unique puzzle experience beyond simple tile-matching, providing players a themed and strategic gameplay challenge.

Prerequisites for Python ClickOmania Game

To run the project, you need the following:

• Python installed on your system.
• The tkinter library (usually comes with Python).

Step by Step Implementation of Python ClickOmania Game

This Python code uses the Tkinter library to create a GUI application for the Vampire Frenzy game. Here’s a detailed breakdown of the code:

Import necessary libraries

import tkinter as tk
import random

• `tkinter as tk`: The code imports the Tkinter library, Python’s standard GUI toolkit, to create visual elements like windows, buttons, and labels using the abbreviation `tk`.
• `random`: This imports Python’s built-in random module. In this game, it is used to shuffle items, ensuring that each game has a different arrangement of items on the grid.

Vampirefrenzy Class Definition

class Vampirefrenzy:
    def __init__(self, window):
        self.window = window
        self.window.title("Vampire Frenzy")
        self.window.geometry("800x750")
        self.window.config(bg="#282A36")


        self.items = {
            "Fang": "#FF79C6", "Mirror": "#8BE9FD", "Chalice": "#FFD700",
            "Wing": "#BD93F9", "Flower": "#50FA7B", "Blood": "#880808",
            "Feather": "#F1FA8C", "Nail": "#6272A4"
        }  
        self.blood = 100
        self.prey = 8
        self.first_pick = None
        self.moves = 0


        self.setup_ui()
        self.create_grid()

• class VampireFrenzy: Defines the game’s main class. All game logic and UI elements are encapsulated within this class.
• def __init__(self, window):
• Constructor method for the class. It is called when a new instance of the class is created.
• self.window = window Stores the main Tkinter window of the passed class.
• self.window.title(“Vampire Frenzy”) Sets the window title.
• self.window.geometry(“800x750”) Sets the initial window size to 800x750 pixels.
• self.window.config(bg=”#282A36") Sets the background color of the window using the hexadecimal color code.
• self.items = {} This dictionary stores game items (keys) and their assigned colors (values).
• self.blood = 100 Initializes the player’s blood (or souls) count.
• self.prey = 8 Sets the initial number of prey (pairs to match).
• self.first_pick = None Saves the first item picked in a turn.
• self.moves = 0 Initializes the move counter.
• self.setup_ui() Calls methods to set up the UI.
• self.create_grid() Calls a method to create the game grid.

User interface settings

    def setup_ui(self):
        self.font = ("Arial", 14, "bold")
       
        tk.Label(self.window, text="Vampire frenzy", font=("Arial", 28, "bold"),
                 bg="#282A36", fg="#780606").pack(pady=10)


        self.info_frame = tk.Frame(self.window, bg="#282A36")
        self.info_frame.pack(fill=tk.X, padx=20, pady=10)


        self.blood_label = tk.Label(self.info_frame, text=f"Souls: {self.blood}",
                                     font=self.font, bg="#282A36", fg="#780606")
        self.blood_label.pack(side=tk.LEFT)


        self.prey_label = tk.Label(self.info_frame, text=f"Prey: {self.prey}",
                                      font=self.font, bg="#282A36", fg="#BD93F9")
        self.prey_label.pack(side=tk.RIGHT)


        self.grid_frame = tk.Frame(self.window, bg="#44475A", padx=15, pady=15)
        self.grid_frame.pack(pady=10)


        self.result_label = tk.Label(self.window, text="", font=self.font,
                                      bg="#282A36", fg="#F8F8F2", wraplength=600)
        self.result_label.pack(pady=10)


        self.reset_button = tk.Button(self.window, text="New Game", command=self.new_game,
                  font=self.font, bg="#6272A4", fg="#F8F8F2", activebackground="#44475A")
        self.reset_button.pack(pady=10)

• `self.font = (“Arial”, 14, “bold”)`: Defines the default font for UI elements.
• `tk.Label(self.window, )`: Creates a label for the main game title.
• `self.info_frame = tk.Frame()`: Creates a frame to store game information.
• `self.blood_label` and `self.prey_label`: Create labels to display the current soul count and remaining loot.
• `self.grid_frame = tk.Frame()`: Creates a frame for the game grid.
• `self.result_label`: Creates a label to display game results or messages.
• `self.reset_button`: Creates a button to start a new game.
• The `pack()` method arranges these elements in the window.

Creating a game grid

    def create_grid(self):
        item_list = list(self.items.items()) * 2
        random.shuffle(item_list)


        for row in range(4):
            for col in range(4):
                item, color = item_list.pop()
                btn = tk.Button(self.grid_frame, text="|+|", width=10, height=3,
                                font=self.font, bg="#44475A", fg="#F8F8F2",
                                command=lambda r=row, c=col: self.reveal(r, c))
                btn.grid(row=row, column=col, padx=5, pady=5)
                btn.item = item
                btn.color = color

item_list = list(self.items.items()) * 2: Creates a list of item-color pairs, doubled to create matching pairs.

random.shuffle(item_list): Randomly shuffles the list of items.

Nested loops create a 4x4 grid of buttons:

• Each button starts with the text “|+|” to hide its item.
• command=lambda r=row, c=col: self.reveal(r, c): Sets up a function to call self.reveal when the button is clicked.
• btn.item and btn.color: Store the item and color as attributes of the button for later use

Item Reveal

 def reveal(self, row, col):
        button = self.grid_frame.grid_slaves(row=row, column=col)[0]
       
        if button['text'] != "|+|":
            return


        button.config(text=button.item, bg=button.color)
       
        if not self.first_pick:
            self.first_pick = button
        else:
            self.moves += 1
            self.window.after(666, lambda: self.check_match(button))

• In the code, when we use `button = self.grid_frame.grid_slaves(row=row, column=column)[0]` loads a button at the specified grid position.
• To check if the button has already been exposed, we can use the condition `if button[‘text’] != “|+|”`.
• To reveal an item by changing the text and background color of the button, we can use the code: `button.config(text=button.item, bg=button.color)`.
• When it’s the first pick in the turn, it’s stored in `self.first_pick`. If it’s the second pick, the move counter is incremented and we schedule `check_match()` to run after a short delay.

Compliance check

    def check_match(self, second_pick):
        if self.first_pick.item == second_pick.item:
            self.result_label.config(text=f"Match found! You caught {self.first_pick.item}!")
            self.blood += 13
            self.prey -= 1
        else:
            self.result_label.config(text="No match. Try again.")
            self.blood -= 7
            self.first_pick.config(text="|+|", bg="#44475A")
            second_pick.config(text="|+|", bg="#44475A")


        self.first_pick = None
        self.update_info()
        self.check_game_over()

When comparing the items of the two selected buttons:

• If they match, update the result label with a success message, increase the blood (souls) count by 13, and decrease the prey count by 1.
• If they don’t match, update the result label with a failure message, decrease the blood count by 7, hide the items again by resetting the button text and color, reset self.first_pick for the next turn, and call update_info() to refresh the display and check_game_over() to see if the game has ended.

Game State Management

Game state management is crucial for maintaining the game's current status, updating the user interface, and determining when the game ends. In the Vampiric match, this is handled by several methods:

1. update_info Method:

    def update_info(self):
        self.blood_label.config(text=f"Souls: {self.blood}")
        self.prey_label.config(text=f"Prey: {self.prey}")

• It updates the blood_label to show the player's number of souls (blood).
• It updates the prey_label to show the remaining prey (pairs to match).
• This method is called after each move to ensure the display always reflects the current game state.

2. check_game_over Method:

   def check_game_over(self):
        if self.prey == 0:
            self.show_message("You Win!", f"All prey caught in {self.moves} moves! \n You are now Count Dracula!")
            self.end_game()
        elif self.blood <= 0:
            self.show_message("Game Over", "You ran out of Souls!")
            self.end_game()

• If self.prey is 0, all pairs have been matched, and the player wins.
• It displays a win message showing the number of moves taken.
• If self.blood is 0 or less, the player has run out of souls and loses.
• It displays a game-over message.
• In both cases, the end_game method finalises the game state.
• This method ensures the game ends appropriately when winning or losing conditions are met.

3. end_game Method:

    def end_game(self):
        for button in self.grid_frame.winfo_children():
            if isinstance(button, tk.Button):
                button.config(state=tk.DISABLED)

• It iterates through all widgets in the grid_frame.
• For each button, it sets its state to DISABLED.
• This prevents further interaction with the game grid after the game has ended.
• It “freezes” the game state effectively, allowing the player to see the final board configuration.

4. new_game Method:

 def new_game(self):
        self.blood = 100
        self.prey = 8
        self.first_pick = None
        self.moves = 0
        self.result_label.config(text="")
        self.update_info()
        for widget in self.grid_frame.winfo_children():
            widget.destroy()
        self.create_grid()

• Resets blood (souls) to the starting value of 100.
• Resets prey to 8 (indicating 8 pairs to match).
• Clears first_pick and resets the moves counter.
• Clears any text in the result_label.
• Calls update_info() to refresh the displayed game information.
• Destroys all existing widgets in the grid_frame.
• Calls create_grid() to set up a new game board.

Displaying Messages

 def show_message(self, title, message):
        popup = tk.Toplevel(self.window)
        popup.title(title)
        popup.geometry("400x200")
        popup.config(bg="#282A36")


        tk.Label(popup, text=message, font=self.font, bg="#282A36", fg="#F8F8F2", wraplength=350).pack(pady=20)
        tk.Button(popup, text="Close", command=popup.destroy,
                  font=self.font, bg="#6272A4", fg="#F8F8F2").pack()

• Creates a new top-level window for displaying messages.
• Sets up the window with a title, size, and background color.
• Adds a label to display the message and a button to close the popup.

Main Execution

if __name__ == "__main__":
    root = tk.Tk()
    game = Vampirefrenzy(root)
    root.mainloop()

• Check if the script is being run directly (not imported).
• Creates the main Tkinter window (root).
• Instantiates the Vampirefrenzy class with this window.
• Starts the Tkinter event loop with mainloop(), which keeps the window open and responsive to user interactions.

Python ClickOmania Game Output

This image displays the initial state of the Vampire Frenzy game upon launch. It showcases the results of the setup_ui() and create_grid() methods. The game title “Vampire Frenzy” is shown at the top as a tk.Label. The initial values of 100 Souls and 8 Prey are displayed in the self.blood_label and self.prey_label. The 4x4 grid of buttons created in the create_grid() method is visible, each marked with “|+|”. The self.result_label is empty, and the self.reset_button labeled “New Game” is also visible.

This picture shows the game in progress. It demonstrates how the reveal() and check_match() methods work. Some buttons on the grid have been revealed, displaying their item and color as set in the create_grid() method. The self.blood_label and self.prey_label have been updated to reflect the game progress. The self.result_label shows a message from a recent move to provide feedback from the check_match() method.

This image illustrates the winning state of the game, highlighting the check_game_over() and show_message() methods. All grid buttons are revealed, indicating all matches have been found. The self.prey_label shows a count of 0, triggering the win condition in check_game_over(). A popup window created by show_message() displays the win message, including the number of moves taken.

This image illustrates the game-over state, highlighting the check_game_over(), show_message(), and end_game() methods. Several grid buttons are still concealed. The self.blood_label indicates a value of 0 or lower, triggering the loss condition in the check_game_over() method. A pop-up window generated by show_message() presents the game-over message. The grid buttons are deactivated as part of implementing the end_game() method.

Conclusion

The Vampire Frenzy project is a unique twist on the ClickOmania game concept, integrating vampire themes and memory game elements. It offers an engaging gameplay experience with blood and prey mechanics, adding strategy to the traditional tile-matching puzzle. The game’s GUI is designed with a dark, vampire-inspired color scheme, enhancing the thematic experience. This project showcases the practical application of GUI programming, game logic implementation, and basic file I/O for high score tracking.

ClickOmania Game in Python —  Design, Code, and Play was originally published in PythonFlood on Medium, where people are continuing the conversation by highlighting and responding to this story.

Following are the applications of E Vaccination application:

• Allow users to register using their credentials
• Allow users to log in to the app through valid and authenticated credentials.
• Allow users to schedule an appointment on the selected date.
• Users can view their appointments as well.

The user-interface components are as follows:

• A Login and Register activity so that users can sign up for the application
• An appointment scheduling activity where users can input the date and click the button to schedule an appointment.
• Users can also view their appointment details.

About Android E-Vaccination System

This Android project aims to allow users to register and log in to the app and then they can input the date on the given field, and then they can make an appointment; the app also allows users to view the appointments they have made. Using the FireBase Database, the user’s appointment will be stored, and they can view it either on the app or the Firebase console.

Prerequisites For Android e-Vaccination System

Before beginning this Android project, we must know some prerequisites.

• OOP Concepts(Inheritance, Abstraction, etc..)
• An Android Virtual Device or a USB-connected device for running the application
• Android Studio
• Understanding of JAVA/Kotlin

Android e-Vaccination System Project File Structure

Let’s check the steps to build a tourist guide application in Android Studio.

• Go to the Firebase website and add your project on Firebase.
• Run the following command on the terminal: gradle signingReport, and press Ctrl+Enter. You will get a field named SHA-1 fingerprint. Add this to your project on Firebase.
• Paste the google-services.json file in the Project→YourAppName→app.
• Now add the authentication, database and Firebase storage SDK’s in the gradle files.
• Now import the files required for the project, such as HashMap, String, Recycler View and the other Firebase Libraries required, such as FirebaseAuth and FirebaseDatabase.

Step-by-Step Implementation of Android e-Vaccination System

Let’s start the implementation of the project.

Step 1: Setting up the Project.

Create a new project in Android Studio

• Open Android Studio and select “Start a new Android Studio project.”
• Choose “Empty Activity” and set the project name, package name, and save location.
• Configure the project with the desired SDK and language (Java/Kotlin).

Step 2: Designing the UI

activity_main.xml

Code:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   android:background="@color/black"
   tools:context=".MainActivity">


   <TextView
       android:id="@+id/textView"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="E Vaccination System"
       android:textColor="@color/white"
       android:textSize="20sp"
       android:textStyle="bold"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent" />


   <ProgressBar
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       android:outlineAmbientShadowColor="#D80B0B"
       android:outlineSpotShadowColor="#6C0909"
       app:layout_constraintHorizontal_bias="0.498"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.617" />


</androidx.constraintlayout.widget.ConstraintLayout>

Explanation:

• Its a basic splash screen which is to show the during the launch of the app.
• We have a Textview to display the title of the app and a progress bar.

activity_register.xml

Code:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   android:background="@color/black"
   tools:context=".RegisterActivity">


   <TextView
       android:id="@+id/textView2"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Registration Screen"
       android:textColor="@color/white"
       android:textSize="20sp"
       android:textStyle="italic"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintHorizontal_bias="0.443"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.055" />


   <EditText
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:hint="Email"
       android:id="@+id/email"
       android:padding="20dp"
       android:textColor="@color/white"
       android:textColorHint="@color/white"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.212"
       tools:layout_editor_absoluteX="0dp" />


   <EditText
       android:id="@+id/password"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:hint="Password"
       android:padding="20dp"
       android:textColor="@color/white"
       android:textColorHint="@color/white"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.358"
       tools:layout_editor_absoluteX="0dp" />


   <Button
       android:id="@+id/register"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Register"
       android:textSize="20sp"
       android:textStyle="bold"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent" />




</androidx.constraintlayout.widget.ConstraintLayout>`

Explanation:

• Two EditText fields are provided for users to input their email and password.
• A Button is provided which, when clicked upon, registers the user into the database.

activity_login.xml

Code:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   android:background="@color/black"
   tools:context=".LoginActivity">


   <TextView
       android:id="@+id/textView3"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:gravity="center"
       android:text="Login Screen"
       android:textColor="@color/white"
       android:textSize="20sp"
       android:textStyle="italic"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.072"
       tools:layout_editor_absoluteX="0dp" />


   <EditText
       android:id="@+id/email"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:hint="Email"
       android:padding="20dp"
       android:textColor="@color/white"
       android:textColorHint="@color/white"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.229"
       tools:layout_editor_absoluteX="16dp" />


   <EditText
       android:id="@+id/password"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:hint="Password"
       android:padding="20dp"
       android:textColor="@color/white"
       android:textColorHint="@color/white"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.373"
       tools:layout_editor_absoluteX="0dp" />


   <Button
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Log In"
       android:textSize="20sp"
       android:textStyle="bold"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintHorizontal_bias="0.498"
       app:layout_constraintStart_toStartOf="parent"
       android:id="@+id/login"
       app:layout_constraintTop_toTopOf="parent" />


   <TextView
       android:id="@+id/registertext"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Create account? Click Here"
       android:textColor="#EA1414"
       android:textStyle="italic"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.568"
       android:clickable="true"/>




</androidx.constraintlayout.widget.ConstraintLayout>

Explanation:

• Two EditText fields allow users to enter their email and password.
• A Button is provided, which, when clicked upon, checks whether the user is registered or not and does the action.
• A TextView is provided, redirecting the user to Register Activity when clicked upon.

activity_schedule.xml

Code:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   android:background="@color/black"
   tools:context=".ScheduleActivity">


   <TextView
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Enter the date for appointment"
       android:textColor="@color/white"
       android:textSize="20sp"
       android:textStyle="italic"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintHorizontal_bias="0.0"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.103" />


   <EditText
       android:id="@+id/date"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:hint="DATE (YYYY-MM-DD)"
       android:textColor="@color/white"
       android:textColorHint="@color/white"
       android:gravity="center"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.19"
       tools:layout_editor_absoluteX="0dp" />


   <Button
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Schedule"
       android:textSize="15sp"
       android:textStyle="bold"
       android:id="@+id/schedule"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintHorizontal_bias="0.516"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.333" />


   <Button
       android:id="@+id/view_appointments"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="View Appointments"
       android:textSize="15sp"
       android:textStyle="bold"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintHorizontal_bias="0.543"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.44" />




</androidx.constraintlayout.widget.ConstraintLayout>

Explanation:

• EditText fields, which allow users to enter the date for the appointment.
• A Button which, when clicked upon, schedules the appointment of the user and then registers them into the database.
• Another Button “View Appointments” is provided which allow the users to view the appointments they have scheduled.

activity_appointment.xml

Code:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   android:background="@color/black"
   tools:context=".AppointmentActivity">




   <androidx.recyclerview.widget.RecyclerView
       android:layout_width="match_parent"
       android:padding="10dp"
       android:layout_height="match_parent"
       android:outlineAmbientShadowColor="@color/white"
       android:outlineSpotShadowColor="@color/white"
       android:id="@+id/recyclerview"/>


</androidx.constraintlayout.widget.ConstraintLayout>

Explanation:

• We have used a RecyclerView to view the appointments in a list-item manner.

item_appointment.xml

Code:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:tools="http://schemas.android.com/tools"
   android:layout_width="match_parent"
   android:background="@color/black"
   android:layout_height="match_parent">


   <TextView
       android:id="@+id/dateTextView"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:text="Date"
       android:textColor="@color/white"
       android:padding="10dp"
       android:textSize="18sp"
       android:textStyle="bold"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.043"
       tools:layout_editor_absoluteX="0dp" />


   <TextView
       android:id="@+id/idTextView"
       android:layout_width="match_parent"
       android:layout_height="wrap_content"
       android:text="ID"
       android:padding="10dp"
       android:textColor="@color/white"
       android:textSize="18sp"
       android:textStyle="bold"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintTop_toTopOf="parent"
       app:layout_constraintVertical_bias="0.008"
       tools:layout_editor_absoluteX="-16dp" />




</androidx.constraintlayout.widget.ConstraintLayout>

Explanation:

• Two TextViews are provided for ID and Date, respectively, which show the respective date and ID of the user when they schedule an appointment.

Step 3: Implementing the Functionality

MainActivity.java

Code:

package com.example.e_vaccinationsystem;


import androidx.appcompat.app.AppCompatActivity;


import android.content.Intent;
import android.os.Bundle;


import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.FirebaseUser;
import com.google.firebase.ktx.Firebase;


public class MainActivity extends AppCompatActivity {
   private FirebaseAuth auths;


   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);


       auths=FirebaseAuth.getInstance();
   }


   @Override
   protected void onStart() {
       super.onStart();
       FirebaseUser curruser=auths.getCurrentUser();
       if(curruser!=null)
       {
           startActivity(new Intent(MainActivity.this, ScheduleActivity.class));
       }else{
           startActivity(new Intent(MainActivity.this, LoginActivity.class));
       }
       finish();
   }
}

Explanation:

• onStart(): Checks whether an existing user is there or not. If there is an existing user, it takes the user directly to the Schedule activity. If there is no use, it redirects them to the Login Screen.

RegisterActivity.java

Code:

package com.example.e_vaccinationsystem;


import androidx.appcompat.app.AppCompatActivity;


import android.content.Intent;
import android.os.Bundle;
import android.text.TextUtils;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;


import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.FirebaseUser;


public class RegisterActivity extends AppCompatActivity {
   private FirebaseAuth auths;
   private EditText emailedittext, passwordedittext;
   private Button registerbutton;


   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_register);
       auths=FirebaseAuth.getInstance();
       emailedittext=findViewById(R.id.email);
       passwordedittext=findViewById(R.id.password);
       registerbutton=findViewById(R.id.register);
       registerbutton.setOnClickListener(v -> registeruser());


   }


   private void registeruser()
   {
       String email=emailedittext.getText().toString().trim();
       String password=passwordedittext.getText().toString().trim();
       if (email.isEmpty()|| password.isEmpty())
       {
           Toast.makeText(this, "Please fill all the details", Toast.LENGTH_SHORT).show();
           return;
       }
       auths.createUserWithEmailAndPassword(email,password).addOnCompleteListener(this,task -> {
           if (task.isSuccessful())
           {
               FirebaseUser user=auths.getCurrentUser();
               Toast.makeText(this, "Registration successful.Please Log in.", Toast.LENGTH_SHORT).show();
               startActivity(new Intent(RegisterActivity.this, LoginActivity.class));
               finish();
           }else {
               Toast.makeText(this, "Registration Failed", Toast.LENGTH_SHORT).show();
           }
       });
   }
}

Explanation:

• registeruser(): Registers the users by checking whether the task is successful and then returns an appropriate message.

LoginActivity.java

Code:

package com.example.e_vaccinationsystem;


import androidx.appcompat.app.AppCompatActivity;


import android.content.Intent;
import android.os.Bundle;
import android.text.TextUtils;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;


import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.auth.FirebaseUser;


public class LoginActivity extends AppCompatActivity {
   private FirebaseAuth auths;
   private EditText emailedt,passwordedt;
   private Button loginbutton;
   private TextView registertextview;


   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_login);
       auths=FirebaseAuth.getInstance();
       emailedt=findViewById(R.id.email);
       passwordedt=findViewById(R.id.password);
       loginbutton=findViewById(R.id.login);
       loginbutton.setOnClickListener(v -> loginuser());
       registertextview=findViewById(R.id.registertext);
       registertextview.setOnClickListener(v -> startActivity(new Intent(LoginActivity.this, RegisterActivity.class)));


   }


   private void loginuser()
   {
       String email=emailedt.getText().toString().trim();
       String password=passwordedt.getText().toString().trim();
       if(email.isEmpty()|| password.isEmpty()){
           Toast.makeText(this, "Please fill all the details", Toast.LENGTH_SHORT).show();
           return;
       }
       auths.signInWithEmailAndPassword(email,password).addOnCompleteListener(this,task -> {
           if (task.isSuccessful())
           {
               FirebaseUser user=auths.getCurrentUser();
               startActivity(new Intent(LoginActivity.this,ScheduleActivity.class));
               finish();
           }else {
               Toast.makeText(this, "Authentication Failure", Toast.LENGTH_SHORT).show();
           }
       });
   }
}

Explanation:

• loginuser(): Allows the user to login to the app by checking if their credentials are valid or not through Firebase.

ScheduleActivity.java

Code:

package com.example.e_vaccinationsystem;


import androidx.appcompat.app.AppCompatActivity;


import android.content.Intent;
import android.os.Bundle;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;


import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;


import java.util.HashMap;
import java.util.Map;


public class ScheduleActivity extends AppCompatActivity {
   private DatabaseReference dbms;
   private EditText dateslot;
   private Button schedulebtn;
   private Button viewApptbtn;


   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_schedule);


       dbms= FirebaseDatabase.getInstance().getReference("appointments");
       dateslot=findViewById(R.id.date);
       schedulebtn=findViewById(R.id.schedule);
       viewApptbtn=findViewById(R.id.view_appointments);
       schedulebtn.setOnClickListener(v -> scheduleAppointment());
       viewApptbtn.setOnClickListener(v -> startActivity(new Intent(ScheduleActivity.this, AppointmentActivity.class)));


   }


   private void scheduleAppointment()
   {
       String date=dateslot.getText().toString().trim();
       String userId= FirebaseAuth.getInstance().getCurrentUser().getUid();
       if(date.isEmpty())
       {
           Toast.makeText(this, "Enter Date please, it cannot be empty", Toast.LENGTH_SHORT).show();
           return;
       }
       String appointid=dbms.push().getKey();
       Map<String,Object> appointment=new HashMap<>();
       appointment.put("date",date);
       appointment.put("id", appointid);
       appointment.put("userId",userId);
       dbms.child(appointid).setValue(appointment).addOnSuccessListener(aVoid -> Toast.makeText(this, "Appointment Scheduled", Toast.LENGTH_SHORT).
               show()).addOnFailureListener(e -> Toast.makeText(this, "Scheduling Failed", Toast.LENGTH_SHORT).show());
   }
}

Explanation:

• scheduleAppointment(): Gets the userid and date field and then checks whether any input field is empty, and then, an entry is created into the database under the appointments table.

AppointmentActivity.java

Code:

package com.example.e_vaccinationsystem;


import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.recyclerview.widget.LinearLayoutManager;
import androidx.recyclerview.widget.RecyclerView;


import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;


import com.google.firebase.auth.FirebaseAuth;
import com.google.firebase.database.DataSnapshot;
import com.google.firebase.database.DatabaseError;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;
import com.google.firebase.database.ValueEventListener;


import java.util.ArrayList;
import java.util.List;


public class AppointmentActivity extends AppCompatActivity {
   private DatabaseReference dbms;
   private RecyclerView recyclerView;
   private AppointmentAdapter adapter;
   private List<Appointment> appointments=new ArrayList<>();


   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_appointment);


       dbms= FirebaseDatabase.getInstance().getReference("appointments");
       recyclerView=findViewById(R.id.recyclerview);
       recyclerView.setLayoutManager(new LinearLayoutManager(this));


       loadAppointments();
   }


   private void loadAppointments() {
       String userId= FirebaseAuth.getInstance().getCurrentUser().getUid();
       dbms.orderByChild("userId").equalTo(userId).addValueEventListener(new ValueEventListener() {
           @Override
           public void onDataChange(@NonNull DataSnapshot dataSnapshot) {
               appointments.clear();
               for(DataSnapshot snapshot:dataSnapshot.getChildren())
               {
                   Appointment appointment=snapshot.getValue(Appointment.class);
                   appointments.add(appointment);
               }
               adapter=new AppointmentAdapter(appointments);
               recyclerView.setAdapter(adapter);
           }


           @Override
           public void onCancelled(@NonNull DatabaseError error) {
               Log.e("AppointmentsActivity","Failed to retrieve appointments",error.toException());
               Toast.makeText(AppointmentActivity.this, "Failed to Load Appointments.Please try again", Toast.LENGTH_SHORT).show();
           }
       });
   }
}

Explanation:

• loadAppointments(): It retrieves the entry through the userid and then displays them onto the appointment activity. If an error occurs an error message is displayed.

Appointment.java

Code:

package com.example.e_vaccinationsystem;


public class Appointment {
   private String date;
   private String id;
   private String userId;


   public Appointment(){


   }
   public Appointment(String date, String id , String userId){
       this.date=date;
       this.id=id;
       this.userId=userId;
   }


   public String getDate() {
       return date;
   }


   public void setDate(String date) {
       this.date = date;
   }


   public String getUserId() {
       return userId;
   }


   public void setUserId(String userId) {
       this.userId = userId;
   }


   public String getId() {
       return id;
   }


   public void setId(String id) {
       this.id = id;
   }
}

Explanation:

• Used to create getters and setters for the variables.

AppointmentAdapter.java

Code:

package com.example.e_vaccinationsystem;


import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;


import androidx.annotation.NonNull;
import androidx.recyclerview.widget.RecyclerView;


import java.util.List;


public class AppointmentAdapter extends RecyclerView.Adapter<AppointmentAdapter.AppointmentViewHolder> {
   private List<Appointment> appointments;


   public AppointmentAdapter(List<Appointment> appointments){
       this.appointments=appointments;
   }


   @NonNull
   @Override
   public AppointmentAdapter.AppointmentViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType) {
       View view= LayoutInflater.from(parent.getContext()).inflate(R.layout.item_appointment,parent,false);
       return new AppointmentViewHolder(view);
   }


   @Override
   public void onBindViewHolder(@NonNull AppointmentAdapter.AppointmentViewHolder holder, int position) {
       Appointment appointment=appointments.get(position);
       holder.dateTextView.setText("Date:"+appointment.getDate());
       holder.idTextView.setText("ID:"+appointment.getId());
   }


   @Override
   public int getItemCount() {
       return appointments.size();
   }


   public static class AppointmentViewHolder extends RecyclerView.ViewHolder{
       public TextView dateTextView;
       public TextView idTextView;
       public AppointmentViewHolder(View itemView){
           super(itemView);
           idTextView=itemView.findViewById(R.id.idTextView);
           dateTextView=itemView.findViewById(R.id.dateTextView);
       }
   }
}

Explanation:

• onCreateViewHolder(): This method is called when a new “AppointmentViewHolder” needs to be created. It inflates on item layout and returns a new “AppointmentViewHolder” instance.
• onBindViewHolder(): This method displays the data at the specified position.

Android e-Vaccination System Output

Conclusion

We have successfully made an Android e-vaccination system app where users can schedule an appointment on a particular date and view their appointments.

Create an E-Vaccination System using Android. was originally published in DataFlair on Medium, where people are continuing the conversation by highlighting and responding to this story.

About Java Expense Tracker

An Expense Tracker system is a robust tool for individuals and businesses to monitor and manage their financial outflows meticulously. By facilitating the recording and categorising of expenses, these systems empower users to gain deeper insights into their spending patterns. They often come equipped with features like automated expense categorization, receipt scanning capabilities, and real-time updates, ensuring accuracy and efficiency in financial tracking.

Additionally, these systems enable users to set and manage budgets effectively while generating comprehensive reports that provide clear, actionable insights for better financial planning and decision-making.

Prerequisites for Java Expense Tracker

• Java Development Kit (JDK): Ensure your system has JDK installed. You can download it from the Oracle website.
• Integrated Development Environment (IDE): Use an IDE like IntelliJ IDEA, Eclipse, or NetBeans to manage your project efficiently.
• Basic Knowledge of Java: Familiarity with Java programming and Swing for GUI development.

Libraries Used in this Java Expense Tracker Project

javax.swing.*:

• Description: This package provides a set of “lightweight” (all-Java language) components that work simultaneously on all platforms to the maximum degree possible.
• Usage: Used to create the graphical user interface (GUI) for the expense tracker application.

javax.swing.table.DefaultTableModel:

• Description: A TableModel implementation that uses a Vector of Vectors to store the cell value objects.
• Usage: Used to manage the data displayed in the table within the GUI.

java.awt.*:

• Description: All classes for creating user interfaces and painting graphics and images.
• Usage: Used for the layout and organization of GUI components.

java.awt.event.*:

• Description: Provides interfaces and classes for dealing with different events fired by AWT components.
• Usage: Used to handle actions performed by the user, such as button clicks.

java.util.ArrayList and java.util.List:

• Description: ArrayList is a resizable array implementation of the List interface.
• Usage: Used to store the list of expenses.

Java Expense Tracker Project Setup

1. Create a New Project

• Open your IDE.
• Create a new Java project.

2. Create Packages and Classes

Create a new package.

Create the following classes within this package:

• Expense
• ExpenseManager
• ExpenseTrackerGUI

3. Write Code

Copy and paste the provided code snippets into their respective classes. Ensure all the necessary imports are included at the top of each class file.

4. Compile and Run

• Compile your project.
• Run the ExpenseTrackerGUI class to start the application.

Classes Overview

1. Expense

This class is a model representing an expense with an amount and description.

package com.ExpenseTracker;

public class Expense {
    private double amount;
    private String description;

    public Expense(double amount, String description) {
        this.amount = amount;
        this.description = description;
    }

    public double getAmount() {
        return amount;
    }

    public void setAmount(double amount) {
        this.amount = amount;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

Explanation of the above code

Package Declaration:

• package com.ExpenseTracker;
• Indicates that the Expense class is part of the com.ExpenseTracker package.

Class Declaration:

• public class Expense {
• Defines a public class named Expense.

Instance Variables:

• private double amount;
• Stores the amount of the expense as a double.
• private String description;
• Stores a description of the expense as a String.

Constructor:

• public Expense(double amount, String description) { … }
• Initializes an Expense object with a specified amount and description parameters.

Getter Method for Amount:

• public double getAmount() { … }
• Returns the current value of the amount instance variable.

Setter Method for Amount:

• public void setAmount(double amount) { … }
• Sets the value of the amount instance variable to the specified parameter.

Getter Method for Description:

• public String getDescription() { … }
• Returns the current value of the description instance variable.

Setter Method for Description:

• public void setDescription(String description) { … }
• Sets the value of the description instance variable to the specified parameter.

2. ExpenseManager

This class manages the list of expenses, providing methods to add, remove, update, and get expenses.

package com.ExpenseTracker;

import java.util.ArrayList;
import java.util.List;

public class ExpenseManager {
    private List<Expense> expenses;

    public ExpenseManager() {
        expenses = new ArrayList<>();
    }

    public void addExpense(Expense expense) {
        expenses.add(expense);
    }

    public void removeExpense(int index) {
        if (index >= 0 && index < expenses.size()) {
            expenses.remove(index);
        }
    }

    public void updateExpense(int index, Expense expense) {
        if (index >= 0 && index < expenses.size()) {
            expenses.set(index, expense);
        }
    }

    public List<Expense> getExpenses() {
        return new ArrayList<>(expenses);
    }

    public double getTotalExpenses() {
        double total = 0;
        for (Expense expense : expenses) {
            total += expense.getAmount();
        }
        return total;
    }
}

Explanation of the above code

Package Declaration:

• package com.ExpenseTracker;
• Indicates that the ExpenseManager class belongs to the com.ExpenseTracker package.

Imports:

• import java.util.ArrayList;
• import java.util.List;
• Imports necessary Java classes (ArrayList and List) from the java.util package, used for managing collections of expenses (ArrayList) and defining the interface (List).

Class Declaration:

• public class ExpenseManager {
• Defines a public class named ExpenseManager, which manages a collection of Expense objects.

Instance Variables:

• private List<Expense> expenses;
• Declares a private instance variable expenses, a list that will hold objects of type Expense.

Constructor:

• public ExpenseManager() { … }
• Constructor initializes the expenses list as a new ArrayList, ensuring it’s ready to store expenses when an ExpenseManager object is created.

Methods:

• addExpense(Expense expense):
• Adds an Expense object to the expenses list.
• removeExpense(int index):
• Removes the Expense object at the specified index from the expenses list, provided the index is valid.
• updateExpense(int index, Expense expense):
• Updates the Expense object at the specified expense list index with a new Expense object, provided the index is valid.
• getExpenses():
• Returns a copy of the expenses list. This is done using the new ArrayList<>(expenses) to prevent external modification of the internal list.

3. ExpenseTrackerGUI

This class sets up the main GUI, allowing users to interact with the system.

package com.ExpenseTracker;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;

public class ExpenseTrackerGUI extends JFrame {
    private JTextField txtAmount;
    private JTextField txtDescription;
    private DefaultTableModel tableModel;
    private ExpenseManager expenseManager;

    public ExpenseTrackerGUI() {
        expenseManager = new ExpenseManager();

        setTitle("Expense Tracker");
        setSize(600, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLocationRelativeTo(null);

        // Create components
        JLabel lblAmount = new JLabel("Amount:");
        txtAmount = new JTextField(15);
        JLabel lblDescription = new JLabel("Description:");
        txtDescription = new JTextField(15);
        JButton btnAddExpense = new JButton("Add Expense");
        JButton btnEditExpense = new JButton("Edit Expense");
        JButton btnDeleteExpense = new JButton("Delete Expense");
        JButton btnViewExpenses = new JButton("View Expenses");
        JButton btnSummary = new JButton("Summary");

        // Create table
        tableModel = new DefaultTableModel(new Object[]{"Amount", "Description"}, 0);
        JTable table = new JTable(tableModel);
        JScrollPane tableScrollPane = new JScrollPane(table);

        // Set layout and add components
        setLayout(new BorderLayout());
        JPanel inputPanel = new JPanel();
        inputPanel.add(lblAmount);
        inputPanel.add(txtAmount);
        inputPanel.add(lblDescription);
        inputPanel.add(txtDescription);
        inputPanel.add(btnAddExpense);
        inputPanel.add(btnEditExpense);
        inputPanel.add(btnDeleteExpense);
        inputPanel.add(btnViewExpenses);
        inputPanel.add(btnSummary);
        add(inputPanel, BorderLayout.NORTH);
        add(tableScrollPane, BorderLayout.CENTER);

        // Add action listeners
        btnAddExpense.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                addExpense();
            }
        });

        btnEditExpense.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                editExpense(table.getSelectedRow());
            }
        });

        btnDeleteExpense.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                deleteExpense(table.getSelectedRow());
            }
        });

        btnViewExpenses.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                viewExpenses();
            }
        });

        btnSummary.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                showSummary();
            }
        });
    }

    private void addExpense() {
        String amountStr = txtAmount.getText();
        String description = txtDescription.getText();

        if (amountStr.isEmpty() || description.isEmpty()) {
            JOptionPane.showMessageDialog(this, "Please enter both amount and description.", "Error", JOptionPane.ERROR_MESSAGE);
            return;
        }

        try {
            double amount = Double.parseDouble(amountStr);
            Expense expense = new Expense(amount, description);
            expenseManager.addExpense(expense);
            viewExpenses();
            clearFields();
        } catch (NumberFormatException e) {
            JOptionPane.showMessageDialog(this, "Invalid amount. Please enter a numeric value.", "Error", JOptionPane.ERROR_MESSAGE);
        }
    }

    private void editExpense(int selectedRow) {
        if (selectedRow < 0) {
            JOptionPane.showMessageDialog(this, "Please select an expense to edit.", "Error", JOptionPane.ERROR_MESSAGE);
            return;
        }

        String amountStr = txtAmount.getText();
        String description = txtDescription.getText();

        if (amountStr.isEmpty() || description.isEmpty()) {
            JOptionPane.showMessageDialog(this, "Please enter both amount and description.", "Error", JOptionPane.ERROR_MESSAGE);
            return;
        }

        try {
            double amount = Double.parseDouble(amountStr);
            Expense expense = new Expense(amount, description);
            expenseManager.updateExpense(selectedRow, expense);
            viewExpenses();
            clearFields();
        } catch (NumberFormatException e) {
            JOptionPane.showMessageDialog(this, "Invalid amount. Please enter a numeric value.", "Error", JOptionPane.ERROR_MESSAGE);
        }
    }

    private void deleteExpense(int selectedRow) {
        if (selectedRow < 0) {
            JOptionPane.showMessageDialog(this, "Please select an expense to delete.", "Error", JOptionPane.ERROR_MESSAGE);
            return;
        }

        expenseManager.removeExpense(selectedRow);
        viewExpenses();
    }

    private void viewExpenses() {
        List<Expense> expenses = expenseManager.getExpenses();
        tableModel.setRowCount(0);

        for (Expense expense : expenses) {
            tableModel.addRow(new Object[]{expense.getAmount(), expense.getDescription()});
        }
    }

    private void showSummary() {
        double totalExpenses = expenseManager.getTotalExpenses();
        JOptionPane.showMessageDialog(this, "Total Expenses: " + totalExpenses, "Summary", JOptionPane.INFORMATION_MESSAGE);
    }

    private void clearFields() {
        txtAmount.setText("");
        txtDescription.setText("");
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                new ExpenseTrackerGUI().setVisible(true);
            }
        });
    }
}

Explanation of the above code

Imports:

• The class imports necessary Swing and AWT classes (JFrame, JPanel, JButton, JLabel, JTextField, JTable, DefaultTableModel, JScrollPane, ActionEvent, ActionListener, SwingUtilities, JOptionPane) for creating the GUI components and handling events.

Class Declaration:

• public class ExpenseTrackerGUI extends JFrame { … }
• Extends JFrame, indicating that this class represents a GUI window (a JFrame).

Instance Variables:

• private JTextField txtAmount;
• private JTextField txtDescription;
• private DefaultTableModel tableModel;
• private ExpenseManager expenseManager;
• These variables hold references to GUI components (txtAmount, txtDescription), a table model for displaying expenses (tableModel), and an instance of ExpenseManager (expenseManager) for managing expense data.

Constructor (ExpenseTrackerGUI()):

• Initializes the GUI:
• Sets the window title, size, and default close operation and centres it on the screen.
• Creates GUI components (JLabel, JTextField, JButton, JTable, JScrollPane) and arranges them using BorderLayout.
• Button Actions:
• addActionListener for each button:
• btnAddExpense, btnEditExpense, btnDeleteExpense, btnViewExpenses, btnSummary:
• Each button has an associated ActionListener that defines what happens when the button is clicked (actionPerformed method).
• Button Actions Implementation:
• addExpense(): Validates input, creates an Expense object, adds it to expenseManager, updates the table, and clears input fields.
• editExpense(int selectedRow): Validates input, updates the selected Expense in expenseManager, updates the table, and clears input fields.
• deleteExpense(int selectedRow): Removes the selected Expense from expenseManager, and updates the table.
• viewExpenses(): Retrieves all expenses from expenseManager and updates the table with tableModel.
• showSummary(): Retrieves total expenses from expenseManager and displays it in a message dialog.

Utility Methods:

• clearFields(): Clears the txtAmount and txtDescription fields.
• main Method:
• public static void main(String[] args) { … }
• The application's entry point creates an instance of ExpenseTrackerGUI and sets it visible on the Event Dispatch Thread (EDT) using SwingUtilities.invokeLater().

Java Expense Tracker Output

Conclusion

This expense tracker system project demonstrates creating a simple yet functional application using Java. The system allows users to manage their expenses with a user-friendly interface. The Java Expense Tracker project is organized into three classes, each with specific responsibilities, ensuring modularity and maintainability.

Track Your Expenses using Java. was originally published in Tutorials Flood on Medium, where people are continuing the conversation by highlighting and responding to this story.

Need of a Python Internet Speed Test

It enables one to diagnose connectivity issues with your Internet connection to improve your network. It also aids in determining whether your Internet service provider (ISP) is providing the bandwidth they advertised in your package. Being informed about your internet speed can enable you to manage or adjust streaming, gaming and other activities on the internet to suit one’s desire.

About the Python Internet Speed Test Project

This project is about creating a simple GUI application using Python that tests the internet speed. This application uses the “speedtest” module to perform the speed test and the “tkinter” module for the GUI part.

Prerequisites of Python Internet Speed Test

To run this Python project, the following prerequisites must be met:

• Python: The user must have Python installed in their system.
• Tkinter: This library is used for making the GUI for utility tools.
• Speedtest-cli: This module helps in performing the internet speed tests.

Step-by-Step Explanation of Python Internet Speed Test Project

The following is the explanation of the code for the project:

Importing the Libraries

import tkinter as tk
from tkinter import ttk
import speedtest

The “tkinter” module is included for creating the GUI, and the “speedtest” module is for conducting the speed test.

Function to check the speed

def speedCheck():
    speedtestCalc = speedtest.Speedtest()
    speedtestCalc.download()
    speedtestCalc.upload()
    results = speedtestCalc.results.dict()
    speedDownload = results["download"] / 1_000_000
    speedUpload = results["upload"] / 1_000_000
    ping = results["ping"]
       labelDownload_1.config(text=f"Download Speed: {speedDownload:.2f} Mbps")
    labelUpload_2.config(text=f"Upload Speed: {speedUpload:.2f} Mbps")
    labelPing_3.config(text=f"Ping: {ping:.2f} ms")

This function assists in the execution of the internet speed test function. It also uses a “Speedtest” object performs download and upload speed tests, and gets the results. The download and upload speed figures are converted from bits per second to megabits per second (Mbps). The ping may be expressed in terms of milliseconds (ms).

Setting up the GUI

root = tk.Tk()
root.title("Internet Speed Test")
ttk.Label(root, text="Internet Speed Test", font=("Arial", 16)).grid(column=0, row=0, pady=10)
ttk.Button(root, text="Start Test", command=speedCheck).grid(column=0, row=1, pady=10)
labelDownload_1 = ttk.Label(root, text="Download Speed: N/A", font=("Arial", 12))
labelDownload_1.grid(column=0, row=2, pady=5)
labelUpload_2 = ttk.Label(root, text="Upload Speed: N/A", font=("Arial", 12))
labelUpload_2.grid(column=0, row=3, pady=5)
labelPing_3 = ttk.Label(root, text="Ping: N/A", font=("Arial", 12))
labelPing_3.grid(column=0, row=4, pady=5)
root.mainloop()

Tkinter window is launched. Three labels and one button are created on the window. On the labels, the indicators of the download speed, the upload speed and the ping can be observed. This button is associated with the “speedCheck” method that causes the speed test and sets the labels with the results.

Python Internet Speed Test Output

1. This is the launch page of the application, where we can see a button which needs to be clicked to start the internet speed test.

2. Here, we have started the speed test by clicking the button.

3. The above image shows the test result, where we can see the download speed, the upload speed and the ping of the network.

Conclusion

This project demonstrates a simple application of Python for testing internet speed using a GUI. It uses the “tkinter” module for the graphical interface and the “speedtest” module for conducting the speed test. The project serves the purpose of helping diagnose a network problem and check the speed of the internet connection.

Check the Internet Speed using Python. was originally published in Data Science Flood on Medium, where people are continuing the conversation by highlighting and responding to this story.