Programatically Close A Program With Python After A Certain Time

Today, out of boredom, I decided to make a python application that will be able to automatically close other applications at the time given to it.
This could be a perfect idea for an application but I do not think I will make it now, maybe later...

For now, am going to name the program "App Killer". Sounds cool right? 🆒
Am going to code it in Python, am going to use Object Oriented approach since that seems cooler than functional programming to me.

How It Will Work

Okay, so the program is going to be multi-threaded, meaning, it's going to run on multiple threads.
The application will collect two data from the user, the program name, and it's end time. Then both will be processed and ran on a unique thread.
On each thread, a function will run to check if the time has come for a program to end,
if it has, it then kills the application.
In order to kill the application, it will run the command taskkill \IM %application_name% \F where %application_name% is the name of the application which we want to close. This command will forcefully close all instances of the application when the time is due. Sounds easy, right?

Coding The Script

import time as time_module # The time module
from threading import Thread #The threading module will allow us to run the program on multiple threads
from subprocess import Popen #This allows us to execute shell commands


class AppKiller:
  """
  The code for our app
  """
  def __init__(self, name, time):
    self.name = name #The application's name
    self.time = time #The time at which it is to close

  def get_time(self):
    #This function returns the current time using the time module
    return str(time_module.strftime("%R"))

  def watch(self):
    #This is the function which does the killing of the application
    #It runs an inner function which loops every two seconds to check
    #if the current time is equal to the closing time of the application
    #it runs a shell command which takes the application's name and then
    #kills it
    def inner_function():
      while self.get_time() != self.time:
        time_module.sleep(2)
      command = Popen(["taskkill","/IM",self.name,"/F"],shell=True)
    Thread(target=inner_function).start()

"""
  Example
  =======

  brave = AppKiller("brave.exe","08:32")
  brave.watch()

  node_js = AppKiller("node.js","21:13")
  node_js.watch()
"""

That's the code above, it's very simple, inside the watch method, there is an inner function which checks if the current time is equal to the end time of an app, if it is, it then kills the application, else, it sleeps for 2 seconds and checks again.

Using the Script

Now that we are done coding the script, it's now time to use it. The most suitable way to have run this program was by making it into a CLI tool but... let's just use it the hard-coded way.

So, to make the App Killer watch and kill an app, you pass two parameters to it's constructor, the app's executable name and the time at which it is to quit.

So for the example which I am going to be making, am going to kill two apps, Node JS and my Brave browser, NodeJS will close at 08:30 (ie. 8:30 AM) and Brave Browser will close at 21:21 (ie. 9:21PM).

So in our code, we will write:

brave = AppKiller("brave.exe","21:21")
brave.watch()

node_js = AppKiller("node.exe","08:30")
node_js.watch()

That's all that is need to initiate the simple program we created.
Now, when you look at the little snippet I wrote, you will notice that the time 21:21 comes before 08:30. Since each instance of the AppKiller class runs on a different thread, the time won't be affected, that is, brave.exe will not close before node.exe, they will all close when their time is due since they all run on different threads.

Happy Coding! 😄