mainUI.py

from filemanager import fm
from main_ui.mainwindow import Ui_MainWindow
from PyQt5 import QtGui as gui, QtCore as core, QtWidgets as wdgt
import sys
import time
import os

# FOR DATABASE COMMUNICATION:
#from cmsdbldr_client import LoaderClient
import atexit  # Close ssh tunnel upon exiting the GUI
import glob

# For uploading XML files in background
import threading
#import subprocess
import platform
if platform.system() == 'Windows':
	import wexpect as pexpect
else: import pexpect


# Import page functionality classes
from pages.view_users       import func as cls_func_view_users
from pages.view_baseplate   import func as cls_func_view_baseplate
from pages.view_sensor      import func as cls_func_view_sensor
from pages.view_PCB         import func as cls_func_view_PCB
from pages.view_protomodule import func as cls_func_view_protomodule
from pages.view_module      import func as cls_func_view_module
from pages.search           import func as cls_func_search

#from pages.view_kapton_step import func as cls_func_view_kapton_step
from pages.view_sensor_step import func as cls_func_view_sensor_step
from pages.view_sensor_post import func as cls_func_view_sensor_post
from pages.view_pcb_step    import func as cls_func_view_pcb_step
from pages.view_pcb_post    import func as cls_func_view_pcb_post
from pages.view_wirebonding import func as cls_func_view_wirebonding
from pages.view_plots       import func as cls_func_view_plots

from pages.view_tooling     import func as cls_func_view_tooling
from pages.view_supplies    import func as cls_func_view_supplies




# Set up page widgets
from pages_ui.view_users import Ui_Form as form_view_users
class widget_view_users(wdgt.QWidget,form_view_users):
	def __init__(self,parent):
		super(widget_view_users,self).__init__(parent)
		self.setupUi(self)

from pages_ui.view_baseplate import Ui_Form as form_view_baseplate
class widget_view_baseplate(wdgt.QWidget,form_view_baseplate):  #was gui.QWidget, etc
	def __init__(self,parent):
		super(widget_view_baseplate,self).__init__(parent)
		self.setupUi(self)

from pages_ui.view_sensor import Ui_Form as form_view_sensor
class widget_view_sensor(wdgt.QWidget,form_view_sensor):
	def __init__(self,parent):
		super(widget_view_sensor,self).__init__(parent)
		self.setupUi(self)

from pages_ui.view_PCB import Ui_Form as form_view_PCB
class widget_view_PCB(wdgt.QWidget,form_view_PCB):
	def __init__(self,parent):
		super(widget_view_PCB,self).__init__(parent)
		self.setupUi(self)


from pages_ui.view_protomodule import Ui_Form as form_view_protomodule
class widget_view_protomodule(wdgt.QWidget,form_view_protomodule):
	def __init__(self,parent):
		super(widget_view_protomodule,self).__init__(parent)
		self.setupUi(self)

from pages_ui.view_module import Ui_Form as form_view_module
class widget_view_module(wdgt.QWidget,form_view_module):
	def __init__(self,parent):
		super(widget_view_module,self).__init__(parent)
		self.setupUi(self)

# NEW:

from pages_ui.search import Ui_Form as form_search
class widget_search(wdgt.QWidget,form_search):
	def __init__(self,parent):
		super(widget_search,self).__init__(parent)
		self.setupUi(self)


from pages_ui.view_sensor_step import Ui_Form as form_view_sensor_step
class widget_view_sensor_step(wdgt.QWidget,form_view_sensor_step):
	def __init__(self,parent):
		super(widget_view_sensor_step,self).__init__(parent)
		self.setupUi(self)

from pages_ui.view_sensor_post import Ui_Form as form_view_sensor_post
class widget_view_sensor_post(wdgt.QWidget,form_view_sensor_post):
	def __init__(self,parent):
		super(widget_view_sensor_post,self).__init__(parent)
		self.setupUi(self)

