#Sets
U = {0,1,2,3,4,5,6,7,8,9}
P = {1,2,3,4}
Q = {4,5,6}
R = {3,4,6,8,9}

def set2bits(xs,us) :
    bs=[]
    for x in us :
        if x in xs :
            bs.append(1)
        else:
            bs.append(0)
    assert len(us) == len(bs)
    return bs

def union(set1,set2) :
    finalSet = set()
    bitList1 = set2bits(set1, U)
    bitList2 = set2bits(set2, U)

    for i in range(len(U)) :
        if(bitList1[i] or bitList2[i]) :
            finalSet.add(i)

    return finalSet

def intersection(set1,set2) :
    finalSet = set()
    bitList1 = set2bits(set1, U)
    bitList2 = set2bits(set2, U)

    for i in range(len(U)) :
        if(bitList1[i] and bitList2[i]) :
            finalSet.add(i)

    return finalSet

def compliment(set1) :
    finalSet = set()
    bitList = set2bits(set1, U)

    for i in range(len(U)) :
        if(not bitList[i]) :
            finalSet.add(i)

    return finalSet

def implication(a,b):
    return union(compliment(a), b)

###########################################################################################
######################         Problems 1-6         #######################################
###########################################################################################

#p \/ (q /\ r) = (p \/ q) /\ (p \/ r)
def prob1():
    return union(P, intersection(Q,R)) == intersection(union(P,Q), union(P,R))

#p /\ (q \/ r) = (p /\ q) \/ (p /\ r)
def prob2():
    return intersection(P, union(Q,R)) == union(intersection(P,Q), intersection(P,R))

#~(p /\ q) = ~p \/ ~q
def prob3():
    return compliment(intersection(P,R)) == union(compliment(P), compliment(R))

#~(p \/ q) = ~p /\ ~q
def prob4():
    return compliment(union(P,Q)) == intersection(compliment(P), compliment(Q))

#(p=>q) = (~q => ~p)
def prob5():
    return implication(P,Q) == implication(compliment(Q), compliment(P))

#(p => q) /\ (q => r)  =>  (p => r)
def prob6():
    return implication(intersection(implication(P,Q), implication(Q,R)), implication(P,R))


print("Problem 1: ", prob1())
print("Problem 2: ", prob2())
print("Problem 3: ", prob3())
print("Problem 4: ", prob4())
print("Problem 5: ", prob5())
print("Problem 6: ", prob6())

'''
Problem 1:  True
Problem 2:  True
Problem 3:  True
Problem 4:  True
Problem 5:  True
Problem 6:  {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
'''

# Python Program to calculate the square root

num = float(input('Enter a number: '))

num_sqrt = num ** 0.5
print('The square root of %0.3f is %0.3f'%(num ,num_sqrt))

""" Calculator
----------------------------------------
"""
def addition ():
    print("Addition")
    n = float(input("Enter the number: "))
    t = 0 //Total number enter
    ans = 0
    while n != 0:
        ans = ans + n
        t+=1
        n = float(input("Enter another number (0 to calculate): "))
    return [ans,t]
def subtraction ():
    print("Subtraction");
    n = float(input("Enter the number: "))
    t = 0 //Total number enter
    sum = 0
    while n != 0:
        ans = ans - n
        t+=1
        n = float(input("Enter another number (0 to calculate): "))
    return [ans,t]
def multiplication ():
    print("Multiplication")
    n = float(input("Enter the number: "))
    t = 0 //Total number enter
    ans = 1
    while n != 0:
        ans = ans * n
        t+=1
        n = float(input("Enter another number (0 to calculate): "))
    return [ans,t]
def average():
    an = []
    an = addition()
    t = an[1]
    a = an[0]
    ans = a / t
    return [ans,t]
