def Main():
parser = argparse.ArgumentParser(
description='Turbidostat controller.'
) # This section defines the command line inputs
parser.add_argument(
"-c",
"--config_filename",
default="config.ini", # This creates a command line argument c
help="Where to load configuration from.")
args = parser.parse_args()
# Startup stacktracer for debugging deadlock
stacktracer.trace_start("trace.html", interval=60, auto=True)
# Read configuration from the config file
config = SafeConfigParser()
print 'Reading config file from', args.config_filename
config.read(args.config_filename)
controller_params = dict(config.items('controller'))
port_names = dict(config.items('ports'))
pump_params = dict(config.items('pump'))
logs = dict(config.items('log'))
# Open ports
cont_port = serial.Serial(port_names['controllerport'],
int(controller_params['baudrate']),
timeout=4,
writeTimeout=1)
cont_port.lock = threading.RLock()
if (port_names['pumpport'].upper() != 'NONE'):
pump_port = serial.Serial(port_names['pumpport'],
int(pump_params['baudrate']),
timeout=1,
writeTimeout=1)
pump_port.lock = threading.RLock()
else:
pump_port = None
# Make and start the controler
cont = Controller(controller_params, logs, pump_params, cont_port,
pump_port)
cont.start()
# Setup network configue port
def cb(cmd):
if 'list' in cmd:
return str(controller_params)
netserv = CTBasicServer(('', int(port_names['network'])), cb)
netserv.start()
print 'num threads: ' + str(len(sys._current_frames().keys()))
# Run until a keyboard interrupt.
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
print 'shutting down'
cont.quit()
time.sleep(1.1)
def __init__(self):
hive.loadLogger()
self.log = logging.getLogger('botqueue')
self.workers = {}
self.workerDataAge = {}
self.config = hive.config.get()
self.lastScanData = None
#check for default info.
if not 'app_url' in self.config:
self.config['app_url'] = "https://www.botqueue.com"
hive.config.save(self.config)
#create a unique hash that will identify this computers requests
if 'uid' not in self.config or not self.config['uid']:
self.config['uid'] = hashlib.sha1(str(time.time())).hexdigest()
hive.config.save(self.config)
#slicing options moved to driver config
if 'can_slice' in self.config:
del self.config['can_slice']
hive.config.save(self.config)
#load up our api
self.api = botqueueapi.BotQueueAPI()
#this is our threading tracker
stacktracer.trace_start("trace.html", interval=5, auto=True) # Set auto flag to always update file!
def Main():
parser = argparse.ArgumentParser(description='Turbidostat controller.')
parser.add_argument("-c", "--config_filename", default="config.ini",
help="Where to load configuration from.")
args = parser.parse_args()
# Startup stacktracer for debugging deadlock
stacktracer.trace_start("trace.html", interval=60, auto=True)
# Read configuration from the config file
config = SafeConfigParser()
print 'Reading config file from', args.config_filename
config.read(args.config_filename)
controller_params = dict(config.items('controller'))
port_names = dict(config.items('ports'))
pump_params = dict(config.items('pump'))
logs = dict(config.items('log'))
# Open ports
cont_port = serial.Serial(port_names['controllerport'],
int(controller_params['baudrate']),
timeout=4,
writeTimeout=1)
cont_port.lock = threading.RLock()
if (port_names['pumpport'].upper()!='NONE'):
pump_port = serial.Serial(port_names['pumpport'],
int(pump_params['baudrate']),timeout = 1,
writeTimeout = 1)
pump_port.lock = threading.RLock()
else:
pump_port = None
# Make and start the controler
cont = Controller(controller_params, logs, pump_params,
cont_port, pump_port)
cont.start()
# Setup network configue port
def cb(cmd):
if 'list' in cmd:
return str(controller_params)
netserv = CTBasicServer(('', int(port_names['network'])), cb)
netserv.start()
print 'num threads: ' + str(len(sys._current_frames().keys()))
# Run until a keyboard interrupt.
try:
while True:
time.sleep(1)
except KeyboardInterrupt:
print 'shutting down'
cont.quit()
time.sleep(1.1)
def startServer(name):
import stacktracer
stacktracer.trace_start("trace_" + str(name) + ".html",interval=2,auto=True) # Set auto flag to always update file!
daemon = Pyro4.Daemon()
simserver = Server(name, daemon)
ns = Pyro4.locateNS()
uri = daemon.register(simserver)
ns.register(str(name), uri)
# Run the loop until something happens (probably keyboardinterrupt...)
try:
daemon.requestLoop()
except:
daemon.shutdown()
fcomment = open(self.comment_info_path , 'w')
for topic_id in self.topic_dict:
topic = self.topic_dict[topic_id]
s = topic.getSimpleString(delimiter = '[=]')
ftopic.write(s + '\n[*ROWEND*]\n')
for comment in topic.comment_list:
cs = comment.getSimpleString(delimiter = '[=]')
fcomment.write(cs + '\n[*ROWEND*]\n')
ftopic.close()
fcomment.close()
'''
if __name__ == "__main__":
LINE_FEED = "\n" # 采用windows的换行格式
stacktracer.trace_start("trace.html",interval=5,auto=True) # Set auto flag to always update file!
congifLogger("log/comment_crawler.log", 5)
#group_id_list = ['FLL', '294806', 'MML']
#group_id_list = ['test']
#group_id_list = ['70612', 'FLL']
group_id_list = []
if len(sys.argv) <= 1:
print "Group IDs were not provided."
sys.exit()
# add group ids
for i in range(1, len(sys.argv)):
group_id_list.append(sys.argv[i])
print "Crawling comments for groups: ", group_id_list
MAX_TOPIC_NUM = float('inf') # 每个小组最多处理的topic的个数
from queue import Queue
import stacktracer
q = Queue()
stacktracer.trace_start("trace.html")
class Circular(object):
def __init__(self):
self.circular = self
def __del__(self):
print("Adding to queue in GC")
q.put(1)
for i in range(10000000):
print("iteration", i)
# Create an object that will be garbage collected
# asynchronously, and therefore have its __del__
# method called later:
Circular()
print("Adding to queue regularly")
q.put(2)
parser.add_argument(
"-s",
"--cylinder",
help=
"Print Which pinch valve you want dispense through (value = 1-8), ex. printing 2 will dispense into cylinder 2"
)
parser.add_argument(
"-v",
"--volume",
help=
"Print the volume you want pumped between 0 - 2000 in the format ####. ex. to pump 500ul print 0500"
)
args = parser.parse_args()
# Startup stacktracer for debugging deadlock
stacktracer.trace_start("trace.html", interval=60, auto=True)
# Read configuration from the config file
config = SafeConfigParser()
print 'Reading config file from', args.config_filename
config.read(args.config_filename)
controller_params = dict(config.items('controller'))
port_names = dict(config.items('ports'))
pump_params = dict(config.items('pump'))
logs = dict(config.items('log'))
cport = serial.Serial(port_names['controllerport'],
int(controller_params['baudrate']),
timeout=4,
writeTimeout=1)
import serial
import time
import requests
import threading
import sys
import Queue
import collections
import ConfigParser
import pickle
import signal
import io
#This is debugging code that dumps a stack trace every 5s
import stacktracer
stacktracer.trace_start("/tmp/trace.html")
from termcolor import colored
### SETTINGS ###
try:
Config = ConfigParser.ConfigParser()
Config.read(sys.argv[1])
ServerUrl = Config.get('GeneralSettings', 'ServerUrl')
ShortUrl = Config.get('GeneralSettings', 'ShortUrl')
JpegUrl = Config.get('GeneralSettings', 'JpegUrl')
SerialDevice = Config.get('DisplaySettings', 'SerialDevice')
BaudRate = Config.getint('DisplaySettings', 'BaudRate')
StartMessage = Config.get('DisplaySettings', 'StartMessage') + " " + ShortUrl
import threading
import time
import stacktracer
stacktracer.trace_start("trace.html")
biA = 1
biA_lock = threading.Lock() # biA lock
biB = 1
biB_lock = threading.Lock() # biB lock
def diao1():
global biA, biB
print "diao1 acquiring lock biA"
biA_lock.acquire() # diao1 start cao biA
time.sleep(5) # 5 miao jiu she
print "diao1 acquiring lock biB"
biB_lock.acquire() # diao1 start cao biB
time.sleep(5) # 5 miao jiu she
biA += 5
biB += 5
print "diao1 releasing both locks"
biB_lock.release()
biA_lock.release()
def diao2():
global biA, biB
print "diao2 acquiring lock biB"
biB_lock.acquire() # diao2 start cao biB
time.sleep(5) # 5 miao she
#!/usr/bin/env python
# coding: utf-8
r"""Start with Trace"""
from stacktracer import trace_start, trace_stop
if __name__ == '__main__':
trace_start("trace.html", interval=5, auto=True)
from cvlab import main
main()
trace_stop()
import stacktracer
stacktracer.trace_start("trace.html", interval=5,
auto=True) # Set auto flag to always update file!
import regression.normal as experiment
import logging
experiment.sim("exp.log", ('localhost', 514), logging.DEBUG)
if not environ.get('PYSTACIA_SETUP'):
from logging import getLogger, basicConfig
logger = getLogger('pystacia')
level = environ.get('PYSTACIA_LOG')
if level:
basicConfig(level=int(level),
format='%(asctime)s %(name)-12s %(thread)d %(message)s')
logger.debug('Imported main module')
if environ.get('PYSTACIA_TRACE'):
logger.debug('Starting tracing')
import stacktracer # @UnresolvedImport
stacktracer.trace_start('trace.html', interval=5, auto=True)
from pystacia.util import Registry
registry = Registry()
from pystacia import color
colors = color.Factory()
"""Convenience factory for SVG names"""
def lazy_imported(key):
def call(*args, **kw):
from pystacia import image
return getattr(image, key)(*args, **kw)