from pages_ui.view_pcb_step import Ui_Form as form_view_pcb_step
class widget_view_pcb_step(wdgt.QWidget, form_view_pcb_step):
	def __init__(self,parent):
		super(widget_view_pcb_step,self).__init__(parent)
		self.setupUi(self)

from pages_ui.view_pcb_post import Ui_Form as form_view_pcb_post
class widget_view_pcb_post(wdgt.QWidget, form_view_pcb_post):
	def __init__(self,parent):
		super(widget_view_pcb_post,self).__init__(parent)
		self.setupUi(self)

from pages_ui.view_wirebonding import Ui_Form as form_view_wirebonding
class widget_view_wirebonding(wdgt.QWidget, form_view_wirebonding):
	def __init__(self,parent):
		super(widget_view_wirebonding,self).__init__(parent)
		self.setupUi(self)

from pages_ui.view_plots import Ui_Form as form_view_plots
class widget_view_plots(wdgt.QWidget, form_view_plots):
	def __init__(self,parent):
		super(widget_view_plots,self).__init__(parent)
		self.setupUi(self)

from pages_ui.view_tooling import Ui_Form as form_view_tooling
class widget_view_tooling(wdgt.QWidget, form_view_tooling):
	def __init__(self,parent):
		super(widget_view_tooling,self).__init__(parent)
		self.setupUi(self)

from pages_ui.view_supplies import Ui_Form as form_view_supplies
class widget_view_supplies(wdgt.QWidget, form_view_supplies):
	def __init__(self,parent):
		super(widget_view_supplies,self).__init__(parent)
		self.setupUi(self)




# Dict of page IDs by name (as the name shows up in the page list widgets)
PAGE_IDS = {
	'Users'                  : 0,
	'Search'                 : 1,
	'Baseplates'             : 2,
	'Sensors'                : 3,
	'Hexaboards'                   : 4,
	'Protomodules'           : 5,
	'Modules'                : 6,
	'Tooling'                : 7,
	'Supplies'               : 8,

	'1. Sensor - pre-assembly' : 9,
	'2. Sensor - post-assembly': 10,
	'3. Hexaboard - pre-assembly'    : 11,
	'4. Hexaboard - post-assembly'    : 12,
	'5. Wirebonding & encapsulating' : 13,
	'6. Module testing' : 14,

}

# List of all pages where DB expects info to upload
UPLOAD_ENABLED_PAGES = [
	'Baseplates',  # In theory, should never have to upload these
	'Sensors',
	'Hexaboards',
	'Protomodules',
	'Modules',
	'2. Sensor - post-assembly',
	'4. Hexaboard - post-assembly',
	'5. Wirebonding & encapsulating',
]


def id_generator():
	"""creates a generator for unique ID values"""
	next_id = 0
	while True:
		yield next_id
		next_id += 1


