getmac | mac address of the current machine | Runtime Evironment library

class ClassName:
    import tkinter, re, uuid
    from tkinter.constants import *
    import tkinter.messagebox
    import socket, os, subprocess, multiprocessing, sys
    from getmac import get_mac_address as gma
    import getmac, paramiko
    import gpio
    import time, requests, sudo
    from subprocess import Popen
 
    def __init__(self):
        self.p = paramiko.SSHClient()
        self.p.set_missing_host_key_policy(paramiko.AutoAddPolicy())   
        self.p.connect("X.0.0.X", port = , username=" ", password=" ")

    def get_ports(self):
        tkinter.messagebox.showinfo("Configure Software", "Configure Access")

        button3 = tkinter.Button(frame,text="Configure", fg="pink", bg="white", command=get_ports)
        button3.pack(side=LEFT)
        
        tkinter.messagebox.showinfo("Client/Server Information", "Lets Be Nosey")
    
        button4 = tkinter.Button(frame,text=" Client/Server Information", command=get_ports)
        button4.pack(side=LEFT)
    
        exec(open('path').read(), globals())

    def pinger(self, job_q, results_q):
        """
        Do Ping
        :param job_q:
        :param results_q:
        :return:
        """
        DEVNULL = open(os.devnull, 'w')
        while True:

            ip = job_q.get()

            if ip is None:
                break

            try:
                subprocess.check_call(['ping', '-c1', ip],
                                    stdout=DEVNULL)
                results_q.put(ip)
            except:
                pass

    def get_my_ip(self):
        """
        Find my IP address
        :return:
        """
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(("8.8.8.8", 80))
        ip = s.getsockname()[0]
        s.close()
        return ip

    def map_network(self, pool_size=255):
        """
        Maps the network
        :param pool_size: amount of parallel ping processes
        :return: list of valid ip addresses
        """

        ip_list = list()

        ip_parts = get_my_ip().split('.')
        base_ip = ip_parts[0] + '.' + ip_parts[1] + '.' + ip_parts[2] + '.'

        jobs = multiprocessing.Queue()
        results = multiprocessing.Queue()

        pool = [multiprocessing.Process(target=pinger, args=(jobs, results)) for i in range(pool_size)]

        for p in pool:
            p.start()

        for i in range(1, 255):
            jobs.put(base_ip + '{0}'.format(i))

        for p in pool:
            jobs.put(None)

        for p in pool:
            p.join()

        while not results.empty():
            ip = results.get()
            ip_list.append(ip)

        return ip_list

    def test_log(self):
        print('test log')
        print('Mapping...')
        lst = map_network()
        print(lst)
        addresses = subprocess.check_output(['arp', '-a'])
        print(addresses)

    def ssh_connect(self):
        ssh = paramiko.SSHClient()
        ssh.load_system_host_keys()
        ssh.set_missing_host_key_policy(paramiko.WarningPolicy())
        ssh.connect("X.0.0.X", port, "user", "password")
        chan=ssh.get_transport().open_session()
        chan.get_pty()
        f = chan.makefile()
        chan.exec_command("sudo dmesg")
        chan.send("password\n")
        print(f.read())
        ssh.close()
        pass

    def raspi_connecter(self):
        print("Below is the output from the shell script in terminal")
        # subprocess.call('ssh user@X.0.0.X', shell=True)
        proc = subprocess.Popen('ssh user@X.0.0.X', shell=True)
        try:
            outs, errs = proc.communicate(timeout=8)
                # print(f.returncode)
        except TimeoutError:
            proc.kill()

            cmd = ['sh commands3.sh']
            f = subprocess.Popen(cmd, stdout=subprocess.PIPE)
            for line in f.stdout:
                print(line)
                f.wait()

    def keypad_tests(self):
        stdin, stdout, stderr = self.p.exec_command('sudo nano /etc/hostname')
        opt2 = stdout.readlines()
        opt2 = "".join(opt2)
        # sudo journalctl -u spiderentry.service | sudo tee ../../full_log.sh 
        print(opt2)
        input("press enter to continue")

    # sudo touch and sudo tee (wipe the file (X_log) and recreate/write upon command execution)

            


    if __name__=='__main__':
        tk = tkinter.Tk()
        

        frame = tkinter.Frame(tk, relief=RIDGE, borderwidth=2)
        frame.pack(fill=BOTH,expand=100)

        label = tkinter.Label(frame, text="GUI IP/Port Scanner")
        label.pack(fill=X, expand=100)
        
        button1 = tkinter.Button(frame,text="Exit",fg="red", bg="black", command=tk.destroy)
        button1.pack(side=LEFT)
        
        button2 = tkinter.Button(frame,text="Start", fg="blue", bg="green", command=map_network)
        button2.pack(side=LEFT)
        button5 = tkinter.Button(frame, text="Port Scanner", command=test_log)
        button5.pack(side=LEFT)
        button6 = tkinter.Button(frame, text="connect keypad", command=raspi_connecter)
        button6.pack(side=LEFT)
        button7 = tkinter.Button(frame, text= "run tests", command= keypad_tests)
        button7.pack(side=LEFT)

        tk.mainloop()

    # release the function (threading, multiprocessing)
    # # open file and pull lines out commands.sh