def main():
t1 = task("http://www.laurentluce.com/posts/python-threads-synchronization-locks-rlocks-semaphores-conditions-events-and-queues/")
t2 = task("http://stackoverflow.com/questions/15651128/in-this-semaphore-example-is-it-necessary-to-lock-for-refill-and-buy")
t3 = task("http://bbs.byr.cn/")
event = Event()
tasks = TaskQueue(event)
pages = TaskQueue(None)
tasks.add(t1)
tasks.add(t2)
tasks.add(t3)
taskLock = BoundedSemaphore(tasks.numOfNewTasks)
pageLock = BoundedSemaphore(1)
f = open("test.txt",'w')
Connector0 = Connector(tasks,taskLock,pages,pageLock,event,'',f, 3000)
Connector1 = Connector(tasks,taskLock,pages,pageLock,event,'',f, 3001)
Connector0.start()
Connector1.start()
Crawler0 = Crawler('',3000)
Crawler1 = Crawler('',3001)
Crawler0.start()
Crawler1.start()
Connector1.join()
Connector0.join()
Crawler0.join()
Crawler1.join()
f.close()
def __init__(self):
self.tasks = []
self.server = "http://localhost:8888"
self.getTaskUrl = "/api/getTask/"
self.c = Connector()
self.data = ""
self.receipt_done = dict()
class MyWindow(QMainWindow, Ui_MainWindow):
def __init__(self, parent=None, mode='online'):
QMainWindow.__init__(self, parent)
self.setupUi(self)
self.setWindowIcon(QIcon('app_icon.png'))
QtCore.QObject.connect(self.speedSlider, QtCore.SIGNAL("valueChanged (int)"), self.MyCube,
QtCore.SLOT("updateSpeed(int)"))
QtCore.QObject.connect(self.pushButton_Spin, QtCore.SIGNAL("clicked(bool)"), self.MyCube,
QtCore.SLOT("spin(bool)"))
QtCore.QObject.connect(self.pushButton_X, QtCore.SIGNAL("clicked(bool)"), self.MyCube,
QtCore.SLOT("moveX(bool)"))
QtCore.QObject.connect(self.pushButton_Y, QtCore.SIGNAL("clicked(bool)"), self.MyCube,
QtCore.SLOT("moveY(bool)"))
QtCore.QObject.connect(self.pushButton_Z, QtCore.SIGNAL("clicked(bool)"), self.MyCube,
QtCore.SLOT("moveZ(bool)"))
self.myConnector = Connector(self, mode=mode)
self.timer = QtCore.QTimer()
QtCore.QObject.connect(self.timer, QtCore.SIGNAL("timeout()"), self.myConnector.update)
self.timer.start(50) # cycle time in ms (50)
def close(self):
self.myConnector.close()
def fetch_day(date):
logger.info(
"START, extracting dividends, date={}".format(str(date))
)
url = util.get_endpoint_url()
conn = Connector(url)
cnt = 0
for div in conn.get_daily_divs(date):
try:
# call REST API
logger.debug(
"Success processing payout, security=" + str(div)
)
cnt += 1
except Exception as e:
logger.error(
"Error processing payout, security={}, "
"messsage={}".format(
div.security_symbol,
str(e))
)
logger.info(
"END, extracting dividends, date={}, div_processed={}".format(
str(date), cnt)
)
def __init__(self):
self.actions = list()
self.confDir = os.path.expanduser("~") + "/Kam1n0"
if not os.path.exists(self.confDir):
os.makedirs(self.confDir)
self.loadIcons()
self.Kconf = self.getConfiguration()
if self.Kconf is None:
self.connector = Connector()
self.Kconf = {}
self.Kconf['cnns'] = {}
cnnInfo = self.connector.toMap()
self.Kconf['cnns'][cnnInfo['key']] = cnnInfo
self.Kconf['default-cnn'] = cnnInfo['key']
self.setConfiguration(self.Kconf)
else:
if self.Kconf['default-cnn'] is None:
self.connector = None
else:
cnnInfo = self.Kconf['cnns'][self.Kconf['default-cnn']]
self.connector = Connector(
protocol=cnnInfo['protocol'],
server=cnnInfo['server'],
port=cnnInfo['port'],
un=cnnInfo['un'],
pw=cnnInfo['pw']
)
global hooks
hooks = Hooks()
re = hooks.hook()
def exportTo(self, connector: Connector):
try:
cur = self.conn.cursor()
data = self._getAllTablesData(cur)
connector.importData(data)
except Exception as ex:
print(ex)
def __init__(self, contract_address, abi_json='erc20.json'):
self.net = Connector()
with open(abi_json, 'r') as abi:
self.contract_abi = json.load(abi)
self.contract = self.net.w3.eth.contract(
address=Web3.toChecksumAddress(contract_address),
abi=self.contract_abi)
class Updater:
def __init__(self):
self.dest_doc = '/mnt/results/twitterInfo.json'
self.conn = Connector()
def update_document(self):
try:
docs = self.conn.select_full_docs(self.conn.twitterdb_demo_results_pub)
with open(self.dest_doc, 'w') as dest:
for doc in docs:
dest.write(doc)
dest.write('\n')
except BaseException:
try:
docs = self.conn.select_full_docs(self.conn.twitterdb0_demo_results_pub)
with open(self.dest_doc, 'w') as dest:
for doc in docs:
dest.write(doc)
dest.write('\n')
except BaseException:
docs = self.conn.select_full_docs(self.conn.twitterdb1_demo_results_pub)
with open(self.dest_doc, 'w') as dest:
for doc in docs:
dest.write(doc)
dest.write('\n')
return
def Query(self, receipt, receipt_date):
res = None
while res is None:
if not self.c.session_valid:
del self.c
self.c = Connector()
self.c.imgRslr.reportFail(self.c.imgCode, self.c.imgSHA)
self.c.resolveImg()
#log.info('[{}]Get Image {}:{}'.format(self.c.res.reason, self.c.tmp_file, self.c.imgCode))
#log.info('{} and {}'.format(receipt , receipt_date))
self.c.setPostData(receipt, receipt_date)
self.c.postForm(self.c.postPath)
#log.info('[{} {}]Post data'.format(self.c.res.status,self.c.res.reason))
res = self.c.getInfo()
if not self.c.info:
return False
else:
log.info("===[Query Result]===")
receipt = self.c.info
receipt['money'] = receipt['money'].replace(',', '')
for k, r in receipt.iteritems():
print k + ":\t\t" + r
self.receipt_done[self.c.info['id']] = (receipt['date'],
receipt['money'],
receipt['taxid'])
return True
def __check_connection (self): # Get a new connection object to lemonstand API c = Connector() identity = c.get_identity(self.config.api_host, self.config.api_access) connection = c.s3_connection(identity); self.connection = connection return
def __init__(self):
self.tasks = []
self.server = "http://127.0.0.1:8000"
self.getTaskUrl = "/api/getTask/"
self.c = Connector()
self.data = ""
self.testsim = []
self.receipt_done = dict()
def run(self):
## get data from RabbitMQ
getDataObj = Connector(self.logger, self.config)
data = getDataObj.run()
## release lock
self.lockObj.release()
return(True)
def get_connection (configuration): # Start print(Back.YELLOW + Fore.BLACK + 'LemonSync is initiating connection...' + Style.RESET_ALL) # Establish a connection to the LemonStand API, and then to s3 c = Connector() identity = c.get_identity(configuration.api_host, configuration.api_access) connection = c.s3_connection(identity); return connection
def get_connection (configuration): # Start print(Back.YELLOW + Fore.BLACK + 'LemonSync is initiating connection...' + Style.RESET_ALL) # Establish a connection to the LemonStand API, and then to s3 c = Connector() identity = c.get_identity(configuration.api_host, configuration.store_host, configuration.api_access) connection = c.s3_connection(identity); return connection
def createIndexProgressForm(self, funcs, cnn=None):
if cnn is None:
cnn = self.connector
form = IndexProgressForm(cnn, funcs)
form.Execute()
code = form.ErrorCode
content = form.Content
form.Free()
if code > OK:
Connector.getCodeDescription(code, content)
idaapi.warning("Connection failed. Please review your connection. \n \"%s\"" % content)
self.openConnectionManagmentForm(ctx=None)
def writeButton(self):
self.infoLbl.set(Local('Please wait...'))
self.root.update()
try:
self.validate()
conf = self.gatherData()
Connector.write(self.port.get(), conf)
tkMessageBox.showinfo('Info', Local('Success!'))
except Exception as e:
tkMessageBox.showerror(Local('Error'), str(e))
traceback.print_exc()
finally:
self.infoLbl.set('')
def connection():
received_resolution_width = 1200
received_resolution_height = 800
connector = Connector(received_resolution_width,
received_resolution_height)
dummy_screen_resolution_msg = to_screen_resolution_msg(2570, 2570)
received_screen_resolution_msg = to_screen_resolution_msg(
received_resolution_width, received_resolution_height)
connector.exchange_screen_resolution(dummy_screen_resolution_msg,
received_screen_resolution_msg)
return connector
def __init__(self,
contract_name,
contracts_folder=contracts_directory,
provider=infura_provider):
Connector.__init__(self, provider)
self.contract_file = f"{contracts_folder + contract_name}.sol"
with open(self.contract_file, 'r') as contract_code:
self.source_code = contract_code.read()
self.compiled = compile_source(self.source_code)
self.abi = self.compiled[f'<stdin>:{contract_name}']['abi']
self.bin = self.compiled[f'<stdin>:{contract_name}']['bin']
class Contract():
def __init__(self, contract_address, abi_json='erc20.json'):
self.net = Connector()
with open(abi_json, 'r') as abi:
self.contract_abi = json.load(abi)
self.contract = self.net.w3.eth.contract(
address=Web3.toChecksumAddress(contract_address),
abi=self.contract_abi)
def function(self,
function,
*args,
sender=senderAddress,
chain=0,
gas=0,
gasPrice=0,
nonce=0,
key=pk,
call=False):
func = self.contract.functions[function]
if call:
self.output = func(*args).call()
return self.output
else:
sender = Web3.toChecksumAddress(sender)
if chain is 0: chain = self.net.chainId()
if gas is 0: gas = func(*args).estimateGas()
if gasPrice is 0: gasPrice = self.net.gasPrice()
if nonce is 0: nonce = self.net.nonce(sender)
txn = func(*args).buildTransaction({
'chainId': chain,
'gas': gas,
'gasPrice': gasPrice,
'nonce': nonce,
})
signed = self.net.w3.eth.account.signTransaction(txn, key)
txn_hash = self.net.w3.eth.sendRawTransaction(
signed.rawTransaction)
self.txn_receipt = self.net.w3.eth.waitForTransactionReceipt(
txn_hash)
return self.txn_receipt
def call(self, function, *args, sender=senderAddress):
func = self.contract.functions[function]
self.output = func(*args).call()
return self.output
def __init__(self):
self.logger.debug('PLTEConnector Init')
Connector.__init__(self, PLTEManager.getInstance())
self.plteQueId = int(ConfManager.getInstance().getConfigData(
ConfManager.MSGQUEUE_INFO, "PLTEIB"))
try:
maxQSize = ConfManager.getInstance().getConfigData(
ConfManager.MSGQUEUE_INFO, "MAX_QUEUE_SIZE")
self.plteQueue = sysv_ipc.MessageQueue(
self.plteQueId, max_message_size=int(maxQSize))
except Exception as e:
self.logger.error(
"msgQueue Connection Failed.. PLTE QUEUE_ID[%d] SIZE[%s]" %
(self.plteQueId, maxQSize))
def Query(self, receipt, receipt_date):
res = None
while res is None:
if not self.c.session_valid:
del self.c
self.c = Connector()
#self.c.imgRslr.reportFail(self.c.imgCode, self.c.imgSHA)
self.c.resolveImg()
log.info('[{}]Get Image {}:{}'.format(self.c.res.reason, self.c.tmp_file, self.c.imgCode))
log.info('{} and {}'.format(receipt , receipt_date))
self.c.setPostData(receipt, receipt_date )
self.c.postForm( self.c.postPath )
log.info('[{} {}]Post data'.format(self.c.res.status,self.c.res.reason))
res = self.c.getInfo()
with open("out.html" , "w") as outFd:
outFd.write(self.c.body)
if not self.c.info:
return False
else:
print("===[Query Result]===")
receipt = self.c.info
receipt['money'] = receipt['money'].replace(',','')
for k,r in receipt.iteritems():
print k+":\t\t"+r
self.receipt_done[self.c.info['id']] = (receipt['date'],receipt['money'],receipt['taxid'])
return True
def run(self):
self.maxSentries = 15
if len(Connector.getPorts()) == 0:
tkMessageBox.showerror(Local('Error'),
Local('Serial port not found'))
os._exit(0)
self.reload = False
self.protScanTask = None
self.tempWindow = None
self.histWindow = None
#window
root = self.root = Tkinter.Tk()
root.resizable(False, False)
root.title('GSMguard Configuration v.' + appVersion)
root.iconbitmap(resource_path('./gg-icon.ico'))
fleft = ttk.Frame(root)
fleft.pack(side='left', anchor='n')
fright = ttk.LabelFrame(root, text=Local('Schedule'))
fright.pack(side='right', anchor='n', padx=3, pady=3, fill='y')
self.makeLocaleSettings(fleft)
self.makePortSettings(fleft)
self.makeMainSettings(fleft)
self.makeScheduleSettings(fright)
self.updPortList()
root.mainloop()
return self.reload
def readButton(self):
self.infoLbl.set(Local('Please wait...'))
self.root.update()
try:
conf = Connector.read(self.port.get(), self.readEventHist.get(),
self.readTempStat.get())
self.spreadData(conf)
if self.histWindow:
self.histWindow.destroy()
self.histWindow = None
if self.tempWindow:
self.tempWindow.destroy()
self.tempWindow = None
if self.readEventHist.get():
self.histWindow = Tkinter.Toplevel()
x = self.root.winfo_x()
y = self.root.winfo_y() + self.root.winfo_height() + 40
self.histWindow.geometry('+%d+%d' % (x, y))
EventHistory(self.histWindow, conf['eventHist'])
if self.readTempStat.get():
self.tempWindow = Tkinter.Toplevel()
x = self.root.winfo_x() + self.root.winfo_width() + 10
y = self.root.winfo_y()
self.tempWindow.geometry('+%d+%d' % (x, y))
TempPlot(self.tempWindow, conf['tempHist'])
except Exception as e:
tkMessageBox.showerror(Local('Error'), str(e))
traceback.print_exc()
finally:
self.infoLbl.set('')
def openConnectionManagmentForm(self, ctx):
form = ConnectionManagementForm(self)
form.Execute()
self.setConfiguration(self.Kconf)
#print self.Kconf
# update connection:
if self.Kconf['default-cnn'] is not None:
cnnInfo = self.Kconf['cnns'][self.Kconf['default-cnn']]
self.connector = Connector(protocol=cnnInfo['protocol'],
server=cnnInfo['server'],
port=cnnInfo['port'],
un=cnnInfo['un'],
pw=cnnInfo['pw'])
self.connector.reset()
else:
self.connector = None
class BusinessSessionAbs:
__connector = Connector()
def __init__(self):
print("BusinessSessionAbs.__init__")
#self.__connector.runQuery( "SELECT crm_info_id FROM crm_information Limit 10" )
Session = sessionmaker(bind=self.__connector.getEngine())
self.session = Session()
def insertLandmarks(self):
connection = Connector()
connection.makeConnection()
writer=csv.writer(open("landmark_locations.csv",'a+'))
train_path = 'dataset/final_train'
landmark_dir_names = os.listdir(train_path)
for landmark_dir_name in landmark_dir_names:
dir_path = os.path.join(train_path, landmark_dir_name)
full_path = str(dir_path) + "/details"
with open(full_path) as f:
content = f.read().splitlines()
connection.insertIntoLandmark(str(landmark_dir_name), str(content[0]), str(content[1]), str(content[2]))
data_row = []
data_row.append(landmark_dir_name)
data_row.append(content[0])
data_row.append(content[1])
writer.writerow(data_row)
os.remove(full_path)
temp_path = str(dir_path) + "/details~"
if(os.path.isfile(temp_path)):
os.remove(temp_path)
connection.closeConnection()
def workflow(self):
import NtuaActivityStreamsEncoder
from Connector import Connector
message = Connector().ReceiveMessage()
message = NtuaActivityStreamsEncoder.Decoder( message ).dictionary
from UltraStupidTest import stupid
message = stupid(message)
message = NtuaActivityStreamsEncoder.Encoder(author=message.findall(message.original,['author']),title=message['title'],
status=message['status'])
from TwitterConnect import publishAtTwitter
#This method listens at activity streams format
publishAtTwitter(message)
return 1
def workflow(self):
import NtuaActivityStreamsEncoder
from Connector import Connector
message = Connector().ReceiveMessage()
message = NtuaActivityStreamsEncoder.Decoder(message).dictionary
from UltraStupidTest import stupid
message = stupid(message)
message = NtuaActivityStreamsEncoder.Encoder(author=message.findall(
message.original, ['author']),
title=message['title'],
status=message['status'])
from TwitterConnect import publishAtTwitter
#This method listens at activity streams format
publishAtTwitter(message)
return 1
class Outport(Port):
def __init__(self, surface, x, y, r, data):
super().__init__(surface, x, y, r, data)
self.connector = Connector(self, self.surface)
def move(self, x, y):
self.surface.coords(self.port, x - self.r, y - self.r, x + self.r,
y + self.r)
if self.connector.inport != None:
self.surface.coords(self.connector.connector, x, y,
self.connector.secondX, self.connector.secondY)
else:
self.surface.coords(self.connector.connector, x, y, x, y)
# When called, set its location to the given location
def update(self, x, y):
self.x = x
self.y = y
self.connector.updateFirst(x, y)
def __init__(self,
name="",
account_number=0,
balance=0,
balance_limit=0,
amount=0):
self.connector = Connector()
self.log = Logger()
if amount > 0:
self.name = name
self.amount = amount
elif type(name) == str and type(account_number) == int and type(
balance_limit) == int:
self.name = name
self.account_number = account_number
self.balance = balance
self.balance_limit = balance_limit
self.amount = amount
else:
self.log.log_message('ICPT')
pass
class MyListener(StreamListener):
def __init__(self):
self.dp = DataProcessor()
self.conf = Config()
self.auth = tweepy.OAuthHandler(self.conf.consumer_key, self.conf.consumer_secret)
self.auth.set_access_token(self.conf.access_token, self.conf.access_token_secret)
self.conn = Connector()
def on_data(self, raw_data):
try:
self.conn.insert_raw_twitter(raw_data, self.conn.twitterdb_demo_pub)
target_info = self.dp.get_geo_twi_target_info(raw_data)
self.conn.insert_raw_twitter_result(target_info, self.conn.twitterdb_demo_results_pub)
if target_info:
self.conn.insert_raw_twitter_result(target_info, self.conn.twitterdb_demo_results_pub)
return True
except BaseException as e:
print("Error on_data:%s" % str(e))
return True
def on_error(self, status_code):
if status_code == 420:
print("ERROR: Rate limit reached")
print(status_code)
return True
def on_timeout(self):
print("ERROR: Timeout...")
return True # Don't kill the stream
def queryCompositionAnalysis(self, ctx):
print "Generating binary surrogate for composition query..."
surrogate = IDAutils.GetBinarySurrogate()
if not surrogate:
print "Cannot generate the binary surrogate"
return 0
code, content = self.connector.tryLoginAndExecute(
queryFunction=self.connector.querySurrogateComposition,
params=[
surrogate, self.Kconf['default-threshold'],
self.Kconf['default-topk']
])
if code > OK:
Connector.getCodeDescription(code, content)
idaapi.warning(
"Connection failed. Please review your connection. \n \"%s\"" %
content)
self.openConnectionManagmentForm(ctx=None)
else:
print "Opening composition view..."
thread = Thread(target=self.connector.openCompositionPage)
thread.start()
def format_data_to_json(raw_data):
data = {'situations': [], 'actions': [], 'connectors': []}
for child in raw_data:
# TODO : Refactor style to config
# TODO : Use pattern Strategy, Factory?
if child.get('style', None) == "whiteSpace=wrap;html=1;aspect=fixed;":
situation = Situation(child)
if situation.is_valid:
data['situations'].append(situation.as_json())
elif child.get('style', None) == "ellipse;whiteSpace=wrap;html=1;":
action = Action(child)
if action.is_valid:
data['actions'].append(action.as_json())
elif child.get('style', None) is not None:
connector = Connector(child)
if connector.is_valid:
data['connectors'].append(connector.as_json())
json_data = json.dumps(data, ensure_ascii=False)
return json_data
def OnFormChange(self, fid):
if fid == self.fvChooser.id:
return 1
if fid == self.chkSkipLib.id:
if self.GetControlValue(self.chkSkipLib) == 1:
self.SetControlValue(self.chkSearchAll, 0)
self.SetControlValue(self.fvChooser, getNotLibIndex(allFuncs))
self.activated = True
if fid == self.chkSearchAll.id:
if self.GetControlValue(self.chkSearchAll) == 1:
self.SetControlValue(self.chkSkipLib, 0)
self.SetControlValue(self.fvChooser, range(len(allFuncs)))
self.activated = True
if fid == self.dpServer:
if len(self.Kconf['cnns'].keys()) > 0:
# update self.cnn
selectedInd = self.GetControlValue(self.dpServer)
key = self.Kconf['cnns'].keys()[selectedInd]
cnnInfo = self.Kconf['cnns'][key]
self.cnn = Connector.Connector(protocol=cnnInfo['protocol'],
server=cnnInfo['server'],
port=cnnInfo['port'],
un=cnnInfo['un'],
pw=cnnInfo['pw'])
if fid == self.txtSim:
self.threshold = float(self.GetControlValue(self.txtSim))
if fid == self.txtTopK:
self.topk = int(self.GetControlValue(self.txtTopK))
if fid == -2:
funcInds = self.GetControlValue(self.fvChooser)
global allFuncs
if allFuncs is not None:
funcs = [allFuncs[x] for x in funcInds]
if len(funcs) < 1:
print "number of selected functions is less than 1"
else:
self.funcs += funcs
return 1
def openConnectionManagmentForm(self, ctx):
form = ConnectionManagementForm(self)
form.Execute()
self.setConfiguration(self.Kconf)
# update connection:
if self.Kconf['default-cnn'] is not None:
cnnInfo = self.Kconf['cnns'][self.Kconf['default-cnn']]
self.connector = Connector(
protocol=cnnInfo['protocol'],
server=cnnInfo['server'],
port=cnnInfo['port'],
un=cnnInfo['un'],
pw=cnnInfo['pw']
)
self.connector.reset()
else:
self.connector = None
def CreateCSV(self):
writer=csv.writer(open("landmark_locations.csv",'a+'))
writer.writerow(['Landmark', 'Longitude', 'Latitiude'])
connection = Connector()
connection.makeConnection()
results = connection.retriveLandmarkLocation()
for i in range(len(results)):
data_row = []
data_row.append(results[i].Name)
data_row.append(results[i].location)
data_row.append(results[i].location2)
writer.writerow(data_row)
connection.closeConnection()
class Crawler(object):
def __init__(self):
self.tasks = []
self.dbmgr = DBManager()
self.c = Connector()
self.data = ""
def getTasks(self, task):
""" getTasks """
pass
def Query(self):
#log.info('Connect to {}'.format(c.domain))
res = None
while res is None:
if not self.c.session_valid:
self.c.imgRslr.reportFail(self.c.imgCode, self.c.imgSHA)
self.c.resolveImg()
log.info('[{}]Get Image {}:{}'.format(self.c.res.reason, self.c.tmp_file, self.c.imgCode))
log.info('{} and {}'.format(self.id_tag + str(self.id_num).zfill(8) , self.rec_date))
self.c.setPostData( self.id_tag + str(self.id_num).zfill(8) , self.rec_date )
self.c.postForm( self.c.postPath )
log.info('[{} {}]Post data'.format(self.c.res.status,self.c.res.reason))
res = self.c.getInfo()
with open("out.html" , "w") as outFd:
outFd.write(self.c.body)
if not bool(self.c.info):
print "No Record"
return False
print("===[Query Result]===")
for k,r in self.c.info.iteritems():
print k+":\t\t"+r
if k == 'id':
res_id = r
if k == 'money':
res_money = r.replace(',','')
if k == 'date':
res_date = r
if k == 'taxid':
res_taxid = r
self.receipt[res_id] = (res_date,res_money,res_taxid)
return True
def Crawl(self , num , date, direct, distance):
self.rec_id = num
self.rec_date = date
self.id_tag = self.rec_id[0:2]
self.id_num = int(self.rec_id[2:10])
self.receipt = {}
cont = 0
cont2 = 0
while ( abs(int(self.id_num) - int(self.rec_id[2:10])) < distance):
success = self.Query()
if success is True :
self.id_num += direct
cont = 0
cont2 = 0
elif (success is False) and (abs(cont2) < 3):
print '!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!'
self.id_num += direct
cont2 += direct
elif (success is False) and (cont==0) and (abs(cont2) >= 3):
self.rec_date = TimeConvert(self.rec_date , direct)
print "TimeConvert : "+ self.rec_date
self.id_num -= cont2
cont2 = 0
cont+=1
elif (success is False) and (cont!=0) and (abs(cont2) >= 3) :
break
else:
log.error('main loop unusually break')
sys.exit(1)
return self.receipt
class CompatibilityMode_702 :
"""Use this class for old 702 Stubs compatibility only """
FETCH_ALL = -1 # get all results in one call (USE CAUTIOUSLY)
CLASSFACTORY = "com.sefas.workflowservice.WorkflowFactory"
METHOD_INIT_CONTEXT = "initContext"
METHOD_TERMINATE_CONTEXT = "terminateContext"
METHOD_START_WORKFLOW = "startWorkflow"
METHOD_STOP_WORKFLOW = "stopWorkflow"
METHOD_KILL_WORKFLOW = "killWorkflow"
METHOD_CLEAN_JOB_TICKET_MONITORING = "cleanJobTicketMonitoring"
METHOD_WAIT_WORKFLOW_END = "waitWorkflowEnd"
ARGS = "args"
def __init__ (self ,
encoding="UTF8" , # default encoding to UTF8
hostName="localhost" ,
port=29100
):
""" constructor just store provided object information """
self._host = hostName
self._port = port
self._connection = None
self._encoding = encoding
self._param = {}
self._env = {}
self._paramSended = {}
self._envSended = {}
self._engineProp = None
self._envProp = None
self._islock = True
def connect(self) :
""" connect to Smd Service """
if (self._connection == None):
self._connection = Connector(self._host , self._port , self._encoding, CompatibilityMode_702.CLASSFACTORY)
return self._connection
def disconnect(self):
""" Disconnect from Smd Service """
if (self._connection != None):
self._connection.close()
self._connection = None
return
def initContext (self, workflowName):
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, CompatibilityMode_702.METHOD_INIT_CONTEXT)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, CompatibilityMode_702.ARGS)
self._connection.marshall(Connector.SET_VALUE, CompatibilityMode_702.ARGS, workflowName)
# proceed with call
# return a workflow loader context id
return self._connection.unmarshall(self._connection.marshall(Connector.CALL))
def terminateContext (self, workflowContextId):
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, CompatibilityMode_702.METHOD_TERMINATE_CONTEXT)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, CompatibilityMode_702.ARGS)
self._connection.marshall(Connector.SET_VALUE, CompatibilityMode_702.ARGS, workflowContextId)
# proceed with call
self._connection.marshall(Connector.CALL)
def startWorkFlow (self, workflowContextId, xpdl, jobTicketData):
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, CompatibilityMode_702.METHOD_START_WORKFLOW)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, CompatibilityMode_702.ARGS)
self._connection.marshall(Connector.SET_VALUE, CompatibilityMode_702.ARGS, workflowContextId)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, CompatibilityMode_702.ARGS)
self._connection.marshall(Connector.SET_VALUE, CompatibilityMode_702.ARGS, xpdl)
# populate parameters
if jobTicketData != None:
self._connection.marshall(Connector.DEF_STRING, CompatibilityMode_702.ARGS)
self._connection.marshall(Connector.SET_VALUE, CompatibilityMode_702.ARGS, jobTicketData)
# proceed with call
# return a workflow running context id
return self._connection.unmarshall(self._connection.marshall(Connector.CALL))
def cleanJobTicketMonitoring (self, jobTicketId):
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, CompatibilityMode_702.METHOD_CLEAN_JOB_TICKET_MONITORING)
if jobTicketId != None:
self._connection.marshall(Connector.DEF_STRING, CompatibilityMode_702.ARGS)
self._connection.marshall(Connector.SET_VALUE, CompatibilityMode_702.ARGS, jobTicketId)
# proceed with call
# return a workflow running context id
return self._connection.unmarshall(self._connection.marshall(Connector.CALL))
def stopWorkFlow (self, workflowContextId):
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, CompatibilityMode_702.METHOD_STOP_WORKFLOW)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, CompatibilityMode_702.ARGS)
self._connection.marshall(Connector.SET_VALUE, CompatibilityMode_702.ARGS, workflowContextId)
# populate parameters
# proceed with call
# return a workflow running context id
return self._connection.unmarshall(self._connection.marshall(Connector.CALL))
def killWorkFlow (self, workflowContextId):
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, CompatibilityMode_702.METHOD_KILL_WORKFLOW)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, CompatibilityMode_702.ARGS)
self._connection.marshall(Connector.SET_VALUE, CompatibilityMode_702.ARGS, workflowContextId)
# populate parameters
# proceed with call
# return a workflow running context id
return self._connection.unmarshall(self._connection.marshall(Connector.CALL))
def waitWorkFlowEnd (self, workflowRunningContextId, timeOut=50000):
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, CompatibilityMode_702.METHOD_WAIT_WORKFLOW_END)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, CompatibilityMode_702.ARGS)
self._connection.marshall(Connector.SET_VALUE, CompatibilityMode_702.ARGS, workflowRunningContextId)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, CompatibilityMode_702.ARGS)
self._connection.marshall(Connector.SET_VALUE, CompatibilityMode_702.ARGS, timeOut)
# proceed with call
return self._connection.marshall(Connector.CALL)
class JdbcClient:
"""Python Client interface to the SqlFactory SMD service """
FETCH_ALL = -1 # get all results in one call (USE CAUTIOUSLY)
CLASSFACTORY = 'com.sefas.gridclient.sqlservices.SqlExecFactory'
METHOD_NAME_SET_DBSCHEMA = "setDBSchema"
METHOD_NAME_SET_DBCATALOG = "setDBCatalog"
PARAM_NAME_DBSCHEMA = "dbSchema"
PARAM_NAME_DBCATALOG = "dbCatalog"
def __init__ ( self ,
encoding="UTF8" , # default encoding to UTF8
hostName="localhost" ,
port=29100,
variableDict = None
):
""" constructor just store provided object information """
self._host = hostName
self._port = port
self._connection = None
self._encoding = encoding
self._variableDict = variableDict
def connect( self ) :
""" connect to SqlFactory Service """
if ( self._connection != None ):
return
self._connection = Connector( self._host , self._port , self._encoding, self.CLASSFACTORY )
def sqlInit( self , jdbcDriver ):
""" load JdbcDriver return Nothing or exception on failure """
self._connection.marshall( Connector.SET_METHOD , "sqlInit" )
# populate parameters
self._connection.marshall( Connector.DEF_STRING , "driver" )
self._connection.marshall( Connector.SET_VALUE , "driver" , jdbcDriver )
self._connection.marshall( Connector.DEF_STRING , "encoding" )
self._connection.marshall( Connector.SET_VALUE , "encoding" , self._encoding )
# proceed with call
self._connection.marshall( Connector.CALL )
def sqlOpen( self , jdbcString , userid , passwd ):
""" connect to requested database through the provided jdbc string """
self._connection.marshall( Connector.SET_METHOD , "sqlOpen" )
# populate parameters
self._connection.marshall( Connector.DEF_STRING , "dbstring" )
self._connection.marshall( Connector.SET_VALUE , "dbstring" , jdbcString )
self._connection.marshall( Connector.DEF_STRING , "user" )
self._connection.marshall( Connector.SET_VALUE , "user" , userid )
self._connection.marshall( Connector.DEF_STRING , "passwd" )
self._connection.marshall( Connector.SET_VALUE , "passwd" , passwd )
# proceed with call
ret = self._connection.marshall( Connector.CALL )
# marshall the Db id back
return int(self._connection.unmarshall( ret ))
def execSql( self , dbHandle , statement ):
""" execute provided sql statement on given dbHandle """
self._connection.marshall( Connector.SET_METHOD , "execSql" )
# populate parameters
self._connection.marshall( Connector.DEF_INTEGER , "dbHandle" )
self._connection.marshall( Connector.SET_VALUE , "dbHandle" , str(dbHandle) )
self._connection.marshall( Connector.DEF_STRING , "statement" )
self._connection.marshall( Connector.SET_VALUE , "statement" , statement )
# proceed with call
ret = self._connection.marshall( Connector.CALL )
# marshall cursor id back or None if cursorId is -1
returned = int(self._connection.unmarshall( ret ))
if returned == -1 :
return None
return returned
def callSql( self , dbHandle , callfx , *args ):
""" call callfx stored procedure with providing argument list """
# build the jdbc call string argument
statement = '{call %s (' % callfx
statementArgs = ''
for arg in args :
statement = ''.join( [ statement , '?' ] )
statementArgs = ''.join( [ statementArgs , "'" , arg , "'" ] )
if arg != args[-1] :
statement = ''.join( [ statement , ',' ] )
statementArgs = ''.join( [ statementArgs , ',' ] )
statement = ' '.join( [ statement , ') }' ] )
self._connection.marshall( Connector.SET_METHOD , "callSql" )
# populate parameters
self._connection.marshall( Connector.DEF_INTEGER , "dbHandle" )
self._connection.marshall( Connector.SET_VALUE , "dbHandle" , str(dbHandle) )
self._connection.marshall( Connector.DEF_STRING , "statement" )
self._connection.marshall( Connector.SET_VALUE , "statement" , statement )
self._connection.marshall( Connector.DEF_STRING , "statementargs" )
self._connection.marshall( Connector.SET_VALUE , "statementargs" , statementArgs )
# proceed with call
ret = self._connection.marshall( Connector.CALL )
# marshall cursor id back or None if cursorId is -1
returned = int(self._connection.unmarshall( ret ))
if returned == -1 :
return None
return returned
def sqlCursorClose( self , csHandle ):
""" close a previously opened cursor on a given database handle for concurent querries"""
self._connection.marshall( Connector.SET_METHOD , "sqlCursorClose" )
# populate parameters
self._connection.marshall( Connector.DEF_INTEGER , "cshandle" )
self._connection.marshall( Connector.SET_VALUE , "cshandle" , csHandle )
# proceed with call
self._connection.marshall( Connector.CALL )
def sqlClose( self , dbHandle ):
""" close a previously opened db connection"""
self._connection.marshall( Connector.SET_METHOD , "sqlClose" )
# populate parameters
self._connection.marshall( Connector.DEF_INTEGER , "dbhandle" )
self._connection.marshall( Connector.SET_VALUE , "dbhandle" , dbHandle )
# proceed with call
self._connection.marshall( Connector.CALL )
def sqlFetch( self , csHandle , nbrow = 1):
""" close a previously opened cursor on a given database handle for concurent querries"""
self._connection.marshall( Connector.SET_METHOD , "sqlFetch" )
# populate parameters
self._connection.marshall( Connector.DEF_INTEGER , "cshandle" )
self._connection.marshall( Connector.SET_VALUE , "cshandle" , csHandle )
self._connection.marshall( Connector.DEF_INTEGER , "nbrow" )
self._connection.marshall( Connector.SET_VALUE , "nbrow" , nbrow )
# proceed with call
ret = self._connection.marshall( Connector.CALL )
# unmarshall sqlresult back
returned = self._connection.unmarshall( ret )
if returned == -1 :
return None
# Fetch provides a Python compliant result back so using
# eval is simply fast and elegant here
dc = self._connection._decoder # NB USED inside eval string
returned = eval(returned , sys._getframe(0).f_globals ,sys._getframe(0).f_locals)
if len(returned) == 0 :
return None
return returned
def setDBSchema( self, dbSchema ):
#ETHOD_NAME_SET_DBSCHEMA = "setDBSchema"
self._connection.marshall( Connector.SET_METHOD, self.METHOD_NAME_SET_DBSCHEMA )
# populate parameters
self._connection.marshall( Connector.DEF_STRING, self.PARAM_NAME_DBSCHEMA )
self._connection.marshall( Connector.SET_VALUE, self.PARAM_NAME_DBSCHEMA, dbSchema )
# proceed with call
self._connection.marshall( Connector.CALL )
def setDBCatalog( self, dbCatalog ):
self._connection.marshall( Connector.SET_METHOD, self.METHOD_NAME_SET_DBCATALOG )
# populate parameters
self._connection.marshall( Connector.DEF_STRING, self.PARAM_NAME_DBCATALOG )
self._connection.marshall( Connector.SET_VALUE, self.PARAM_NAME_DBCATALOG, dbCatalog )
# proceed with call
self._connection.marshall( Connector.CALL )
def __trace( self , msg , verbose ) :
if verbose :
print msg
def __isStoredProc( self , sqlStmt ):
""" return true if current sqlstmt is a create function or package """
curCheck = sqlStmt.replace('%%cr%%' , '').lstrip()
storeprocChecker = curCheck.split(' ')
if len(storeprocChecker) < 2 :
return False
if ( storeprocChecker[0] == 'CREATE' or 'create' ) :
if storeprocChecker[1] == 'or' or 'OR' :
pos = 3
else :
pos = 2
if len(storeprocChecker) <= pos :
return False
if storeprocChecker[pos] == 'package' or \
storeprocChecker[pos] == 'PACKAGE' or \
storeprocChecker[pos] == 'function' or \
storeprocChecker[pos] == 'FUNCTION' or \
storeprocChecker[pos] == 'trigger' or \
storeprocChecker[pos] == 'TRIGGER' :
return True
else:
if ( storeprocChecker[pos] == 'type' or \
storeprocChecker[pos] == 'TYPE' ) and \
( storeprocChecker[pos+1] == 'body' or \
storeprocChecker[pos+1] == 'BODY' ) :
return True
return False
def __checkStoredProc( self , sqlStmt ):
""" split non stored procedure sequences """
if self.__isStoredProc(sqlStmt) :
return None
else:
return sqlStmt.split(';')
def __emptySql( self , sqlStmt ):
""" check for empty sql statement """
curCheck = sqlStmt.replace('%%cr%%' , '').lstrip()
if curCheck == '' or curCheck == '.' or curCheck == 'exit' :
# dot is sometime used as kind of separator = ignore it
return True
return False
def _purgeLeadingSpace( self , sqlStmts ):
""" return sqlstm removing leading \n and spaces"""
sqlStmts = sqlStmts.lstrip(' ')
sqlStmts = sqlStmts.lstrip('\n')
return sqlStmts
def __procesQuoted ( self , sqlStmt ) :
""" process ; inside quote """
sqlStmt = sqlStmt.replace( ';' , '%%semicol%%' )
return sqlStmt
def __purgeComments( self , sqlStmts ) :
""" purge ; / inside sqlcomments """
sqlStmts = sqlStmts.split('\n')
i = 0
inMultiLineComment = False
while i < len(sqlStmts) :
# remove leading spaces
sqlStmts[i] = sqlStmts[i].lstrip()
sqlStmt = sqlStmts[i]
# check for -- / and ; in current line
multiLineComPos = sqlStmt.find('/*')
if multiLineComPos != -1 :
inMultiLineComment = True
if inMultiLineComment :
multiLineComPosEnd = sqlStmt.find('*/')
if multiLineComPosEnd == -1 :
del sqlStmts[i]
else :
sqlStmts[i] = sqlStmt[multiLineComPosEnd+2:]
i = i+1
inMultiLineComment = False
else :
commentPos = sqlStmt.find('--')
quotePos = sqlStmt.find("'")
semicolPos = sqlStmt.find(';')
# check for sqlplus / execute statement separator
wk = sqlStmts[i].strip()
if len(wk) == 1 and wk == '/':
pass
else :
# replace any /
sqlStmts[i] = sqlStmt.replace( '/' , '%%slash%%' )
sqlStmt = sqlStmts[i]
if commentPos != -1 :
if semicolPos > commentPos :
sqlStmts[i] = sqlStmt.replace( ';' , '%%semicol%%' )
else :
if semicolPos != -1 :
# only change when / or ; in constants
while quotePos != -1 :
# process multiple paired quoted
endQuote = sqlStmt.find("'",quotePos+1)
sliced = self.__procesQuoted(sqlStmt[quotePos:endQuote+1])
newEndQuote = (quotePos-1) + len(sliced) # recomp after transformation
sqlStmts[i] = ''.join([sqlStmt[0:quotePos] , sliced , sqlStmt[endQuote+1:] ])
sqlStmt = sqlStmts[i]
quotePos = sqlStmt.find("'",newEndQuote+1)
# don't care about '.' DOT end of sqlblocs and get rid of them
if len(wk) == 1 and wk == '.' :
del sqlStmts[i]
i = i+1
returned = '\n'.join(sqlStmts) ;
return returned
def __purgeLeadingComments( self , sqlStmts ) :
""" purge -- before sql commands """
sqlStmts = sqlStmts.replace('%%cr%%' , '\n')
sqlStmts = sqlStmts.split('\n')
# check for leading --
while ( sqlStmts != [] ) and \
( len( sqlStmts[0] ) == 0 or \
sqlStmts[0][:2] == '--' ) :
del sqlStmts[0]
sqlStmts = '\n'.join(sqlStmts)
return sqlStmts.replace('\n','%%cr%%')
def __isDrop( self , sqlStmt ) :
first = sqlStmt.split()[0].strip().upper()
if first == 'DROP' :
return True
return False
def __processScriptUnit( self , scriptFName , dbHandle , sqlStmt ) :
""" process single script SQL element """
try :
isDrop = False
sqlStmt = self.__purgeLeadingComments(sqlStmt)
sqlStmt = sqlStmt.replace('}', '%%clbracket%%' )
sqlStmt = sqlStmt.replace('{', '%%opbracket%%' )
# check for emptyness after
if not self.__emptySql(sqlStmt) :
isDrop = self.__isDrop(sqlStmt)
cursor = self.execSql(dbHandle , sqlStmt)
# fetch until the end of the resultset requesting 10 rows by fetch
if cursor != None :
srows = self.sqlFetch( cursor , self.FETCH_ALL )
sqlStmt = sqlStmt.replace('%%cr%%' , '')
print scriptFName + ":"+ sqlStmt + " rows = " , srows
self.sqlCursorClose(cursor)
except SmdClientError , f :
# ignore error on SQL drop (May be refined)
if not isDrop :
sqlStmt = sqlStmt.replace( '%%cr%%' , '\n' )
print 'sqlprocessing error : ' + str(f)
print 'on statement :' + sqlStmt
def connect(self) :
""" connect to Smd Service """
if (self._connection == None):
self._connection = Connector(self._host , self._port , self._encoding, CompatibilityMode_702.CLASSFACTORY)
return self._connection
def __init__(self, url, api_key, api_user = '', api_pass = ''):
self.url = url
self.api_key = api_key
Connector.__init__(self, url, api_key, api_user, api_pass)
def executer(oneLine):
# for oneLine in eList:
if oneLine.operation=='upload':
Conn=Connector(oneLine.ip,oneLine.port,oneLine.userName,oneLine.passWord,oneLine.connWay)
Conn.sftpUpload(oneLine.restList[1].strip(),oneLine.restList[0].strip())
elif oneLine.operation=='download':
Conn=Connector(oneLine.ip,oneLine.port,oneLine.userName,oneLine.passWord,oneLine.connWay)
Conn.sftpDownLoad(oneLine.restList[1].strip(),oneLine.restList[0].strip())
elif oneLine.operation=='execute':
Conn=Connector(oneLine.ip,oneLine.port,oneLine.userName,oneLine.passWord,oneLine.connWay)
Conn.sshExecute(oneLine.restList)
elif oneLine.operation=='monitor':
Conn=Connector(oneLine.ip,oneLine.port,oneLine.userName,oneLine.passWord,oneLine.connWay)
Conn.sshMonitor(oneLine.restList,oneLine.filePath,oneLine.interval,oneLine.times)
class TaskSolver(object):
def __init__(self):
self.tasks = []
self.dbmgr = DBManager()
self.c = Connector()
self.data = ""
self.receipt_done = dict()
def getTasks(self, task):
""" getTasks """
pass
def Query(self, receipt, receipt_date):
res = None
while res is None:
if not self.c.session_valid:
del self.c
self.c = Connector()
#self.c.imgRslr.reportFail(self.c.imgCode, self.c.imgSHA)
self.c.resolveImg()
log.info('[{}]Get Image {}:{}'.format(self.c.res.reason, self.c.tmp_file, self.c.imgCode))
log.info('{} and {}'.format(receipt , receipt_date))
self.c.setPostData(receipt, receipt_date )
self.c.postForm( self.c.postPath )
log.info('[{} {}]Post data'.format(self.c.res.status,self.c.res.reason))
res = self.c.getInfo()
with open("out.html" , "w") as outFd:
outFd.write(self.c.body)
if not self.c.info:
return False
else:
print("===[Query Result]===")
receipt = self.c.info
receipt['money'] = receipt['money'].replace(',','')
for k,r in receipt.iteritems():
print k+":\t\t"+r
self.receipt_done[self.c.info['id']] = (receipt['date'],receipt['money'],receipt['taxid'])
return True
def _modify_receipt_num(self, receipt, delta):
receipt_eng = receipt[0:2]
receipt_num = int(receipt[2:10])
receipt_num += delta
return receipt_eng+str(receipt_num)
def solve_task(self, task_dict):
distance = task_dict['distance']
date = task_dict['date']
direction = task_dict['direction']
receipt = task_dict['receipt']
start_receipt = receipt
start_receipt_num = int(start_receipt[2:10])
current_receipt = start_receipt
current_receipt_num = int(current_receipt[2:10])
success_count = 0
while (abs(start_receipt_num - current_receipt_num) < distance):
success = self.Query(current_receipt, date)
if success is True:
current_receipt = self._modify_receipt_num(current_receipt,direction)
current_receipt_num = int(current_receipt[2:10])
success_count += 1
elif success is False:
break
else:
log.error('main loop unusually break')
sys.exit(1)
result = {
'success':success_count,
'error':distance-success_count,
}
receipt = self.receipt_done
return_data = {'result':result,'receipt':self.receipt_done,'task':task_dict}
return return_data
def start_solver(self):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_address = ('127.0.0.1', 5555)
print 'connecting to {} '.format(server_address)
sock.connect(server_address)
while True:
task_str = sock.recv(512)
task = json.loads(task_str)
if task['action'] == "solve":
task_dict = task['task']
print "Recieve task : {}".format(task_dict)
result = solver.solve_task(task_dict)
print "send : \n{}".format(result)
sock.sendall(json.dumps(result))
print "Task done!!"
elif task['action'] == "close":
sock.close()
break
class Kam1n0PluginManager():
def __init__(self):
self.actions = list()
self.confDir = os.path.expanduser("~") + "/Kam1n0"
if not os.path.exists(self.confDir):
os.makedirs(self.confDir)
self.loadIcons()
self.Kconf = self.getConfiguration()
if self.Kconf is None:
self.connector = Connector()
self.Kconf = {}
self.Kconf['cnns'] = {}
cnnInfo = self.connector.toMap()
self.Kconf['cnns'][cnnInfo['key']] = cnnInfo
self.Kconf['default-cnn'] = cnnInfo['key']
self.setConfiguration(self.Kconf)
else:
if self.Kconf['default-cnn'] is None:
self.connector = None
else:
cnnInfo = self.Kconf['cnns'][self.Kconf['default-cnn']]
self.connector = Connector(
protocol=cnnInfo['protocol'],
server=cnnInfo['server'],
port=cnnInfo['port'],
un=cnnInfo['un'],
pw=cnnInfo['pw']
)
global hooks
hooks = Hooks()
re = hooks.hook()
def loadIcons(self):
self.icon = {}
self.icon[IDAutils.ICON_SEARCH] = IDAutils.loadIcon(IDAutils.ICON_SEARCH)
self.icon[IDAutils.ICON_SEARCHMULTI] = IDAutils.loadIcon(IDAutils.ICON_SEARCHMULTI)
self.icon[IDAutils.ICON_INDEX] = IDAutils.loadIcon(IDAutils.ICON_INDEX)
self.icon[IDAutils.ICON_INDEXS] = IDAutils.loadIcon(IDAutils.ICON_INDEXS)
self.icon[IDAutils.ICON_SETT] = IDAutils.loadIcon(IDAutils.ICON_SETT)
self.icon[IDAutils.ICON_CONN] = IDAutils.loadIcon(IDAutils.ICON_CONN)
def removeAllAction(self):
for action in self.actions:
action.unregisterAction()
def registerActions(self):
action = ActionWrapper(
id="Kam1n0:queryCurrent",
name="Search current function",
icon=self.icon[IDAutils.ICON_SEARCH],
tooltip="Search the current function",
shortcut="Ctrl+Shift+s",
menuPath="Search/next code",
callback=self.queryCurrentFunction,
args=None
)
self.actions.append(action)
if not action.registerAction():
return 1
action = ActionWrapper(
id="Kam1n0:querySelected",
name="Select functions to search",
icon=self.icon[IDAutils.ICON_SEARCHMULTI],
tooltip="Select functions to search",
shortcut="Ctrl+Shift+a",
menuPath="Search/next code",
callback=self.querySelectedFunctions,
args=None
)
self.actions.append(action)
if not action.registerAction():
return 1
action = ActionWrapper(
id="Kam1n0:indexCurrent",
name="Index current function",
icon=self.icon[IDAutils.ICON_INDEX],
tooltip="Index current function",
shortcut="Ctrl+Shift+k",
menuPath="Edit/Export data",
callback=self.indexCurrentFunction,
args=None
)
self.actions.append(action)
if not action.registerAction():
return 1
action = ActionWrapper(
id="Kam1n0:indexSelected",
name="Index selected function",
icon=self.icon[IDAutils.ICON_INDEXS],
tooltip="Index selected function",
shortcut="Ctrl+Shift+j",
menuPath="Edit/Export data",
callback=self.indexSelectedFunctions,
args=None
)
self.actions.append(action)
if not action.registerAction():
return 1
action = ActionWrapper(
id="Kam1n0:connectionManagement",
name="Manage connection",
icon=self.icon[IDAutils.ICON_CONN],
tooltip="Manage connection",
shortcut="",
menuPath="Edit/Kam1n0/",
callback=self.openConnectionManagmentForm,
args=None
)
self.actions.append(action)
if not action.registerAction(True):
return 1
action = ActionWrapper(
id="Kam1n0:storageManagement",
name="Manage storage",
icon=self.icon[IDAutils.ICON_SETT],
tooltip="Manage storage",
shortcut="",
menuPath="Edit/Kam1n0/",
callback=self.openAdminForm,
args=None
)
self.actions.append(action)
if not action.registerAction(False):
return 1
return 0
def indexCurrentFunction(self, ctx):
func = IDAutils.GetCurrentFunction()
if not func:
print "Current address does not belong to a function"
return 0
self.createIndexProgressForm([func])
def indexSelectedFunctions(self, ctx):
if ctx.form_title == "Functions window":
funcs = []
for fidx in ctx.chooser_selection:
func = idaapi.getn_func(fidx - 1)
funcs.append(func)
self.createIndexProgressForm(funcs)
else:
form = IndexSelectionForm(self)
ok = form.Execute()
funcs = form.funcs
s_cnn = form.cnn
form.Free()
if ok == 1:
self.createIndexProgressForm(funcs, s_cnn)
def querySelectedFunctions(self, ctx):
if ctx.form_title == "Functions window":
funcs = []
for fidx in ctx.chooser_selection:
func = idaapi.getn_func(fidx - 1)
funcs.append(func)
self.createProgressForm(funcs)
else:
form = SelectionForm(self)
ok = form.Execute()
funcs = form.funcs
s_cnn = form.cnn
form.Free()
if ok == 1:
self.createProgressForm(funcs, s_cnn)
def queryCurrentFunction(self, ctx):
func = IDAutils.GetCurrentFunction()
if not func:
print "Current address does not belong to a function"
return 0
self.createProgressForm([func])
def openConnectionManagmentForm(self, ctx):
form = ConnectionManagementForm(self)
form.Execute()
self.setConfiguration(self.Kconf)
# update connection:
if self.Kconf['default-cnn'] is not None:
cnnInfo = self.Kconf['cnns'][self.Kconf['default-cnn']]
self.connector = Connector(
protocol=cnnInfo['protocol'],
server=cnnInfo['server'],
port=cnnInfo['port'],
un=cnnInfo['un'],
pw=cnnInfo['pw']
)
self.connector.reset()
else:
self.connector = None
def openAdminForm(self, ctx):
self.connector.openAdminPage()
def createProgressForm(self, funcs, cnn=None):
if cnn is None:
cnn = self.connector
form = SearchProgressForm(cnn, funcs)
form.Execute()
code = form.ErrorCode
content = form.Content
form.Free()
if code > OK:
Connector.getCodeDescription(code, content)
idaapi.warning("Connection failed. Please review your connection. \n \"%s\"" % content)
self.openConnectionManagmentForm(ctx=None)
def createIndexProgressForm(self, funcs, cnn=None):
if cnn is None:
cnn = self.connector
form = IndexProgressForm(cnn, funcs)
form.Execute()
code = form.ErrorCode
content = form.Content
form.Free()
if code > OK:
Connector.getCodeDescription(code, content)
idaapi.warning("Connection failed. Please review your connection. \n \"%s\"" % content)
self.openConnectionManagmentForm(ctx=None)
def getConfiguration(self):
try:
with open(self.confDir + '/plugin-conf.pkl', 'rb') as f:
return pickle.load(f)
except:
return None
def setConfiguration(self, map):
with open(self.confDir + '/plugin-conf.pkl', 'wb') as f:
pickle.dump(map, f, pickle.HIGHEST_PROTOCOL)
def imageSearch(self, descriptorsJson, locationJson, bearingJson):
# def imageSearch(self):
descriptors = json.loads(descriptorsJson)
descriptors = descriptors['desc']
descriptors = descriptors.replace(';', '],[')
descriptors = descriptors.replace('\n', '')
descriptors = '[' + descriptors + ']'
descriptors = descriptors.replace('[','').split('],')
descriptors = [map(float, s.replace(']','').split(',')) for s in descriptors]
descriptors = np.array(descriptors)
location = json.loads(locationJson)
location = location['loc']
location = location.replace('[','').split('],')
location = [map(float, s.replace(']','').split(',')) for s in location]
location = np.array(location)
bearing = json.loads(bearingJson)
bearing = bearing['bearing']
bearing = bearing.replace('[', '').split('],')
bearing = [map(float, s.replace(']','').split(',')) for s in bearing]
# a = 'temp'
# b = os.listdir(a)
# for c in b:
# d = os.path.join(a,c)
# img = cv2.imread(d)
# fea_det = cv2.FeatureDetector_create("ORB")
# des_ext = cv2.DescriptorExtractor_create("ORB")
# kpts = fea_det.detect(img)
# kpts, descriptors = des_ext.compute(img, kpts)
# location = [6.908844, 79.6454667]
# location = np.array(location)
clusterNumber = self.findCluster(location.reshape(1,-1))
file_name = "Cluster_" + str(clusterNumber[0]) + ".pkl"
clf, classes_names, stdSlr, k, voc = joblib.load(file_name)
test_features = np.zeros((1, k), "float32")
words, distance = vq(descriptors, voc)
for w in words:
test_features[0][w] += 1
test_features = stdSlr.transform(test_features)
writer=csv.writer(open("buddha_statue_test_data.csv",'a+'))
try:
predictions = [classes_names[i] for i in clf.predict(test_features)]
prediction_probability = np.amax(clf.predict_proba(test_features))
print str(predictions[0]) + " - " + str(prediction_probability)
data_row = []
data_row.append(str(predictions[0]))
data_row.append(str(prediction_probability))
writer.writerow(data_row)
except Exception as e:
print e
connection = Connector()
connection.makeConnection()
if(prediction_probability>=0.8):
results = connection.retriveLandmarkDescription(predictions[0])
connection.closeConnection()
data=[]
suggetion_path = "dataset/landmarks/" + str(results[0].Name)
image_names = os.listdir(suggetion_path)
full_path = os.path.join(suggetion_path, image_names[0])
with open(full_path, "rb") as imageFile:
encoded_image = base64.b64encode(imageFile.read())
data.append({
"thumbnail": encoded_image,
"location": {
"Lognitude": results[0].location,
"Latitiude": results[0].location2
},
"description": results[0].Description,
"title": results[0].Name,
"key": str(results[0].rid),
})
json_data = json.dumps(data)
print json_data
return json_data
else:
results = connection.getLandmarkSuggestions(clusterNumber[0])
data = []
for i in range(len(results)):
suggetion_path = "dataset/landmarks/" + str(results[i].Name)
image_names = os.listdir(suggetion_path)
full_path = os.path.join(suggetion_path, image_names[0])
with open(full_path, "rb") as imageFile:
encoded_image = base64.b64encode(imageFile.read())
data.append({
"thumbnail": encoded_image,
"location": {
"Lognitude": results[i].location,
"Latitiude": results[i].location2
},
"description": results[i].Description,
"title": results[i].Name,
"key": str(results[i].rid),
})
json_data = json.dumps(data)
print json_data
connection.closeConnection()
return json_data
class ExecEngine:
"""Python Client interface to the SqlFactory SMD service """
FETCH_ALL = -1 # get all results in one call (USE CAUTIOUSLY)
CLASSFACTORY = "com.sefas.EngineStarter.SmdEngineStarter"
METHOD_ADD_ENV = "addEnv"
METHOD_ADD_PARAM = "addParam"
METHOD_LOAD_ENV_PROP = "loadEnvProp"
METHOD_LOAD_ENGINES_PROP = "loadEnginesProp"
METHOD_LOCK = "lock"
METHOD_START = "start"
METHOD_START_ASSEMBLY = "startAssembly"
METHOD_START_CODR = "startCodr"
METHOD_START_COMPO = "startCompo"
METHOD_START_DRV = "startDrv"
METHOD_START_SORT = "startSort"
METHOD_RESULT_LOG = "resultLog"
METHOD_RESULT_EXIT_CODE = "resultExitCode"
METHOD_RESULT_ERR = "resultErr"
METHOD_RESULT_MESSAGE = "resultMessage"
METHOD_RESULT_VERSION = "resultVersion"
METHOD_PARAM_VARNAME = "paramVarName"
METHOD_PARAM_VARVALUE = "paramVarValue"
METHOD_PARAM_FILENAME = "paramFileName"
METHOD_PARAM_LOCK = "paramLock"
METHOD_PARAM_ENGINE_KEY = "engineKey"
def __init__ (self ,
encoding="UTF8" , # default encoding to UTF8
hostName="localhost" ,
port=29100
):
""" constructor just store provided object information """
self._host = hostName
self._port = port
self._connection = None
self._encoding = encoding
self._param = {}
self._env = {}
self._paramSended = {}
self._envSended = {}
self._engineProp = None
self._envProp = None
self._islock = True
def connect(self) :
""" connect to SqlFactory Service """
if (self._connection != None):
return
self._connection = Connector(self._host , self._port , self._encoding, self.CLASSFACTORY)
self.lock(True)
def disconnect(self):
""" Disconnect from SqlFactory Service """
if (self._connection != None):
self._connection.close()
self._connection = None
def addEnv (self, envVarName, envVarValue):
""" add an environment variable to the call """
self._env[envVarName] = envVarValue
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, self.METHOD_ADD_ENV)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, self.METHOD_PARAM_VARNAME)
self._connection.marshall(Connector.SET_VALUE, self.METHOD_PARAM_VARNAME, envVarName)
self._connection.marshall(Connector.DEF_STRING, self.METHOD_PARAM_VARVALUE)
self._connection.marshall(Connector.SET_VALUE, self.METHOD_PARAM_VARVALUE, envVarValue)
# proceed with call
return self._connection.marshall(Connector.CALL)
def addParam (self, paramVarName, paramVarValue):
""" add a parameter to the call """
self._param[paramVarName] = paramVarValue
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, self.METHOD_ADD_PARAM)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, self.METHOD_PARAM_VARNAME)
self._connection.marshall(Connector.SET_VALUE, self.METHOD_PARAM_VARNAME, paramVarName)
self._connection.marshall(Connector.DEF_STRING, self.METHOD_PARAM_VARVALUE)
self._connection.marshall(Connector.SET_VALUE, self.METHOD_PARAM_VARVALUE, paramVarValue)
# proceed with call
return self._connection.marshall(Connector.CALL)
def loadEnvProp (self, envPropertiesFileName):
""" set the environement properties file name to be used on the server """
self._envProp = envPropertiesFileName
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, self.METHOD_LOAD_ENV_PROP)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, self.METHOD_PARAM_FILENAME)
self._connection.marshall(Connector.SET_VALUE, self.METHOD_PARAM_FILENAME, envPropertiesFileName)
# proceed with call
return self._connection.marshall(Connector.CALL)
def loadEnginesProp (self, enginesPropertiesFileName):
""" set the propertie file name of the server to be used """
self._engineProp = enginesPropertiesFileName
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, self.METHOD_LOAD_ENGINES_PROP)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, self.METHOD_PARAM_FILENAME)
self._connection.marshall(Connector.SET_VALUE, self.METHOD_PARAM_FILENAME, enginesPropertiesFileName)
# proceed with call
return self._connection.marshall(Connector.CALL)
def lock (self, synchronizedCall):
""" management of the sychroneous or asynchroneus call """
self._islock = synchronizedCall
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, self.METHOD_LOCK)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, self.METHOD_PARAM_LOCK)
if synchronizedCall:
self._connection.marshall(Connector.SET_VALUE, self.METHOD_PARAM_LOCK, "true")
else :
self._connection.marshall(Connector.SET_VALUE, self.METHOD_PARAM_LOCK, "false")
# proceed with call
return self._connection.marshall(Connector.CALL)
def start (self, engineKey):
""" execute the command on the smd server """
self._connection.marshall(Connector.SET_METHOD, self.METHOD_START)
# populate parameters
self._connection.marshall(Connector.DEF_STRING, self.METHOD_PARAM_ENGINE_KEY)
self._connection.marshall(Connector.SET_VALUE, self.METHOD_PARAM_ENGINE_KEY, engineKey)
# proceed with call
return self._connection.marshall(Connector.CALL)
def getReturnDetail (self):
self._connection.marshall(Connector.SET_METHOD, self.METHOD_RESULT_EXIT_CODE)
exitCode = self._connection.unmarshall(self._connection.marshall(Connector.CALL))
self._connection.marshall(Connector.SET_METHOD, self.METHOD_RESULT_VERSION)
version = self._connection.unmarshall(self._connection.marshall(Connector.CALL))
self._connection.marshall(Connector.SET_METHOD, self.METHOD_RESULT_MESSAGE)
message = self._connection.unmarshall(self._connection.marshall(Connector.CALL))
self._connection.marshall(Connector.SET_METHOD, self.METHOD_RESULT_LOG)
log = self._connection.unmarshall(self._connection.marshall(Connector.CALL))
self._connection.marshall(Connector.SET_METHOD, self.METHOD_RESULT_ERR)
err = self._connection.unmarshall(self._connection.marshall(Connector.CALL))
return "Exit Code = %s\nVersion = %s\nMessage = %s\nLog = %s\nError = %s" %(exitCode,version,message,log,err)
def printReturnDetail (self):
print self.getReturnDetail()
def manageExecReturn (self, ret):
""" execute the command on the smd server """
returned = int(self._connection.unmarshall( ret ))
if returned != 0:
print "Execution return code not 0 : "
self.printReturnDetail()
def cleanup():
# Disconnecting before exit
logger.debug("Cleanup operations initiated")
connector.disconnect(status="405")
connector.view.close()
logger.debug("All cleanup operations completed")
# Logging system initialization
# sys.stdout = open("log.txt", "a+")
# sys.stderr = open("errors.txt", "a+")
logger = logging.getLogger('RocketOne')
logger.setLevel(logging.DEBUG)
fh = logging.handlers.RotatingFileHandler('debug.log',
mode='a',
maxBytes=524288,
backupCount=0)
fh.setLevel(logging.INFO)
formatter = logging.Formatter(
'%(asctime)s - %(levelname)s - %(name)s - %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
logger.info('Launch')
app = QtGui.QApplication(sys.argv)
connector = Connector()
connector.read_settings()
# Perform some cleanup before exit
sys.exitfunc = cleanup
sys.exit(app.exec_())
def updateLandmarkClass(self):
connection = Connector()
connection.makeConnection()
connection.updateLandmarkClusterID(self.clusterList, self.landmarks)
connection.closeConnection()
def __init__(self):
self.tasks = []
self.dbmgr = DBManager()
self.c = Connector()
self.data = ""
import gdata.apps
#Example how to authorize you application service
from Connector import Connector
multidomainObj = gdata.apps.service.AppsService()
Connector.connectByOauth(multidomainObj)
print multidomainObj.RetrieveAllUsers()
#Example how to create OAuth token
from OAuth import OAuth
from OAuth import POSSIBLE_SCOPES
OAuth(domain="gridcommons.com",
clientKey="your client key",
clientSecret="your client secret",
scopes=POSSIBLE_SCOPES,
appName="application name").getAccessToken()
def __init__(self):
self.tasks = []
self.dbmgr = DBManager()
self.c = Connector()
self.data = ""
self.receipt_done = dict()
def connect(self) :
""" connect to SqlFactory Service """
if (self._connection != None):
return
self._connection = Connector(self._host , self._port , self._encoding, self.CLASSFACTORY)
self.lock(True)
class OsCommandClient:
"""Python Client interface to the SqlFactory SMD service """
FETCH_ALL = -1 # get all results in one call (USE CAUTIOUSLY)
CLASSFACTORY = "com.sefas.gridclient.osservices.OsCommandFactory"
STRCR = "\\n"
CR = "\n"
COMMAND = "command"
GETSTDOUT = "getStdOut"
GETSTDERR = "getStdErr"
_ENCODING_PROPERTY_ = "file.encoding"
_ARGS_ = "args"
def __init__ ( self ,
encoding="UTF8" , # default encoding to UTF8
hostName="localhost" ,
port=29100
):
""" constructor just store provided object information """
self._host = hostName
self._port = port
self._connection = None
self._encoding = encoding
def connect( self ) :
""" connect to SqlFactory Service """
if ( self._connection != None ):
return
self._connection = Connector( self._host , self._port , self._encoding, self.CLASSFACTORY )
def disconnect( self ):
""" Disconnect from SqlFactory Service """
if ( self._connection != None ):
self._connection.close()
self._connection = None
def command ( self, commandLine, priority=PRIORITY_UNUSED):
""" execute the command on the smd server """
self._connection.marshall( Connector.SET_METHOD, self.COMMAND)
# populate parameters
self._connection.marshall( Connector.DEF_STRING, self._ARGS_)
self._connection.marshall( Connector.SET_VALUE, self._ARGS_, commandLine)
self._connection.marshall( Connector.DEF_INTEGER, self._ARGS_)
self._connection.marshall( Connector.SET_VALUE, self._ARGS_, priority)
# proceed with call
ret = self._connection.marshall( Connector.CALL )
# marshall cursor id back or None if cursorId is -1
returned = int(self._connection.unmarshall( ret ))
if returned == -1 :
return None
return returned
def getStd ( self, which):
""" execute the command on the smd server """
self._connection.marshall( Connector.SET_METHOD, which)
# proceed with call
ret = self._connection.marshall( Connector.CALL )
returned = self._connection.unmarshall( ret )
return returned
def getStdOut ( self):
return self.getStd(self.GETSTDOUT)
def getStdErr ( self):
return self.getStd(self.GETSTDERR)
def addConnector(self, children):
name = self.name + str(len(self.connectors))
connector = Connector(self, name)
for child in children:
connector.addNode(child)
self.connectors[name] = connector
def run_detector():
# import os
# os.environ['SDL_VIDEODRIVER'] = 'windib'
# os.environ['SDL_VIDEODRIVER'] = 'directx'
parser = OptionParser(usage="""\
Detect SnapMyinfo QRcodes in a live video stream
Usage: %prog [options] camera_index
""")
parser.add_option('-f','--fs','--fullscreen',
dest="fullscreen", default=False,
action='store_true',
help="""Run the Live Decoder full screen.""")
parser.add_option('--hw','--hw_accel',
dest="hw_accel", default=False,
action='store_true',
help="""Runs pygame with the directx hw driver (if avail). Automatically assumes fullscreen.""")
parser.add_option('-s','--scale',
dest="scale", default=4.0,
action='store', type="float",
help="""Sets the precision of code tracking. Valid values are >1.0 and less than 8.0. Lower values represent more accurate tracking, but consume more CPU.""")
parser.add_option('--flip',
dest="flip", default=False,
action='store_true',
help="""Flip the video image horizontally before processing.""")
parser.add_option('-m','--max_cards',
dest="tracker_count", default=3, type="int",
action="store",
help="""The number of simultaneous snap codes that can be tracked in the video stream.""")
parser.add_option('--nv','--no_video',
dest="no_video", default=False,
action="store_true",
help="""A debugging option, turns off the video stream from the web cam.""")
parser.add_option('-d','--debug',
dest="debug", default=False,
action="store_true",
help="""Debugging option, turns on fps display and additional tracking data on the display.""")
opts, args = parser.parse_args()
import os
os.environ['SDL_VIDEODRIVER'] = 'windib'
if opts.hw_accel:
os.environ['SDL_VIDEODRIVER'] = 'directx'
opts.fullscreen = True
# initialize pygame
pygame.init()
display_size = (800,600)
video_size = (1280,720)
# scale is roughly equivalent to tracking precision
# the higher the scale, the less precise, but faster, the gross
# tracking will be scale of 1 means 1:1 tracking, but can be slow
# recommend 2-4 as a good scale/precision factor. higher res images
# usually benefit from higher scale
scale = opts.scale
# this can be used to throttle the max framerate processed. 0 means no throttle
max_frame_rate = 30
names = [args[0]]
name = names[0]
if not opts.no_video:
# connect to web camera and set the webcam options
capture = cvCreateCameraCapture( int(name) )
cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_WIDTH, video_size[0] )
cvSetCaptureProperty( capture, CV_CAP_PROP_FRAME_HEIGHT, video_size[1] )
# query the camera once to get the camera properties
# the frame is just a throwaway
cvQueryFrame( capture )
# get the camera properties
(o_width,o_height) = [cvGetCaptureProperty(capture, prop) for prop in [CV_CAP_PROP_FRAME_WIDTH,CV_CAP_PROP_FRAME_HEIGHT]]
video_size = (int(o_width),int(o_height))
else:
blank = cvCreateImage(video_size,8,3)
cvZero(blank)
# create the pygame display
flags = 0
if opts.fullscreen:
flags = pygame.FULLSCREEN
if opts.hw_accel:
flags = flags|pygame.HWSURFACE|pygame.DOUBLEBUF
display_layer = pygame.display.set_mode( display_size, flags )
video = pygame.Surface(video_size).convert()
# set the window name
pygame.display.set_caption('Live Detector')
# some debug information
# print the current driver being used
print 'Driver %s\nVideo Input Resolution: %s\nDisplay Resolution: %s\n' % (pygame.display.get_driver(), video_size, display_size)
# for convert to work, pygame video mode has to be set
image_buffer = ImageBuffer(video_size,display_size,scale)
if opts.no_video:
image_buffer.frame_buffer = cvCreateImage(video_size,8,3)
# blank = cvCreateImage(video_size,8,3)
# cvZero(blank)
worker = GrossTracker(image_buffer)
# pool of tracker objects
pool = TrackerPool(image_buffer, opts.tracker_count)
thread_objects.append(pool)
status = Status()
connector = Connector(pool,status)
connector.start()
thread_objects.append(connector)
# for i in range(4):
# win_name = "thread-%d" % i
# cvNamedWindow(win_name, CV_WINDOW_AUTOSIZE)
pyg_clock = pygame.time.Clock()
update_count = 0
last_rects = []
last_fills = []
hud_last_fills = []
if opts.debug:
dbg = DebugDisplay()
snap_logo = pygame.image.load('./images/snap_logo.png').convert_alpha()
still = False
running = True
fps = 0.0
while running:
pyg_clock.tick(max_frame_rate)
if update_count > 20:
fps = pyg_clock.get_fps()
update_count = 0
update_count += 1
# get the pygame events
events = pygame.event.get()
for e in events:
# 'quit' event key
if e.type == QUIT or (e.type == KEYDOWN and e.key == K_ESCAPE):
running = False
elif e.type == KEYDOWN and e.unicode == u't':
still = True
# take a frame from the web camera
if opts.no_video:
cvCopy(blank,image_buffer.frame_buffer)
else:
image_buffer.frame_buffer = cvQueryFrame( capture )
if opts.flip:
cvFlip(image_buffer.frame_buffer,image_buffer.frame_buffer,1)
# update the image buffer with the latest frame
image_buffer.update()
# analyze the small frame to find collapsed candidates
squares = worker.analyze_frame()
# check squares and assign a tracker if new
pool.check(squares)
# update all trackers
pool.update()
status.update()
# clear the paint buffer
for rect in last_rects:
pygame.gfxdraw.rectangle(image_buffer.paint_buffer, rect, Color(0,0,0))
last_rects = []
for blank in last_fills:
image_buffer.paint_buffer.fill((0,0,0),blank)
last_fills = []
for blank in hud_last_fills:
image_buffer.hud_buffer.fill((0,0,0,0),blank)
hud_last_fills = []
# draw the sprite and tracker boundaries
# boundaries will be replaced (or turned off)
pool.sort_active()
for t_id in pool.active_trackers:
#rect = pool.trackers[t_id].get_bound_rect()
center = pool.trackers[t_id].get_avg_center(2)
frame_color = Color(128,255,128)
if pool.trackers[t_id].sprite:
# print str(dir(pool.trackers[t_id].sprite))
sprite_size = pool.trackers[t_id].sprite.get_size()
# print str(sprite_size)
x_diff = sprite_size[0] / 2.0
y_diff = sprite_size[1] / 2.0
# frame_color = Color(250,250,255)
rect = pygame.Rect(center.x * image_buffer.display_scale[0] - x_diff, center.y * image_buffer.display_scale[1] - y_diff, sprite_size[0],sprite_size[1])
# pygame.gfxdraw.rectangle(image_buffer.paint_buffer, rect, pool.trackers[t_id].color)
# last_rects.append(rect)
#if pool.trackers[t_id].user_id:
image_buffer.paint_buffer.blit(pool.trackers[t_id].sprite,(rect.x ,rect.y ))
last_fills.append(rect) #pygame.Rect(rect.x ,rect.y ,closer_img.size[0],closer_img.size[1]))
else:
# rect = pygame.Rect(center.x * scale - 100, center.y * scale - 100, 200,200)
#
#
# pygame.gfxdraw.rectangle(image_buffer.paint_buffer, rect, frame_color)
# last_rects.append(rect)
#c = pygame.Color(164,229,135,150)
#c1 = pygame.Color(164,229,135,255)
c = pygame.Color(229,229,135,200)
# c1 = pygame.Color(229,229,135,255)
pygame.gfxdraw.filled_polygon(image_buffer.hud_buffer, pool.trackers[t_id].get_bounding_points(),c)
# pygame.gfxdraw.polygon(image_buffer.hud_buffer, pool.trackers[t_id].get_bounding_points(),c1)
# pygame.gfxdraw.rectangle(image_buffer.hud_buffer, rect, frame_color)
# pygame.gfxdraw.filled_polygon(image_buffer.hud_buffer, pool.trackers[t_id].get_bounding_points(),c)
hud_last_fills.append(pool.trackers[t_id].get_bound_rect())
# draw the orphans and frame rate display
# debug for now, lets me know when it's trying to lock onto something
if opts.debug:
fps_sprite = dbg.gen_sprite('''%.2f fps''' % fps)
image_buffer.hud_buffer.blit(fps_sprite,(image_buffer.display_size[0]-100,10))
fps_rect = pygame.Rect(video_size[0]-100,10, dbg.size[0], dbg.size[1])
hud_last_fills.append(fps_rect)
for orphans in pool.orphan_frames:
for orphan in orphans:
orphan = pygame.Rect(orphan.x * image_buffer.display_scale[0], orphan.y * image_buffer.display_scale[1], orphan.width * image_buffer.display_scale[0], orphan.height * image_buffer.display_scale[1])
pygame.gfxdraw.rectangle(image_buffer.paint_buffer, orphan, Color(190,255,190))
last_rects.append(orphan)
# no data in the frame buffer means we're done
if not image_buffer.frame_buffer:
break
# Surf_dat array is not oriented the same way as the pyame display so
# first it's transposed. Then the
# the surface RGB values are not the same as the cameras
# this means that two of the channels have to be swapped in the numpy
# array before being blit'ted onto the array
surf_dat = image_buffer.frame_buffer.as_numpy_array().transpose(1,0,2)[...,...,::-1]
# blit_array zaps anything on the surface and completely replaces it with the array, much
# faster than converting the bufer to a surface and bliting it
# replaces video with the data in surf_dat
surfarray.blit_array(video,surf_dat)
# this resizes the video surface and stores it in display_layer. Completely
# overwrites whatever is in display_layer
pygame.transform.scale(video, image_buffer.display_size, display_layer)
# blit the paint buffer onto the surface. Paint buffer has a chromakey so all black values will show through
display_layer.blit(image_buffer.paint_buffer,(0,0))
# the "HUD" is added next.
display_layer.blit(image_buffer.hud_buffer,(0,0))
# Write out the status sprite to the display_layer
if status.sprite:
display_layer.blit(status.sprite,(10,image_buffer.display_size[1] - status.height - 10 ))
# finally watermark the screen with the company logo and name of the product
# putting it here means it always shows above the other layers
logo_size = snap_logo.get_size()
display_layer.blit(snap_logo,(image_buffer.display_size[0]-logo_size[0]-10 , image_buffer.display_size[1]-logo_size[1]-10))
if still == True:
pygame.image.save(display_layer, 'test.jpg')
still = False
# flip() actually displays the surface
pygame.display.flip()
# we've left the loop
# exit
print 'exiting...'