class mainDesigner(wdgt.QMainWindow,Ui_MainWindow):

	def __init__(self):
		super(mainDesigner,self).__init__(None)
		print("Setting up filemanager...")
		fm.setup()
		print("Finished setting up filemanager.  DATADIR is", fm.DATADIR)
		print("Setting up user manager...")
		self.userManager = fm.UserManager()
		print("Finished setting up user manager.")

		print("Setting up main UI ...")
		self.setupUi(self)
		print("Finished setting up main UI.")
		print("Setting up pages' UI...")
		self.setupPagesUI()
		print("Finished setting up pages' UI.")
		print("Initializing pages...")
		self.initPages()
		print("Finished initializing pages.")
		print("Rigging UI...")
		self.rig()
		print("Finished rigging UI.")

		self.setUIPage('Baseplates')
		print("Set UI page")

		self.setWindowTitle("Module Assembly User Interface")
	
		if not fm.ENABLE_DB_COMMUNICATION:
			print("DB communcation is DISABLED")
			return
		print("DB communication is ENABLED")

		# NEW:  Set up ssh tunnel for DB access!
		# First, request username:
		ldlg = UserDialog(self)
		loginResult = ldlg.exec_()
		if loginResult != 1:
			print("Login cancelled")
			exit()
		#loginResult = 0
		#attempts = 0
		#while attempts < 3 and loginResult != 1:
		#	print("Login request: attempt {}".format(attempts))
		#	loginResult = ldlg.exec_()
		#	if loginResult == 1:  break
		#	attempts += 1
		self.username = ldlg.getUsername()
		self.password = ldlg.getPassword()
		print("Got username:  ",  ldlg.getUsername())
		# WARNING:  May need ot be changed for developemnt DB!
		# to:  ssh -L 10221:itrac5403-v.cern.ch:10121 -L 10222:itrac5423-v.cern.ch:10121 -L 10223:itrac5432-v.cern.ch:10121 username@lxplus.cern.ch
		# os.system('ssh -fNT -M -S temp_socket -L 10131:itrac1609-v.cern.ch:10121 -L 10132:itrac1601-v.cern.ch:10121 {}@lxplus.cern.ch'.format(self.username))
		#os.system('ssh -vvv -f -N -M -L 10131:itrac1609-v.cern.ch:10121 -L 10132:itrac1601-v.cern.ch:10121 {}@lxplus.cern.ch'.format(self.username))

		# Now, connect to the DB
		# fm.db_connect()
	
		# Close upon exiting
		# def close_ssh():
		# 	print("Closing ssh connection")
		# 	os.system('ssh -S temp_socket -O exit lxplus.cern.ch')
		# 	print("Closed ssh connection")
		# atexit.register(close_ssh)

		# After tunnel established, :
		# fm.connectOracle()


	def setupPagesUI(self):
		self.page_view_users       = widget_view_users(None)       ; self.swPages.addWidget(self.page_view_users)

		self.page_search           = widget_search(None)           ; self.swPages.addWidget(self.page_search)
		self.page_view_baseplate   = widget_view_baseplate(None)   ; self.swPages.addWidget(self.page_view_baseplate)
		self.page_view_sensor      = widget_view_sensor(None)      ; self.swPages.addWidget(self.page_view_sensor)
		self.page_view_PCB         = widget_view_PCB(None)         ; self.swPages.addWidget(self.page_view_PCB)
		self.page_view_protomodule = widget_view_protomodule(None) ; self.swPages.addWidget(self.page_view_protomodule)
		self.page_view_module      = widget_view_module(None)      ; self.swPages.addWidget(self.page_view_module)
		self.page_view_tooling     = widget_view_tooling(None)     ; self.swPages.addWidget(self.page_view_tooling)
		self.page_view_supplies    = widget_view_supplies(None)    ; self.swPages.addWidget(self.page_view_supplies)

		self.page_view_sensor_step = widget_view_sensor_step(None) ; self.swPages.addWidget(self.page_view_sensor_step)
		self.page_view_sensor_post = widget_view_sensor_post(None) ; self.swPages.addWidget(self.page_view_sensor_post)
		self.page_view_pcb_step    = widget_view_pcb_step(None)    ; self.swPages.addWidget(self.page_view_pcb_step)
		self.page_view_pcb_post    = widget_view_pcb_post(None)    ; self.swPages.addWidget(self.page_view_pcb_post)
		self.page_view_wirebonding = widget_view_wirebonding(None) ; self.swPages.addWidget(self.page_view_wirebonding)
		self.page_view_plots       = widget_view_plots(None)       ; self.swPages.addWidget(self.page_view_plots)



	def initPages(self):
		self.func_view_users       = cls_func_view_users(            fm, self.userManager, self.page_view_users      , self.setUIPage, self.setSwitchingEnabled)

		self.func_search           = cls_func_search(                fm, self.page_search          , self.setUIPage, self.setSwitchingEnabled)
		self.func_view_baseplate   = cls_func_view_baseplate(        fm, self.userManager, self.page_view_baseplate  , self.setUIPage, self.setSwitchingEnabled)
		self.func_view_sensor      = cls_func_view_sensor(           fm, self.userManager, self.page_view_sensor     , self.setUIPage, self.setSwitchingEnabled)
		self.func_view_PCB         = cls_func_view_PCB(              fm, self.userManager, self.page_view_PCB        , self.setUIPage, self.setSwitchingEnabled)
		self.func_view_protomodule = cls_func_view_protomodule(      fm, self.userManager, self.page_view_protomodule, self.setUIPage, self.setSwitchingEnabled)
		self.func_view_module      = cls_func_view_module(           fm, self.userManager, self.page_view_module     , self.setUIPage, self.setSwitchingEnabled)
		self.func_view_tooling     = cls_func_view_tooling(          fm, self.page_view_tooling    , self.setUIPage, self.setSwitchingEnabled)
		self.func_view_supplies    = cls_func_view_supplies(         fm, self.page_view_supplies   , self.setUIPage, self.setSwitchingEnabled)

		self.func_view_sensor_step = cls_func_view_sensor_step(      fm, self.userManager, self.page_view_sensor_step, self.setUIPage, self.setSwitchingEnabled)
		self.func_view_sensor_post = cls_func_view_sensor_post(      fm, self.userManager, self.page_view_sensor_post, self.setUIPage, self.setSwitchingEnabled)
		self.func_view_pcb_step    = cls_func_view_pcb_step(         fm, self.userManager, self.page_view_pcb_step   , self.setUIPage, self.setSwitchingEnabled)
		self.func_view_pcb_post    = cls_func_view_pcb_post(         fm, self.userManager, self.page_view_pcb_post   , self.setUIPage, self.setSwitchingEnabled)
		self.func_view_wirebonding = cls_func_view_wirebonding(      fm, self.userManager, self.page_view_wirebonding, self.setUIPage, self.setSwitchingEnabled)
		self.func_view_plots       = cls_func_view_plots(            fm, self.page_view_plots,       self.setUIPage, self.setSwitchingEnabled)

		# This list must be in the same order that the pages are in in the stackedWidget in the main UI file.
		# This is the same order as in the dict PAGE_IDS
		self.func_list = [
			self.func_view_users,

			self.func_search,
			self.func_view_baseplate,
			self.func_view_sensor,
			self.func_view_PCB,
			self.func_view_protomodule,
			self.func_view_module,
			self.func_view_tooling,
			self.func_view_supplies,

			self.func_view_sensor_step,
			self.func_view_sensor_post,
			self.func_view_pcb_step,
			self.func_view_pcb_post,
			self.func_view_wirebonding,
			self.func_view_plots,
			]


	def rig(self):
		self.listUsers.itemActivated.connect(self.changeUIPage)
		self.listInformation.itemActivated.connect(self.changeUIPage)
		self.listModules.itemActivated.connect(self.changeUIPage)
		self.listAssembly.itemActivated.connect(self.changeUIPage)
		self.swPages.currentChanged.connect(self.pageChanged)

		self.pbUploadObject.clicked.connect(self.goUploadObject)
		self.pbUploadDate.clicked.connect(self.goUploadDate)
  
		self.pbUploadStartNow.clicked.connect(self.uploadStartNow)

	

	def pageChanged(self,*args,**kwargs):
		self.func_list[args[0]].changed_to()

	def changeUIPage(self,*args,**kwargs):
		self.setUIPage(args[0].text())

	def setUIPage(self, which_page, switch_to_page=True, **kwargs):
		if which_page in PAGE_IDS.keys():
			if self.func_list[PAGE_IDS[which_page]].mode == 'setup':
				print("page {} not yet setup; doing setup".format(which_page))
				self.func_list[PAGE_IDS[which_page]].setup()

			if switch_to_page:
				self.swPages.setCurrentIndex(PAGE_IDS[which_page])
				# self.func_list[PAGE_IDS[which_page]].changed_to() # notify page function that page has been changed to

			if len(kwargs) > 0:
				self.func_list[PAGE_IDS[which_page]].load_kwargs(kwargs)

			# NEW:  Enable/disable uploading accordingly.
			enableUploading = which_page in UPLOAD_ENABLED_PAGES
			self.pbUploadObject.setEnabled(enableUploading)
			self.pbUploadDate.setEnabled(  enableUploading)
			self.dUpload.setEnabled(       enableUploading)
			self.leStatus.setText("")
			self.leStatus.setEnabled(      enableUploading)

		else:
			print("Page <{}> not supported yet. Tried to load with kwargs {}".format(which_page,kwargs))

	def setSwitchingEnabled(self,enabled):
		self.listUsers.setEnabled(enabled)
		self.listInformation.setEnabled(enabled)
		self.listAssembly.setEnabled(enabled)


	# New, sort of experimental
	def goUploadObject(self,*args,**kwargs):
		# Create a popup box requesting username/password, plus a "cancel" button.
		# If username+password given, submit.
		# BUT:  How can username/password be fed to loader?

		# NEW:
		# Find directory w/ a certain date, and upload ALL files in it.

		# OUTDATED:
		# FIRST:  Check to see whether there's any modified XML files

		currentPage = self.func_list[self.swPages.currentIndex()]
		upload_files = currentPage.filesToUpload()
		print("Preparing to upload files for single object:", upload_files)
		"""
		# New method:  Zip all files together and scp
		for f in upload_files:
			os.system('zip tempzip.zip {}'.format(f))
		success = os.system('scp tempzip.zip phmaster@dbloader-hgcal.cern.ch:/home/dbspool/spool/hgc/int2r')
		#os.remove('tempzip.zip')
		
		if success==0:
			print("Upload successful")
			self.leStatus.setText("Success!")
		else:
			print("Upload failed!")
			self.leStatus.setText("Error during upload!")
		"""


		# Now upload files in separate thread - will need to wait if multiple files, loader can only handle 1
		x = threading.Thread(target=self.uploadFilesAndSleep, args=(upload_files,))
		x.start()
		print("Starting upload.  Will continue in background.")


		"""
		print("DISPLAYING POP-UP")
		ldlg = LoginDialog(self)
		loginResult = ldlg.exec_()
		if loginResult.isCancelled():
			print("Upload cancelled!")
		elif loginResult == wdgt.QDialog.Accepted:
			print("Upload successful!")
			# MAYBE:  New popup box here!
			# WARNING:  Might be difficult to pass obj info to save to LoginDialog...
			
			for step in xmlStepList:
				step.xmlModifiedReset()

		else:
			print("Upload unsuccessful!")
		"""
	
	def uploadFilesAndSleep(self, flist):
		if len(flist)==0: return

		#lc = LoaderClient()
		success = True
		for f in flist:
			# Note:  .bash_history does NOT store commands run w/ subprocess
			#upload_status = lc.run(iargs=["--login", "--url", "https://cmsdca.cern.ch/hgc_loader/hgc/int2r", f, "--verbose"])
			self.leStatus.setText("Uploading {} ...".format(os.path.basename(f)))
			# scpcmd = "scp -vvv {} {}@dbloader-hgcal.cern.ch:/home/dbspool/spool/hgc/int2r".format(f, self.username)
			scpcmd = "scp -o ProxyJump={}@lxplus.cern.ch {} {}@dbloader-hgcal:/home/dbspool/spool/hgc/int2r/".format(self.username, f, self.username)
			print("Scping {} ...".format(f))
			# result = os.system(scpcmd)

			# pexpect method
			mypassword = self.password
			child = pexpect.spawn(scpcmd)
			password_prompt_index1 = child.expect(['Password: ', pexpect.EOF, pexpect.TIMEOUT])
			
			if password_prompt_index1 == 0:
				
				child.sendline(mypassword)
				password_prompt_index2 = child.expect(['Password: ', pexpect.EOF, pexpect.TIMEOUT])
				if password_prompt_index2 == 0:
					# print("ssh to lxplus successful")
					child.sendline(mypassword)
					exit_status = child.expect([pexpect.EOF, pexpect.TIMEOUT])
					if exit_status == 0:
						print("scp to dbloader successful!")
					else:
						print("scp to dbloader failed!")
				else:
					print("ssh to lxplus failed!")
			else:
				print("Password prompt not found")
			
			# print("scp'ed {} ...".format(f))
			success = success and exit_status == 0
			#success = (upload_status == 200) and success
			if exit_status != 0:
				print("File transfer:  possible error!  Return code {}".format(exit_status))

			if f != flist[-1]:  # if not final:
				# Wait 20s before uploading the next file
				# (If cond files are uploaded before the base file is read into the DB,
				# the DB won't be able to find the part and will throw and error)
				# 20s is a conservative estimate for the worst-case upload duration
				# (It's also really obnoxious w/ multiple passwords and must change ASAP)
				# 2024/3/19 reduce to 15s
				print("Waiting 15s before uploading the next file...")
				time.sleep(15)
		if success:
			self.leStatus.setText("Upload to dbloader success!")
		else:
			self.leStatus.setText("Upload failed!")

		print("Finished uploading files.  See GUI status bar for result.")
	

	def goUploadDate(self):
		lDate = self.dUpload.date()
		dateStr = "{}-{}-{}".format(lDate.month(), lDate.day(), lDate.year())
		print("Uploading files for date", dateStr)
		filemanager_dir = os.sep.join([os.getcwd(), 'filemanager_data'])
		# part_files = glob.glob(filemanager_dir + "/*/{}/*upload*".format(dateStr))
		# step_files = glob.glob(filemanager_dir + "/steps/*/*upload*".format(dateStr))  # no steps xml to upload
		
		
		upload_files = []

		# Upload in order:
		# 1.  Part files
		#     1.1  build
		#     1.2  cond
		parts = ['baseplate', 'sensor', 'pcb']
		for part in parts:
			upload_files += glob.glob(filemanager_dir + "/{}*/{}/*build*upload*".format(part, dateStr))
			upload_files += glob.glob(filemanager_dir + "/{}*/{}/*cond*upload*".format(part, dateStr))
			# 1.3  hexaboard testing files
			if part == 'pcb':
				upload_files += glob.glob(filemanager_dir + "/{}*/{}/*pedestal_test*upload*".format(part, dateStr))
		# 2.  Protomodule files
		#     2.1  build
		#     2.2  cond
		#     2.3  assembly
		upload_files += glob.glob(filemanager_dir + "/protomodule*/{}/*build*upload*".format(dateStr))
		upload_files += glob.glob(filemanager_dir + "/protomodule*/{}/*cond*upload*".format(dateStr))
		upload_files += glob.glob(filemanager_dir + "/protomodule*/{}/*assembly*upload*".format(dateStr))
		# 3.  Module files
		#     3.1  build
		#     3.2  cond
		#     3.3  assembly	
		#     3.4  wirebond
		upload_files += glob.glob(filemanager_dir + "/module*/{}/*build*upload*".format(dateStr))
		upload_files += glob.glob(filemanager_dir + "/module*/{}/*cond*upload*".format(dateStr))
		upload_files += glob.glob(filemanager_dir + "/module*/{}/*assembly*upload*".format(dateStr))
		upload_files += glob.glob(filemanager_dir + "/module*/{}/*wirebond*upload*".format(dateStr))
		#     3.5  testing
		upload_files += glob.glob(filemanager_dir + "/module*/{}/*pedestal_test*upload*".format(dateStr))
		upload_files += glob.glob(filemanager_dir + "/module*/{}/*pedestal_plots*upload*".format(dateStr))
		upload_files += glob.glob(filemanager_dir + "/module*/{}/*iv_test*upload*".format(dateStr))
  
		print("Preparing to upload multiple object files:", upload_files)

		# Now upload files in separate thread - will need to wait if multiple files, loader can only handle 1
		x = threading.Thread(target=self.uploadFilesAndSleep, args=(upload_files,))
		x.start()
		print("Starting upload.  Will continue in background.")
  

  
		'''
  		lc = LoaderClient()
		success = True
		# NOTE:  Writing all errors to upload_errors.log
		sys.stdout = open('upload_errors.log', 'w+')
		for f in part_files + step_files:
			print("UPLOADING", f)
			# removed "--login" arg
			upload_status = lc.run(iargs=["--url", "https://cmsdca.cern.ch/hgc_loader/hgc/int2r", f, "--verbose"])
			success = (upload_status == 200) and success
		sys.stdout.close()
		if success:
			self.leStatus.setText("Success!")
		else:
			self.leStatus.setText("Error during upload!")
		'''


	def uploadStartNow(self, *args, **kwargs):
		localtime = time.localtime()
		self.dUpload.setDate(core.QDate(*localtime[0:3]))