// main...
while True:
    list = []
    print(" My first python program!")
    print(" Simple Calculator in python by Malik Umer Farooq")
    print(" Enter 'a' for addition")
    print(" Enter 's' for substraction")
    print(" Enter 'm' for multiplication")
    print(" Enter 'v' for average")
    print(" Enter 'q' for quit")
    c = input(" ")
    if c != 'q':
        if c == 'a':
            list = addition()
            print("Ans = ", list[0], " total inputs ",list[1])
        elif c == 's':
            list = subtraction()
            print("Ans = ", list[0], " total inputs ",list[1])
        elif c == 'm':
            list = multiplication()
            print("Ans = ", list[0], " total inputs ",list[1])
        elif c == 'v':
            list = average()
            print("Ans = ", list[0], " total inputs ",list[1])
        else:
            print ("Sorry, invilid character")
    else:
        break

def print_x_pattern(size):
    i,j = 0,size - 1

    while j >= 0 and i < size:

        initial_spaces = ' '*min(i,j)
        middle_spaces = ' '*(abs(i - j) - 1)
        final_spaces = ' '*(size - 1 - max(i,j))

        if j == i:
            print(initial_spaces + '*' + final_spaces)
        else:
            print(initial_spaces + '*' + middle_spaces + '*' + final_spaces)

        i += 1
        j -= 1

print_x_pattern(7)

"""
Take screenshots at x interval - make a movie of doings on a computer.
"""

import time
from datetime import datetime

import ffmpeg
import pyautogui

while True:
    epoch_time = int(time.time())
    today = datetime.now().strftime("%Y_%m_%d")
    filename = str(epoch_time) + ".png"

    print("taking screenshot: {0}".format(filename))
    myScreenshot = pyautogui.screenshot()

    myScreenshot.save(today + "/" + filename)

    time.sleep(5)

#
# and then tie it together with: https://github.com/kkroening/ffmpeg-python/blob/master/examples/README.md#assemble-video-from-sequence-of-frames
#

"""
import ffmpeg
(
    ffmpeg
    .input('./2021_01_22/*.png', pattern_type='glob', framerate=25)
    .filter('deflicker', mode='pm', size=10)
    .filter('scale', size='hd1080', force_original_aspect_ratio='increase')
    .output('movie.mp4', crf=20, preset='slower', movflags='faststart', pix_fmt='yuv420p')
    .run()
)
"""

import os
import sys
import argparse
import json
import csv
import getpass
import string
import random
import re

from datetime import datetime
import ldap
import requests
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
from requests.auth import HTTPBasicAuth
import validators



def create_guac_connection(BASE_URL, auth_token, ldap_group, computer, guac_group_id):
    '''
    creates a guac connection
    '''
    json_header = {'Accept': 'application/json'}
    query_parm_payload = { 'token': auth_token }

    payload_data = {
   "parentIdentifier":guac_group_id,
   "name":computer,
   "protocol":"vnc",
   "parameters":{
      "port":"5900",
      "read-only":"",
      "swap-red-blue":"",
      "cursor":"",
      "color-depth":"",
      "clipboard-encoding":"",
      "disable-copy":"",
      "disable-paste":"",
      "dest-port":"",
      "recording-exclude-output":"",
      "recording-exclude-mouse":"",
      "recording-include-keys":"",
      "create-recording-path":"",
      "enable-sftp":"true",
      "sftp-port":"",
      "sftp-server-alive-interval":"",
      "enable-audio":"",
      "audio-servername":"",
      "sftp-directory":"",
      "sftp-root-directory":"",
      "sftp-passphrase":"",
      "sftp-private-key":"",
      "sftp-username":"",
      "sftp-password":"",
      "sftp-host-key":"",
      "sftp-hostname":"",
      "recording-name":"",
      "recording-path":"",
      "dest-host":"",
      "password":"asdasd",
      "username":"asdasd",
      "hostname":"nt72310.cvad.unt.edu"
   },
   "attributes":{
      "max-connections":"",
      "max-connections-per-user":"1",
      "weight":"",
      "failover-only":"",
      "guacd-port":"",
      "guacd-encryption":"",
      "guacd-hostname":""
   }
}
    CREATE_CONNECTION_URL = BASE_URL + "/api/session/data/mysql/connections"

    create_connection_request = requests.post(CREATE_CONNECTION_URL, headers=json_header, params=query_parm_payload, data=payload_data, verify=False)
    create_connection_result = create_connection_request.status_code


    if create_connection_result == "200":
        print("Successfully created computer: " + computer)
    else: 
        print(create_connection_request.json())

    return create_connection_result