def test_thread_local(self):
import thread
from System.Threading import Thread
x = thread._local()
#--Sanity
x.foo = 42
self.assertEqual(x.foo, 42)
global found
found = None
def f():
global found
found = hasattr(x, 'foo')
thread.start_new_thread(f, ())
while found == None:
Thread.Sleep(100)
self.assertTrue(not found)
self.assertEqual(x.__dict__, {'foo': 42})
try:
x.__dict__ = None
self.fail("Should not be able to set thread._local().__dict__!")
except AttributeError, e:
pass
def run_job(self, job, requests):
job = self.decode_job(job)
payload = {'id': job['id']}
if DEBUG: print "Running job (id: {})".format(job['id'])
try:
result = getattr(self, job['command'])(job['data'])
payload['state'] = 'success'
payload['result'] = result
except AttributeError as e:
#traceback.print_exc()
payload['state'] = 'error'
payload['result'] = 'Unknown command {}'.format(job['command'], e)
except Exception as e:
#traceback.print_exc()
payload['state'] = 'error'
payload[
'result'] = 'Exception when executing command {}: {}'.format(
job['command'], e)
payload = self.encode_job(payload)
while True:
try:
requests.post(urljoin(self.URL, '/jobs', job['id']),
json=payload)
return
except Exception as e:
if DEBUG:
print "Error sending job results (id: {}): {}".format(
job['id'], e)
Thread.Sleep(self.SLEEP)
def runProc(self):
self.running = True
while 1:
Thread.Sleep(60 * 60 * 1000)
try:
self.notify()
except:
Trace.WriteLine(sys.exc_info().ToString())
self.running = False
def test_thread(self):
from System.Threading import ParameterizedThreadStart, Thread, ThreadStart
class Sync:
hit = 0
def ThreadProcParm(parm):
parm.hit = 1
def ThreadProcNoParm():
pass
def Main():
sync = Sync()
t = Thread(ParameterizedThreadStart(ThreadProcParm))
t.Start(sync)
t.Join()
self.assertTrue(sync.hit == 1)
t = Thread(ThreadStart(ThreadProcNoParm))
t.Start()
t.Join()
Main()
def import_sys():
import sys
self.assertTrue(sys != None)
t = Thread(ThreadStart(import_sys))
t.Start()
t.Join()
so = sys.stdout
se = sys.stderr
class myStdOut:
def write(self, text):
pass
sys.stdout = myStdOut()
sys.stderr = myStdOut()
import thread
def raises(*p):
raise Exception
id = thread.start_new_thread(raises, ())
Thread.Sleep(1000) # wait a bit and make sure we don't get ripped.
sys.stdout = so
sys.stderr = se
def runProc(self):
Trace.WriteLine("Start Watching")
self.running = True
while self.interval > 0 and len(self.targets) > 0:
for target in self.targets:
try:
self.fetch(target)
except:
Trace.WriteLine(sys.exc_info().ToString())
Thread.Sleep(self.interval * 1000)
self.running = False
Trace.WriteLine("Stop Watching")
def test_new_thread_is_background(self):
from System.Threading import Thread
"""verify new threads created during Python are background threads"""
import _thread as thread
global done
done = None
def f():
global done
done = Thread.CurrentThread.IsBackground
thread.start_new_thread(f, ())
while done == None:
Thread.Sleep(100)
self.assertTrue(done)
def key_exchange(self):
while True:
try:
self.crypto = Crypto()
r = self.requests.post(self.base_url,
payload=self.crypto.public_key)
self.crypto.derive_key(r.text)
return
except Exception as e:
if DEBUG:
print "Error performing key exchange: " + str(e)
print_traceback()
Thread.Sleep(self.client.SLEEP)
def get_job(self):
self.key_exchange()
while True:
try:
job = self.requests.get(self.jobs_url).bytes
if len(job):
return JavaScriptSerializer().DeserializeObject(
Encoding.UTF8.GetString(self.crypto.Decrypt(job)))
return
except Exception as e:
if DEBUG:
print "Error performing getting jobs: " + str(e)
print_traceback()
Thread.Sleep(self.client.SLEEP)
def update():
while True:
if Misc.ReadSharedValue('run') == 'True':
hits = ((Player.Hits + .0) / Player.HitsMax) * 100
hit = int(hits)
if hit == 0:
hit = 1
def step():
count = 0
self.prog.Value = hit
self.Invoke(CallTarget0(step))
Thread.Sleep(1000)
else:
self.prog.Value = 1
def send_job_results(self, results, job_id):
self.key_exchange()
if type(results) == dict:
results = JavaScriptSerializer().Serialize(results)
elif hasattr(results, '__serialize__'):
results = JavaScriptSerializer().Serialize(results.__serialize__())
encrypted_results = self.crypto.Encrypt(results)
job_url = Uri(urljoin(self.jobs_url, job_id))
while True:
try:
self.requests.post(job_url, payload=encrypted_results)
return
except Exception as e:
if DEBUG:
print "Error performing sending job results: " + str(e)
print_traceback()
Thread.Sleep(self.client.SLEEP)
from System.IO import FileSystemWatcher, Path
from System.Threading import Thread
from UdpSender import UdpSender, port, group
directory = Path.GetDirectoryName(Path.GetFullPath(__file__))
dataFile = 'data.txt'
watcher = FileSystemWatcher()
watcher.Path = directory
watcher.Filter = dataFile
sender = UdpSender(port, group)
def onChanged(source, event):
print 'Changed:', event.ChangeType, event.FullPath
sender.send('DATA:FILE:CHANGED')
watcher.Changed += onChanged
watcher.EnableRaisingEvents = True
while True:
Thread.Sleep(1000)
import clr
clr.AddReference("mscorlib")
from System.Threading import Thread
for i in range(0, 10):
print str(i+1)
Thread.Sleep(500)
print "Done!"
print 'Changed:', event.ChangeType, event.FullPath
def onRenamed(source, event):
print 'Renamed:', event.OldFullPath, event.FullPath
watcher.Changed += onChanged
watcher.Created += onChanged
watcher.Deleted += onChanged
watcher.Renamed += onRenamed
watcher.EnableRaisingEvents = True
# wait for an hour
Thread.Sleep(60 * 1000 * 60)
"""
#HB update code from source file.
def getAllTheComponents(onlyGHPython = True):
components = []
document = ghenv.Component.OnPingDocument()
objects = list(document.Objects)
# check if there is any cluster and collect the objects inside clusters
for obj in objects:
if type(obj) == gh.Special.GH_Cluster:
clusterDoc = obj.Document("")
if not clusterDoc:
def closure():
Thread.Sleep(delay * 1000)
callback()
def ThreadMain():
try:
ie1 = IE.AttachTo[IE](Find.ByTitle("Gestione Giornaliera"))
ie2 = IE.AttachTo[IE](Find.ByTitle("Giustificativo Singolo"))
from datetime import datetime
fom = DateTime(int(ie1.SelectList(Find.ByName("cmbAnni")).SelectedOption.Value), int(ie1.SelectList(Find.ByName("cmbMesi")).SelectedOption.Value), 1)
eom = fom.AddMonths(1).AddDays(-1)
day1 = int(raw_input("Start=") or fom.Day)
day2 = int(raw_input("End=") or eom.Day)
print "%i - %i of %s" % (day1, day2, fom.ToString("MMM yyyy"))
for day in range(day1, day2+1):
ie1.Link(Find.ByText(str(day))).Click()
Thread.Sleep(1000)
f = ie1.Frame(Find.ByName("prestazioni"))
print f.Tables
print f.Tables.Count
print f.Tables.
t = f.Tables[0].Tables[0]
for r in t.TableRows:
if r.TableCells.Count >= 7:
if r.TableCells[4].Text == "Presenza Oltre Monte Ore Teorico":
inizio = r.TableCells[5].Text.strip()
fine = r.TableCells[6].Text.strip()
date = DateTime(fom.Year, fom.Month, day)
ie2.TextField(Find.ByName("cmbCodCausale")).Value = '001' # straordinari
#ie2.TextField(Find.ByName("cmbCodCausale")).Value = '008' # banca ore
ie2.TextField(Find.ByName("datai")).Value = date.ToString("dd/MM/yyyy")
ie2.TextField(Find.ByName("dataf")).Value = date.ToString("dd/MM/yyyy")
iHH, iMM = inizio.split(":")
fHH, fMM = fine.split(":")
iDT = DateTime(date.Year, date.Month, day, int(iHH), int(iMM), 0)
fDT = DateTime(date.Year, date.Month, day, int(fHH), int(fMM), 0)
ts = fDT - iDT
# print "%i\t%s\t%s - " % (day, inizio, fine)
mins = int(ts.TotalMinutes)
rmins = floor(mins/30)*30
if rmins < 60:
rmins = 0
print "%s - %s (%s mins rounded to %s - lost %s)" % (iDT, fDT, mins, rmins, mins - rmins)
fDT = iDT.AddMinutes(rmins)
fHH = "%02i" % fDT.Hour
fMM = "%02i" % fDT.Minute
if rmins > 0:
try:
ie2.SelectList(Find.ByName("cmbOraInizioPezzaHH")).Option(Find.ByValue(iHH)).Select()
except:
pass
try:
ie2.SelectList(Find.ByName("cmbOraInizioPezzaMM")).Option(Find.ByValue(iMM)).Select()
except:
pass
try:
ie2.SelectList(Find.ByName("cmbOraFinePezzaHH")).Option(Find.ByValue(fHH)).Select()
except:
pass
try:
ie2.SelectList(Find.ByName("cmbOraFinePezzaMM")).Option(Find.ByValue(fMM)).Select()
except:
pass
ie2.Button(Find.ById("buttonInserisci")).Click()
#Console.ReadLine()
Thread.Sleep(1000)
except:
import traceback
traceback.print_exc()
def blink():
for i in range(50):
global flag
ard.SetDO(ArduinoUnoPins.D13,flag)
flag = not flag
Thread.Sleep(100)
def print_hello():
for _ in range(3):
Thread.Sleep(500)
print('task---sleep')
print('hello world')
def spin():
for i in "|\-/" * 4:
print i, '\r',
Thread.Sleep(60)
print '\r'
