def __init__(self, visitor, darea, obj=None, config=None, key=None):
Generic.__init__(self, self.visitor, obj, config, TYPE_GRAPHIC)
section = self.cfg_fetch_raw(config, key, None)
Graphic.__init__(self, section, rows=64, cols=256)
self.dots = {'x': 6, 'y':8}
self.pixels = {'x':4, 'y':4} # Resolution in crt pixels - scaled
self.border = 5
self.darea = darea
self.darea.connect('expose-event', self.lcd_expose_event, self)
self.bg_color = gtk.gdk.color_parse("#78a878")
self.fg_color = gtk.gdk.color_parse("#113311")
self.config = config
self.rows = 8
self.cols = 256/6
self.lcd_gc = None
if obj == None:
self.name = 'noname'
self.connected = False
self.framebuffer = resizeList([], 256 * 64, list)
self.clear_display()
else:
self.name = obj.name
self.connected = obj.connected
self.framebuffer = obj.framebuffer
self.app = visitor
def selectItem(a):
if messagebox.askyesno('delete', 'delete selected column?'):
if messagebox.showwarning('Sure to delete?',
'deleting selected data'):
curItem = tree.focus()
dict_tree = tree.item(curItem) # dictionary of the tree
values_reqd = dict_tree['values'] # a list of the values
#print(values_reqd)
#print(date_collected)
slno = values_reqd[0]
name = values_reqd[1]
e_mail = values_reqd[2]
flat = values_reqd[3]
tower = values_reqd[4]
area = values_reqd[5]
parking = values_reqd[6]
recpt_fees = values_reqd[7]
addr = values_reqd[8]
contact_no = values_reqd[9]
tmestmp = values_reqd[10]
print("Deleting : ", slno, name, e_mail, flat, tower, area,
parking, recpt_fees, addr, contact_no, tmestmp)
ao.delete_selected(slno, name, e_mail, flat, tower, area,
parking, recpt_fees, addr, contact_no,
tmestmp)
print("deleting selected column!")
if messagebox.askyesno(
'show', 'show changed values? or delete again?'):
GUIfunctions.show()
else:
print("Calling self! delete function again!")
Generic.delete_dummy()
#messagebox.showinfo('Note', 'Open -> Details -> show to see the updated values')
else:
messagebox.showinfo('No', 'Deletion has been cancelled!')
def setJob(job_dict,
isNew=0,
path=__guidePath__,
histoyPath=__historyPath__,
logPath=__logPath__):
try:
Json_evaluation.updateJson(job_dict, __jobFile__, path=path)
if isNew == 1:
for x in job_dict.keys():
Json_evaluation.writeText(
filename=str(x) + ".txt",
path=histoyPath,
data=Generic.prefixTimeStamp("Job Created!!"))
log("Adding " + str(job_dict.keys()) + " Job", path=logPath)
else:
log("Update made on " + str(job_dict.keys()) + " Job",
path=logPath)
for x in job_dict.keys():
History.addJobHistory(filename=str(x + ".txt"),
path=histoyPath,
data=Generic.prefixTimeStamp(
str("Job has been updated!!")))
pass
except Exception as e:
log("Error_Jobs_setJob@" + str(e), path=logPath)
def __init__(self):
Generic.__init__(self)
def _get_model():
r = re.compile('^.*brand-string.*\n\s+value=(.+)$', re.M)
m = r.findall( self._read_cpuinfo() )
return m[0]
def _get_cache():
r = re.compile('^.*l2-cache-size.*\n\s+value=(.+)$', re.M)
m = r.findall( self._read_cpuinfo())
m_int = int(m[0],16)
return int(round(m_int/1000))
def _read_cpu_speed():
r = re.compile('^.*cpu-mhz.*\n\s+value=(.+)$', re.M)
m = r.findall(self._read_cpuinfo())
return float(int(m[0],16))
# CPU model and cache size never changes
self.__model_name = _get_model()
self.__cache_size = _get_cache()
# the cpu speed might change (laptops have mobile CPUs)
self.__speed = _read_cpu_speed()
def __init__(self):
Generic.__init__(self)
def _get_model():
r = re.compile('brand\s+(.+)$', re.M)
m = r.findall( self._read_cpuinfo() )
return m[0]
def _get_cache():
r = re.compile('^\s+ecache-size:+\s+(.+)$',re.M)
m = r.findall(os.popen('/usr/sbin/prtconf -vp').read())
m_int = int(m[0],16)
return int(round(m_int/1000))
def _read_cpu_speed():
r = re.compile('clock_MHz\s+(\d+)$', re.M)
m = r.findall(self._read_cpuinfo())
return float(int(m[0]))
# CPU model and cache size never changes
self.__model_name = _get_model()
self.__cache_size = _get_cache()
# the cpu speed might change (laptops have mobile CPUs)
self.__speed = _read_cpu_speed()
def __init__(self,index=0):
"""
@param index: the camera index to use (start from 0)
"""
Generic.__init__(self)
serial_numbers = self.get_serial_numbers()
self.__serial_number = sn = serial_numbers[index]
print "PixeLINK camera sn = ",sn
# initialize the camera
self.initialize()
self.__get_features_desc()
# init ROI
self.__roi = map(int,self.get_feature('roi').parms)
self.__update_frame_buffer()
self.stop()
def __init__(self):
Generic.__init__(self)
def _get_model():
r = re.compile('^cpu\s+:\s+(\w+)$', re.M)
m = r.search( self._read_cpuinfo() )
return m.group(1)
# CPU model and cache size never changes
self.__model_name = _get_model()
self.__cache_size = _get_cache()
# the cpu speed might change (laptops have mobile CPUs)
self.__speed = re.compile('^Cpu0ClkTck\s+:\s+(\w+)$', re.M)
self.__bogo = re.compile('^Cpu0Bogo\s+:\s+(\d+\.\d+)$', re.M)
def callApi(
filePath=__storagePath__,
filename="",
url="http://sussociety.cc:8080/bower_components/images/banner.jpg"
):
try:
extn = ""
_filename = ""
extn = (url[-5:].split('.')[1])
if filename == "":
_filename = str(url[-10:].split('.')[0])
_filename = _filename.replace('/', '_')
#print(_filename)
else:
_filename = filename
if extn is None or extn == "":
return "Http path is not valid!!"
#print(filePath+"/"+_filename+"."+extn)
_filename = Generic.prefixTimeStamp(_filename, "_")
_filename = _filename.replace(' ', '_').replace(':', '.')
fileContent = urllib.request.urlopen(url)
with open(filePath + "/" + _filename + "." + extn, 'wb') as output:
output.write(fileContent.read())
return str(filePath + "/" + _filename + "." + extn)
except Exception as e:
log("Error_Url_callApi@" + str(e))
return "-1"
def getFileFromRemote(remote_dict,remoteFilePath,filename):
try:
ssh=Sync.sshCall(remote_dict)
ftp_client=ssh.open_sftp()
try:
ftp_client.get(remoteFilePath,Generic.getCurrentPath()+pathConnector+__storagePath__+pathConnector+filename)
#ftp_client.mkdir(__installationDirName__)
return str(Generic.getCurrentPath()+pathConnector+__storagePath__+pathConnector+filename)
except (IOError,Exception) as e:
log("Error_Sync_getFileFromRemote_CmdError@"+str(e))
except (Exception,paramiko.SSHException,paramiko.AuthenticationException,paramiko.BadHostKeyException,socket.error) as e:
log("Error_Sync_remoteName@"+str(e))
return -1
def getActiveJobs(path=__guidePath__):
try:
data = Job.evaluateJob(path)
#print(data)
curDate = Generic.strToDate(Generic.getDate())
activeJobs = {}
for key in data.keys():
if Generic.strToDate(data[key]["startDate"]
) <= curDate and Generic.strToDate(
data[key]["endDate"]) >= curDate and (
data[key]["isActive"] == 1
or data[key]["isActive"] == "on"):
activeJobs[key] = data[key]
return activeJobs
except Exception as e:
log("Error_Jobs_isJobEligibleToRun@" + str(e))
return 0
def __init__ ( self, visitor, obj=None, config=None, key=None):
Generic.__init__(self, visitor, obj, config, TYPE_GRAPHIC)
section = self.cfg_fetch_raw(config, key, None)
Graphic.__init__(self, section, rows=SCREEN_H, cols=SCREEN_W)
self.rows = SCREEN_H / 8
self.cols = SCREEN_W / 6
self.CHARS = self.rows * self.cols
self.CHAR0 = 0
self.chars = []
if obj == None:
self.contrast = 127
self.backlight = 100
self.command_queue = Queue.Queue()
self.command_rate = 1
self.layout_timeout = 0
self.name = 'noname'
self.connected = False
else:
self.contrast = obj.contrast
self.backlight = obj.backlight
self.command_queue = obj.command_queue0
self.layout_timeout = obj.layout_timeout
self.command_rate = obj.command_rate
self.name = obj.name
self.connected = obj.connected
self.app = visitor
self.debug = visitor.debug
self.AddFunction("LCD::contrast", 1, self.my_contrast)
self.AddFunction("LCD::backlight", 1, self.my_backlight)
self.AddFunction("LCD::gpo", 2, self.my_gpo)
self.command_id = None
#self.device_poll_thread = threading.Thread(target=self.device_poll)
self.framebuffer = resizeList([], 256 * 64, bool)
self.inverted = 0
self.command_time = time.time()
self.graphic_real_blit = self.drv_blit
#self.graphic_clear = self.drv_clear
self.drv_locked = False
self.libhandle = OPENUSB_HANDLE()
self.usbhandle = OPENUSB_DEV_HANDLE()
self.request_handle = (OPENUSB_REQUEST_HANDLE * 1)()
self.rq_handle_references = []
def __init__(self, model, visitor, obj=None, config=None): self.model = model Generic.__init__(self, visitor, obj, config) GenericSerial.__init__(self, visitor, obj, config) Text.__init__(self, rows=model.rows, cols=model.cols, yres=8, xres=6, goto=model.goto, chars=model.chars, char0=model.char0) if obj is None: self.port = '' self.baud = 19200 self.command_rate = .0165 self.layout_timeout = 0 else: self.port = obj.port self.baud = obj.baud self.command_rate = obj.command_rate self.layout_timeout = obj.layout_timeout self.command_thread = ThreadedTask(self.command_worker, None, 1) self.command_queue = Queue.Queue() self.command_time = time.time()
def isJobEligibleToRun(interval, curDate, curTime, lastRunDateTime):
try:
return 1 #Disabled this function in version 3.0!!
if lastRunDateTime == "-1":
return 1
if interval < 0:
#print(Generic.strToTime(Generic.addTime(Generic.strToTime(lastRunDateTime),(-1*interval))))
if Generic.strToTime(
Generic.addTime(Generic.strToTime(lastRunDateTime),
(-1 * interval))) >= curTime:
return 1
elif Generic.addDate(Generic.strToDate(lastRunDateTime),
interval) >= curDate and interval > 0:
return 1
else:
return 0
except Exception as e:
log("Error_Jobs_isJobEligibleToRun@" + str(e))
return 0
def sendEmail(step_data):
#context = ssl.create_default_context()
# Try to log in to server and send email
try:
data = Json_evaluation.getJsonByKey(
filename=__emailFile__, key=step_data["emailProfilerName"])
#print(step_data[data["attachmentFilePath"]])
server = smtplib.SMTP(data["emailServer"], int(data["emailPort"]),
None, 30)
#import traceback
#traceback.print_exc()
msg = MIMEMultipart()
msg['From'] = data["emailUser"]
msg['To'] = step_data["receiver_emails"]
msg['Subject'] = "Willdo-Automated generated email!!"
body = str(step_data["emailMsg"])
msg.attach(MIMEText(body, 'html'))
attachment = ""
#for attachPath in Generic.removeLastSperator(step_data["attachmentFilePath"]).split('|'):
attachPath = step_data["attachmentFilePath"]
part = MIMEBase('application', 'octet-stream')
try:
attachment = open(attachPath, "rb")
except Exception as ee:
log("Attachment block" + str(ee))
if attachment != "":
#print(attachPath)
part.set_payload(attachment.read())
attachment.close()
part.add_header(
'Content-Disposition', "attachment; filename= %s" %
Generic.getFileNameFromPath(attachPath))
encoders.encode_base64(part)
msg.attach(part)
text = msg.as_string()
server.ehlo() # Can be omitted
server.starttls() # Secure the connection
server.ehlo() # Can be omitted
server.login(data["emailUser"], data["emailPassword"])
server.sendmail(data["emailUser"],
str(step_data["receiver_emails"]).split(','), text)
except smtplib.SMTPException as e:
log("Error_Email_sendEmail@SMTPException_" +
str(e)) # Didn't make an instance.
except smtplib.socket.error:
log("Error_Email_sendEmail@Socket_" + str(e))
finally:
server.quit()
def __init__(self):
Generic.__init__(self)
def _get_model():
r = re.compile('^model name\s+:\s+(.+)$', re.M)
m = r.search( self._read_cpuinfo() )
return m.group(1)
def _get_cache():
r = re.compile('^cache size\s+:\s+(\d+)\sKB$', re.M)
m = r.search( self._read_cpuinfo() )
return int(m.group(1))
# CPU model and cache size never changes
self.__model_name = _get_model()
self.__cache_size = _get_cache()
# the cpu speed might change (laptops have mobile CPUs)
self.__speed = re.compile('^cpu MHz\s+:\s+(\d+\.\d+)$', re.M)
def __init__ ( self, visitor, obj=None, config=None, key=None):
Generic.__init__(self, visitor, obj, config, DRV_GRAPHIC)
section = self.cfg_fetch_raw(config, key, None)
Graphic.__init__(self, section, rows=SCREEN_H, cols=SCREEN_W)
self.rows = SCREEN_H / 8
self.cols = SCREEN_W / 6
self.CHARS = self.rows * self.cols
self.CHAR0 = 0
self.chars = []
if obj == None:
self.contrast = 127
self.backlight = 100
self.command_queue = Queue.Queue()
self.command_rate = 1
self.layout_timeout = 0
self.name = 'noname'
self.connected = False
else:
self.contrast = obj.contrast
self.backlight = obj.backlight
self.command_queue = obj.command_queue0
self.layout_timeout = obj.layout_timeout
self.command_rate = obj.command_rate
self.name = obj.name
self.connected = obj.connected
self.app = visitor
self.debug = visitor.debug
self.AddFunction("LCD::contrast", 1, self.my_contrast)
self.AddFunction("LCD::backlight", 1, self.my_backlight)
self.AddFunction("LCD::gpo", 2, self.my_gpo)
self.command_id = None
self.device_poll_thread = threading.Thread(target=self.device_poll)
self.framebuffer = resizeList([], 256 * 64, bool)
lib.libusb_init(None)
self.transfer = lib.libusb_alloc_transfer(0)
self.handle = lib.libusb_open_device_with_vid_pid(None, VENDOR_ID, PRODUCT_ID)
self.inverted = 0
self.command_time = time.time()
self.graphic_real_blit = self.drv_blit
#self.graphic_clear = self.drv_clear
self.drv_locked = False
def lastRunUpdate(jobName):
try:
data = Json_evaluation.getJsonByKey(filename=__jobFile__,
key=jobName)
data = Job.updateNextRun(data)
data["lastRunDate"] = Generic.getDate()
n_data = {}
n_data[jobName] = data #Next scheduled time update
Json_evaluation.updateJson(dict=n_data, filename=__jobFile__)
log("Job " + jobName + " last Run Updated!!")
except Exception as e:
log("Error_Jobs_lastRunUpdate@" + str(e))
def remoteSyncCall(remote_dict):
try:
remotePathConnector=Generic.getRemotePathConnector(remote_dict)
ssh=Sync.sshCall(remote_dict)
ftp_client=ssh.open_sftp()
try:
stdin, stdout, stderr = ssh.exec_command("rm -r "+__installationDirName__+remotePathConnector+__guidePath__)
#ftp_client.get(__installationDirName__+pathConnector+__logPath__+pathConnector+__logFile__,"log.txt")
#ftp_client.mkdir(__installationDirName__)
except IOError as e:
log("Error_Sync_Dir_already exists@"+str(e))
thisdir = os.getcwd()
dir_list=None
for r, d, f in os.walk(thisdir):
#for file in f:
#if ".docx" in file:
# print(os.path.join(r, file))
if dir_list is None:
dir_list=d
for dir in d:
try:
if dir=="scheduler_guide":
ftp_client.mkdir(__installationDirName__+remotePathConnector+dir)
log(__installationDirName__+remotePathConnector+dir+" is created")
except IOError as e:
log("Error_Sync_Dir_already exists@"+str(e))
for file in f:
#if ".docx" in file:
r_dir=r.split(pathConnector)
r_dir=r_dir[len(r_dir)-1]
log(r_dir)
#if r_dir in dir_list:
if r_dir=="scheduler_guide":
try:
ftp_client.put(str(os.path.join(r, file)),__installationDirName__+remotePathConnector+r_dir+remotePathConnector+file)
log(__installationDirName__+remotePathConnector+r_dir+remotePathConnector+file+" is created")
except IOError as e:
log("Error_Sync_File_already exists@"+str(e))
#print(str(os.path.join(r, file))+"-----------"+r_dir+" "+__installationDirName__+pathConnector+file)
#ftp_client.put(os.path.join(r, file),"/var/www/pp.png")
#ftp_client.put("/home/worldwiki/Desktop/willDO/FileStorage/2019-04-30_14.31.49.434702_2x92dp.png","/var/www/pp.png")
#stdin, stdout, stderr = ssh.exec_command(__installationDirName__+"/setup.sh")
#print ("stderr: "+stderr.readlines())
#print ("pwd: "+stdout.readlines())
ftp_client.close()
return 1
except (Exception,paramiko.SSHException,paramiko.AuthenticationException,paramiko.BadHostKeyException,socket.error) as e:
log("Error_Sync_remoteSyncCall@"+str(e))
return -1
def setSchedulerTimeStap():
try:
dateTime = Generic.currentTimestamp()
Json_evaluation.updateJson(
{
"schedulerTimeStamp": str(dateTime),
"schedulerStatus": "ON"
},
filename=__schedulerTimeStampFile__)
log("Scheduler Restarted at " + str(dateTime))
except Exception as e:
log("Error_setSchedulerTimeStap" + str(e))
def prepareJobQueue():
try:
todayList = {}
data = Job.evaluateJob()
#print(data)
curDate = Generic.strToDate(Generic.getDate())
curTime = Generic.strToTime(Generic.getTime())
#print(curTime)
for key in data.keys():
timeKeyword = ""
lastRunDate = data[key]["lastRunDate"]
if data[key]["lastRunDate"] == "-1":
timeKeyword = "scheuledTime"
else:
timeKeyword = "nextRunTime"
if Generic.strToDate(
data[key]
["startDate"]) <= curDate and Generic.strToDate(
data[key]["endDate"]) >= curDate and (
data[key]["isActive"] == 1
or data[key]["isActive"] == "on") and (
lastRunDate == "-1" or Job.isJobEligibleToRun(
int(data[key]["interval"]), curDate,
curTime, data[key][timeKeyword])
== 1) and Generic.strToTime(
data[key][timeKeyword]) >= curTime:
todayList[key] = {
"scheduledTime":
data[key][timeKeyword],
"remainingSec":
Generic.timeDiff(Generic.getTime(),
data[key][timeKeyword]),
"nextRunDate":
"-" if timeKeyword == "scheuledTime" else
data[key]['nextRunDate'],
"nextRunTime":
"-" if timeKeyword == "scheuledTime" else
data[key]['nextRunTime']
}
#print(todayList)
Json_evaluation.writeJSON(data=todayList, filename=__jobQueue__)
log("Job Queue Prepared....")
except Exception as e:
log("Error_Jobs_prepareJobQueue@" + str(e))
def post_upgrade(self):
primary = getkey(self.arguments, 'primary')
if not primary == '':
G.info(''.join(['Creating a dummy object of type ', primary]))
obj = Generic(
self.globalvars,
[''.join([primary,':'])] + self.lines[1:]
)
obj.setup()
G.debug('\n'.join(['DUMPING DUMMY OBJECT', obj.dump()]))
else:
G.critical(''.join('Missing argument: primary'))
self.removed = True # This object's purpose is done
def __init__(self,parent, id=wx.ID_ANY, pos=wx.DefaultPosition, size=wx.DefaultSize ):
Generic.__init__(self, parent, id, pos, size,"data/icons/photo.png", Priority=1000)
self.rightSizer = wx.BoxSizer(wx.VERTICAL)
self.ObjectName = wx.StaticText(self)
self.rightSizer.Add(self.ObjectName,0, wx.ALIGN_TOP | wx.ALIGN_LEFT)
g = wx.FlexGridSizer(2,4,3,3)
s1 = wx.StaticText(self,-1,"X")
self.x = wx.SpinCtrl(self,-1,'1', style= wx.SP_ARROW_KEYS | wx.SP_WRAP)
s2 = wx.StaticText(self,-1,"Y")
self.y = wx.SpinCtrl(self,-1,'1', style= wx.SP_ARROW_KEYS | wx.SP_WRAP)
s3 = wx.StaticText(self,-1,"W")
self.w = wx.SpinCtrl(self,-1,'1', style= wx.SP_ARROW_KEYS | wx.SP_WRAP)
s4 = wx.StaticText(self,-1,"H")
self.h = wx.SpinCtrl(self,-1,'1', style= wx.SP_ARROW_KEYS | wx.SP_WRAP)
g.Add(s1)
g.Add(self.x)
g.Add(s2)
g.Add(self.y)
g.Add(s3)
g.Add(self.w)
g.Add(s4)
g.Add(self.h)
self.mainSizer.Add(self.rightSizer, 0)
self.rightSizer.Add(g)
self.mainSizer.SetSizeHints(self)
def __init__(self, darea, rows=4, cols=20, config=None):
file = open('cfa635_fonts.dat', 'r')
self.lcd_fonts = pickle.load(file)
file.close()
self.ch_data = []
self.fontP = None
self.interface = None
self.current_state = None
self.previous_state = None
self.mode_flag = 0
self.data_latch = None
self.data_latch_phase = None
self.debug = False
self.cursor = {'row':0, 'col':0}
self.lcd_gc = None
self.rows = rows
self.cols = cols
self.dots = {'x':6, 'y':8} # Resolution in lcd pixels. e.g. 5x7
self.pixels = {'x':4, 'y':4} # Resolution in crt pixels - scaled
self.contrast = None
self.dot_color = None
self.title = None
self.window = None
self.darea = None
self.w_width = None
self.w_height = None
self.disp_type = 0
self.border = 5
self.darea = darea
self.darea.connect('expose-event', self.lcd_expose_event, self)
self.darea.connect('button-press-event', self.cursor_event)
self.bg_color = gtk.gdk.color_parse("#78a878")
self.fg_color = gtk.gdk.color_parse("#113311")
self.config = config
Generic.__init__(self, None, config)
Text.__init__(self, rows=rows, cols=cols, yres=8, xres=6, goto=0, chars=8, char0=0)
def __init__ ( self, visitor, obj=None, config=None):
Generic.__init__(self, visitor, obj, config)
GenericSerial.__init__(self, visitor, obj, config)
Text.__init__(self, rows=4, cols=20, yres=8, xres=5, goto=2, chars=8, char0=0)
if obj == None:
self.name = 'noname'
self.port = ''
self.baud = 19200
self.layout_timeout = 0 #Default layout timeout. 0 = no transitions. Override at layout level.
self.layouts = {}
self.write_rate = .0165
else:
self.name = obj.name
self.port = obj.port
self.baud = obj.baud
self.layout_timeout = obj.layout_timeout
self.layouts = obj.layouts
self.write_rate = obj.write_rate
self.app = visitor
self.debug = visitor.debug
self.AddFunction("backlight", 0, self.my_backlight)
self.write_thread = threading.Thread(target=self.write_worker)
self.write_active = False
self.write_queue = Queue.Queue()
def getNearestJob(): #Disabled in v3.0
try:
data = Json_evaluation.readJSON(filename=__jobQueue__)
#print(data)
jobCache = ""
curDate = Generic.strToDate(Generic.getDate())
lesserTime = -1
for key in data.keys():
if lesserTime == -1 and Generic.strToTime(
data[key]["scheduledTime"]) >= Generic.strToTime(
Generic.getTime()):
lesserTime = data[key]["remainingSec"]
jobCache = key
if lesserTime > int(
data[key]["remainingSec"]) and Generic.strToTime(
data[key]["scheduledTime"]) >= Generic.strToTime(
Generic.getTime()):
lesserTime = data[key]["remainingSec"]
jobCache = key
return jobCache
except Exception as e:
log("Error_Jobs_getNearestJob@" + str(e))
def __init__ ( self, visitor, obj=None, config=None):
Generic.__init__(self, visitor, obj, config)
GenericSerial.__init__(self, visitor, obj, config)
Text.__init__(self, rows=self.model.rows, cols=self.model.cols, yres=8, xres=6, goto=self.model.goto, chars=self.model.chars, char0=self.model.char0)
self.commands_sent = 0
self.commands_received = 0
self.commands_resent = 0
self.tossed = 0
self.errors = 0
self.packet = Packet()
self.fill_buffer_thread = ThreadedTask(self.fill_buffer, None, 1)
self.check_thread = ThreadedTask(self.check_for_packet, None, 1)
self.buffer = BufferedReader()
if obj == None:
self.port = ''
self.baud = 115200
self.display_name = ''
self.device_name = ''
self.serial_number = ''
self.path = ''
self.device_version = ""
self.hardware_version = ""
self.firmware_version = ""
self.fans = []
self.current_command = [-1, -1]
for i in range(0, 4):
self.fans.append(Fan())
self.dallas = []
self.contrast = 127
self.backlight = 100
self.memory = ReadLCDMemory(self)
self.command_queue0 = Queue.Queue()
self.command_queue1 = Queue.Queue()
self.response_bin = Bin(self)
self.response = None
self.response_state = 0
self.response_time_init = time.time()
self.command_limit = 0 # 0 means 1 command every <command_rate> interval. 1 means 2 commands.
self.command_rate = 1
self.response_timeout = 0.25
self.active = False
self.layout_timeout = 0 #Default layout timeout. 0 = no transitions. Override at layout level.
self.layouts = {}
self.name = 'noname'
else:
self.name = obj.name
self.port = obj.port
self.baud = obj.baud
self.display_name = obj.display_name
self.device_name = obj.device_name
self.serial_number = obj.serial_number
self.path = obj.path
self.device_version = obj.device_version
self.hardware_version = obj.hardware_version
self.firmware_version = obj.firmware_version
self.books = obj.books
self.fans = obj.fans
self.current_command = obj.current_command
self.command_limit = obj.command_limit
self.dallas = obj.dallas
self.contrast = obj.contrast
self.backlight = obj.backlight
self.memory = ReadLCDMemory(self)
self.command_queue0 = obj.command_queue0
self.command_queue1 = obj.command_queue1
self.response_bin = Bin(self)
self.response = obj.response
self.response_state = obj.response_state
self.response_time_init = obj.response_time_init
self.command_rate = obj.command_rate
self.response_timeout = obj.response_timeout
self.active = obj.active
self.layout_timeout = obj.layout_timeout
self.layouts = obj.layouts
self.app = visitor
self.debug = visitor.debug
self.waiting = False
self.AddFunction("contrast", 0, self.my_contrast)
self.AddFunction("backlight", 0, self.my_backlight)
self.connect('packet-ready', self.response_bin.process_packet)
self.command_thread = ThreadedTask(self.command_worker, None, self.command_rate)
self.crcLookupTable = array ('H', # Define the CRC lookup table
[0x00000,0x01189,0x02312,0x0329B,0x04624,0x057AD,0x06536,0x074BF,
0x08C48,0x09DC1,0x0AF5A,0x0BED3,0x0CA6C,0x0DBE5,0x0E97E,0x0F8F7,
0x01081,0x00108,0x03393,0x0221A,0x056A5,0x0472C,0x075B7,0x0643E,
0x09CC9,0x08D40,0x0BFDB,0x0AE52,0x0DAED,0x0CB64,0x0F9FF,0x0E876,
0x02102,0x0308B,0x00210,0x01399,0x06726,0x076AF,0x04434,0x055BD,
0x0AD4A,0x0BCC3,0x08E58,0x09FD1,0x0EB6E,0x0FAE7,0x0C87C,0x0D9F5,
0x03183,0x0200A,0x01291,0x00318,0x077A7,0x0662E,0x054B5,0x0453C,
0x0BDCB,0x0AC42,0x09ED9,0x08F50,0x0FBEF,0x0EA66,0x0D8FD,0x0C974,
0x04204,0x0538D,0x06116,0x0709F,0x00420,0x015A9,0x02732,0x036BB,
0x0CE4C,0x0DFC5,0x0ED5E,0x0FCD7,0x08868,0x099E1,0x0AB7A,0x0BAF3,
0x05285,0x0430C,0x07197,0x0601E,0x014A1,0x00528,0x037B3,0x0263A,
0x0DECD,0x0CF44,0x0FDDF,0x0EC56,0x098E9,0x08960,0x0BBFB,0x0AA72,
0x06306,0x0728F,0x04014,0x0519D,0x02522,0x034AB,0x00630,0x017B9,
0x0EF4E,0x0FEC7,0x0CC5C,0x0DDD5,0x0A96A,0x0B8E3,0x08A78,0x09BF1,
0x07387,0x0620E,0x05095,0x0411C,0x035A3,0x0242A,0x016B1,0x00738,
0x0FFCF,0x0EE46,0x0DCDD,0x0CD54,0x0B9EB,0x0A862,0x09AF9,0x08B70,
0x08408,0x09581,0x0A71A,0x0B693,0x0C22C,0x0D3A5,0x0E13E,0x0F0B7,
0x00840,0x019C9,0x02B52,0x03ADB,0x04E64,0x05FED,0x06D76,0x07CFF,
0x09489,0x08500,0x0B79B,0x0A612,0x0D2AD,0x0C324,0x0F1BF,0x0E036,
0x018C1,0x00948,0x03BD3,0x02A5A,0x05EE5,0x04F6C,0x07DF7,0x06C7E,
0x0A50A,0x0B483,0x08618,0x09791,0x0E32E,0x0F2A7,0x0C03C,0x0D1B5,
0x02942,0x038CB,0x00A50,0x01BD9,0x06F66,0x07EEF,0x04C74,0x05DFD,
0x0B58B,0x0A402,0x09699,0x08710,0x0F3AF,0x0E226,0x0D0BD,0x0C134,
0x039C3,0x0284A,0x01AD1,0x00B58,0x07FE7,0x06E6E,0x05CF5,0x04D7C,
0x0C60C,0x0D785,0x0E51E,0x0F497,0x08028,0x091A1,0x0A33A,0x0B2B3,
0x04A44,0x05BCD,0x06956,0x078DF,0x00C60,0x01DE9,0x02F72,0x03EFB,
0x0D68D,0x0C704,0x0F59F,0x0E416,0x090A9,0x08120,0x0B3BB,0x0A232,
0x05AC5,0x04B4C,0x079D7,0x0685E,0x01CE1,0x00D68,0x03FF3,0x02E7A,
0x0E70E,0x0F687,0x0C41C,0x0D595,0x0A12A,0x0B0A3,0x08238,0x093B1,
0x06B46,0x07ACF,0x04854,0x059DD,0x02D62,0x03CEB,0x00E70,0x01FF9,
0x0F78F,0x0E606,0x0D49D,0x0C514,0x0B1AB,0x0A022,0x092B9,0x08330,
0x07BC7,0x06A4E,0x058D5,0x0495C,0x03DE3,0x02C6A,0x01EF1,0x00F78])
def __init__(self, data, param):
Generic.__init__(self, data, param)
def __init__(self, data, param):
Generic.__init__(self, data, param)
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.width = kwargs["width"]
self.rollover_value = kwargs["rollover_thresh"]
assert (2**self.width >= self.rollover_value)
if "reset_val" in kwargs:
default_reset = kwargs["reset_val"]
else:
default_reset = 0
if "init_val" in kwargs:
default_init = kwargs["init_val"]
else:
default_init = 0
if "rollover_thresh" in kwargs:
default_rollover = kwargs["rollover_thresh"]
else:
default_rollover = all_ones_binary(self.width)
if "direction" in kwargs:
self.direction = kwargs["direction"]
assert (self.direction == "up" or self.direction == "down")
else:
self.direction = "up"
if "use_clock_en" in kwargs:
self.use_clock_en = kwargs["use_clock_en"]
assert (isinstance(self.use_clock_en, bool))
else:
self.use_clock_en = True
if "delta" in kwargs:
default_delta = kwargs["delta"]
assert (default_delta >= 1)
assert (2**self.width > default_delta)
else:
default_delta = 1
self.clk = kwargs["clk"]
self.rst = kwargs["rst"]
self.children.append(kwargs["clk"])
self.children.append(kwargs["rst"])
# Choose the value the counter goes to when device is reset:
reset_val = Generic(name=rst_name(self.name),
width=kwargs["width"],
kind="std_ulogic",
default=default_reset,
central_name_gen=self.central_name_gen)
# Choose the value the counter goes to after it rolls over:
init_val = Generic(name=init_name(self.name),
width=kwargs["width"],
kind="std_ulogic",
default=default_init,
central_name_gen=self.central_name_gen)
rollover_threshold = Generic(name=rollover_name(self.name),
width=kwargs["width"],
target_lang="vhdl",
kind="std_ulogic",
default=default_rollover,
central_name_gen=self.central_name_gen)
delta_obj = Generic(name=delta_name(self.name),
width=kwargs["width"],
target_lang="vhdl",
kind="std_ulogic",
default=default_delta,
central_name_gen=self.central_name_gen)
count_sig = Signal(name=self.name + "_counter",
width=kwargs["width"],
target_lang="vhdl",
expression="",
central_name_gen=self.central_name_gen)
self.children.append(reset_val)
self.children.append(init_val)
self.children.append(rollover_threshold)
self.children.append(count_sig)
self.children.append(delta_obj)
self.reset_val = reset_val
self.init_val = init_val
self.rollover_threshold = rollover_threshold
self.count_sig = count_sig
self.delta = delta_obj
def update_rows(tuple_rows):
def get_rows():
i_sl_no = data_col[1]
i_name = e[1].get()
i_e_mail = e[2].get()
i_flat = e[3].get()
i_tower = e[4].get()
i_area = e[5].get()
i_parking = e[6].get()
i_recpt_fees = e[7].get()
i_addr = e[8].get()
i_contact_no = e[9].get()
i_tmstmp = data_col[11]
#print(i_sl_no," ",i_name," ", i_e_mail," ", i_flat," ", i_tower," ", i_area," ", i_parking," ", i_recpt_fees," ", i_addr," ", i_contact_no," ",i_tmstmp)
ao.updateData(i_sl_no, i_name, i_e_mail, i_flat, i_tower, i_area,
i_parking, i_recpt_fees, i_addr, i_contact_no,
i_tmstmp)
def data_updated_sucessfully():
row_no = 0
parent3 = Tk()
row = Frame(parent3)
parent3.title("FLAT-INVENTORY JIMSOFT ( UPDATED ? )")
parent3.geometry("500x50+200+200")
#global data_valid
text = "Data updated sucessfully"
tk.Label(parent3,
justify=tk.LEFT,
padx=10,
pady=10,
text=text,
font=font.Font(family='Helvetica', size=12,
weight='bold')).grid(row=row_no,
column=1,
sticky=W,
pady=4)
data_valid = 0 # everytime it is set to 0, on clscreen
row_no = 1 # row number
parent6 = Tk()
parent6.title("FLAT-INVENTORY JIMSOFT (UPDATE ROWS MODE)")
parent6.geometry("800x800+200+200")
data_col = [""]
for data in tuple_rows:
data_col.append(data)
print(data_col)
for data, num in info:
#print(data,"\t",num)
tk.Label(parent6,
justify=tk.LEFT,
padx=10,
pady=10,
text=data,
font=font.Font(family='Helvetica', size=20,
weight='bold')).grid(row=row_no,
column=1,
sticky=W,
pady=4)
e[num] = tk.Entry(parent6, width=100)
e[num].insert(END, data_col[num + 1]) # to insert an existing data
#print("####",e[num])
e[num].grid(row=row_no, column=2, sticky=W, pady=4)
row_no = row_no + 2
Button(parent6,
justify=tk.LEFT,
padx=10,
pady=10,
text='update data',
command=Generic.combine_funcs(
get_rows, data_updated_sucessfully)).grid(row=20,
column=1,
sticky=W,
pady=4)
Button(parent6,
justify=tk.LEFT,
padx=10,
pady=10,
text='show',
command=GUIfunctions.update).grid(row=20,
column=2,
sticky=W,
pady=4)
from Json_evaluation import Json_evaluation,log
from include.Variable import __syncFile__,__schedulerTimeStampFile__,__webServerStopCmd__,__webServerSeachCmd__,__webServerStartCmd__,__webServerStartFile__,__installationDirName__,__linuxInstallationPath__,__guidePath__,__logPath__,__storagePath__,__logFile__,__schedulerSeachCmd__,__schedulerStopCmd__,__schedulerStartCmd__,__schedulerServiceName__,__uninstallRemoteCmd__
from paramiko import SSHClient
import paramiko,socket
from Generic import Generic
import os
#from scp import SCPClient
pathConnector=Generic.getPathConnector()
class Sync:
def addSync(sync_dict):
try:
Json_evaluation.updateJson(dict=sync_dict,filename=__syncFile__)
log("Adding "+str(sync_dict.keys())+" Parameter ")
pass
except Exception as e:
log("Error_Sync_addSync@"+str(e))
def sshCall(remote_dict,logPath=__logPath__):
try:
log("SSH Connecting.....",path=logPath)
ssh = SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
try:
success=ssh.connect(hostname=remote_dict["ip"],port=int(remote_dict["syncPort"]),username=remote_dict["syncUser"], password=remote_dict["syncPassword"],timeout=20)
if success==True:
log("SSH connected",path=logPath)
except paramiko.AuthenticationException as e:
log("Error_Sync_AuthenticationException@"+str(e),path=logPath)
#print("connected")
return ssh
def updateNextRun(jobData):
try:
interval = int(jobData["interval"])
if jobData["lastRunDate"] == "-1":
if interval < 0:
jobData["nextRunTime"] = Generic.addTime(
Generic.strToTime(jobData["scheuledTime"]),
(-1 * interval))
#print(jobData["nextRunTime"])
jobData["nextRunDate"] = Generic.getDate()
else:
jobData["nextRunTime"] = jobData["scheuledTime"]
jobData["nextRunDate"] = Generic.dateToStr(
Generic.addDate(Generic.strToDate(Generic.getDate()),
interval))
else:
if interval < 0:
jobData["nextRunTime"] = Generic.addTime(
Generic.strToTime(jobData["nextRunTime"]),
(-1 * interval))
#print(jobData["nextRunTime"])
jobData["nextRunDate"] = Generic.getDate()
else:
jobData["nextRunTime"] = jobData["scheuledTime"]
jobData["nextRunDate"] = Generic.dateToStr(
Generic.addDate(
Generic.strToDate(jobData["nextRunDate"]),
interval))
return jobData
except Exception as e:
log("Error_Jobs_updateNextRun@" + str(e))
def create_instance(c_instance):
' Creates and returns the APC20 script '
return Generic(c_instance)