# Class for requesting GUI username at start (for ssh tunnel)
class UserDialog(wdgt.QDialog):
	def __init__(self, *args, **kwargs):
		super(UserDialog, self).__init__(*args, **kwargs)
		print("Initializing request box")

		self.setWindowTitle("SSH: username and password required")
		self.resize(300,150)
		
		self.textName = wdgt.QLineEdit(self)
		self.passName = wdgt.QLineEdit(self)
		self.passName.setEchoMode(wdgt.QLineEdit.Password) # conceal password
  
		self.labelName = wdgt.QLabel('Username:', self)
		self.labelPass = wdgt.QLabel('Password:', self)
		self.buttonLogin = wdgt.QPushButton('Confirm', self)
		self.buttonCancel = wdgt.QPushButton('Cancel', self)
		self.buttonLogin.clicked.connect(self.handleLogin)
		self.buttonCancel.clicked.connect(self.handleCancel)
  
		layout = wdgt.QVBoxLayout(self)
		layout.addWidget(self.labelName)
		layout.addWidget(self.textName)
		layout.addWidget(self.labelPass)
		layout.addWidget(self.passName)
  
		
		# layout = wdgt.QVBoxLayout(self)
		# layout.addWidget(self.textName)
		# layout.addWidget(self.passName)
		layout.addWidget(self.buttonLogin)
		layout.addWidget(self.buttonCancel)

		self.cancelled = False
		print("Initialized request box")

	def handleLogin(self):
		self.username = self.textName.text()
		print("Got username {}".format(self.username))
		self.password = self.passName.text()
		print("Got password!")
		
		if self.username != "" and self.password != "":
			self.accept()
		else:
			self.reject()

	def handleCancel(self):
		print("Login canceled")
		self.username = None
		self.cancelled = True
		self.reject()

	def isCancelled(self):
		return self.cancelled

	def getUsername(self):
		return self.username	

	def getPassword(self):
		return self.password


# Class for DB upload login
class LoginDialog(wdgt.QDialog):

	def __init__(self, *args, **kwargs):
		super(LoginDialog, self).__init__(*args, **kwargs)

		self.setWindowTitle("Provide DB login credentials")
		
		self.textName = wdgt.QLineEdit(self)
		self.textPass = wdgt.QLineEdit(self)
		self.buttonLogin = wdgt.QPushButton('Login', self)
		self.buttonCancel = wdgt.QPushButton('Cancel', self)
		self.buttonLogin.clicked.connect(self.handleLogin)
		self.buttonCancel.clicked.connect(self.handleCancel)
		layout = wdgt.QVBoxLayout(self)
		layout.addWidget(self.textName)
		layout.addWidget(self.textPass)
		layout.addWidget(self.buttonLogin)
		layout.addWidget(self.buttonCancel)

		self.cancelled = False

	def handleLogin(self):
		username = self.textName.text()
		password = self.textPass.text()
		print("Got username {}, password {}".format(username, password))
		print("TEMP:  May need to authenticate in terminal")


	def handleCancel(self):
		print("Login canceled")
		self.cancelled = True
		self.reject()

	def isCancelled(self):
		return self.cancelled



if __name__ == '__main__':
	app = wdgt.QApplication(sys.argv)
	m=mainDesigner()
	m.resize(1366,768)
	m.show()
	sys.exit(app.exec_())