def __init__(self, crypter, negotiator):
asynchat.async_chat.__init__(self)
self.received_data = ''
self.crypter = crypter
self.negotiator = negotiator
self.set_terminator(MessageManager.MULTI_MESSAGE_DELIMITER)
self.negotiation_lock = mutex.mutex()
self.progress_lock = mutex.mutex()
self.in_step_through_mode = False
self.shared_secret = ""
self.integrity_hash = None
self.logger = None
self.debugger = None
self.debugger_raw = None
def compare_all_files(file_name='file', magdir='Magdir', exact=False):
pool = ThreadPool(4)
m = mutex.mutex()
split_patterns(magdir, file_name)
compile_patterns(file_name)
compiled = is_compilation_supported(file_name)
entries = get_stored_files("db")
def store_mimedata(data):
metadata = get_full_metadata(data[0], file_name, compiled)
stored_metadata = get_stored_metadata(data[0])
text = "PASS " + data[0]
if is_regression(stored_metadata, metadata, exact):
text = "FAIL " + data[0] + "\n" + get_diff(stored_metadata,
metadata, exact)
return text
def data_print(data):
print data
m.unlock()
def data_stored(data):
m.lock(data_print, data)
for i, entry in enumerate(entries):
# Insert tasks into the queue and let them run
pool.queueTask(store_mimedata, (entry, i % 2), data_stored)
# When all tasks are finished, allow the threads to terminate
pool.joinAll()
print ''
def __init__(self,
name,
dim=100,
window=10,
min_count=1,
parallelism=1,
use_stem=False,
iterations=100,
learning_rate=0.025):
self.name = name
self.dimension = dim
self.window = window
self.min_count = min_count
self.parallelism = parallelism
self.sample = 1
self.iterations = iterations
self.alpha = learning_rate
self.sentence_func = self.strip_non_ascii
self.stemmer = PorterStemmer().stem if use_stem else lambda e: e
self.stop_words = stopwords.words('english')
self.stopwords = {self.stemmer(w): True for w in self.stop_words}
self.tokenizer = self.form_sentences
self.train_lock = mutex.mutex()
self.doc_tags = {}
self.model = None
def __init__(self, needed_caps):
self._width = None
self._height = None
self._current_frame = None
gobject.threads_init()
self._mutex = mutex()
gst.Bin.__init__(self)
self._capsfilter = gst.element_factory_make('capsfilter', 'capsfilter')
self.set_caps(needed_caps)
self.add(self._capsfilter)
fakesink = gst.element_factory_make('fakesink', 'fakesink')
fakesink.set_property("sync", True)
self.add(fakesink)
self._capsfilter.link(fakesink)
pad = self._capsfilter.get_pad("sink")
ghostpad = gst.GhostPad("sink", pad)
pad2probe = fakesink.get_pad("sink")
pad2probe.add_buffer_probe(self.buffer_probe)
self.add_pad(ghostpad)
self.sink = self._capsfilter
def __init__(self, uid, path): self.id = None self.proxy = None self.uid = uid self.path = path self.mutex = mutex.mutex() self.loaded = False
def __init__(self, screen, num, image, sprites):
"""
initialising
:param screen: main view screen
:param num: number of client
:param image: image of player
:param sprites: another objects in game
:param players: another players
:return:
"""
self.active = False
self.sprites = sprites
self.movingright = False
self.movingleft = False
self.num = num
self.__posx = random.randint(0, LENGTH_BOUND)
self.__posy = random.randint(MAGIC_TWNT, HIGH_BOUND - DIST_DIFF)
self.playerview = PlayerView(screen, self, image)
self.dx = 0
self.jumping = False
self.jump_speed = 0
self.jump_acceleration = 0
self.landed = False
self.died = False
self.send_died = False
self.score = 0
self.onboard = False
self.movingactions = dict()
self.movingactions[LEFT] = self.lefthandler
self.movingactions[RIGHT] = self.righthandler
self.movingactions[JUMP] = self.jumphandler
self.mutex = mutex.mutex()
def __init__(self, nResolutionW, nResolutionH):
self.nResolutionW = nResolutionW # rendeing resolution, could and will be different than window size
self.nResolutionH = nResolutionH
# but for the moment, they are of the same size
self.listPts = [
] # a list of list of coord (one for each trace) (currently traced)
self.listFigures = []
self.listLinks = []
# this is an image used for shape sorting: each inner shape will be paint with a specific color
# and then a direct piking from mouse pointing will tell us, if we're inside or outside...
# index => index of shape
# 0 .. 1023 => rect (actually 0 .. kNbrFiguresPerShapeStyle
# 1024.. 2047 => rect with title
# ...
self.kNbrFiguresPerShapeStyle = 1024
#self.sortbuf = numpy.zeros((nResolutionH,nResolutionW,1), numpy.uint16)
self.repaintSortBuf()
self.nGridSize = 20
self.bMouseDown = False
self.aMouseDownPos = []
self.mutexMouse = mutex.mutex()
self.figMoved = None # a shape currently moving with mouse
self.nIdxFigSelected = -1
self.strSaveFilename = "/tmp/fastscheme.dat"
self.loadFromDisk()
def __init__(self):
pos_dist = np.load("/home/ubuntu/TLD/posDist.npy").tolist()
neg_dist = np.load("/home/ubuntu/TLD/negDist.npy").tolist()
self.active = True
self.bridge = CvBridge()
self.Detector = Detector()
self.Detector.set_posterior(pos_dist, neg_dist)
self.Tracker = Tracker()
self.tracking = False
self.sub_image = rospy.Subscriber(
"/autopilot/camera_node/image/compressed",
CompressedImage,
self.cbImage,
queue_size=1)
self.pub_image = rospy.Publisher("~image_with_detection",
Image,
queue_size=1)
self.pub_vehicle_detected = rospy.Publisher("~vehicle_detected",
VehicleDetected,
queue_size=1)
self.pub_vehicle_bbox = rospy.Publisher("~vehicle_bounding_box",
VehicleBoundingBox,
queue_size=1)
self.lock = mutex()
bbox = []
self.tracking = True
def __init__(self, needed_caps):
self._width = None
self._height = None
self._current_frame = None
gobject.threads_init()
self._mutex = mutex()
gst.Bin.__init__(self)
self._capsfilter = gst.element_factory_make('capsfilter', 'capsfilter')
self.set_caps(needed_caps)
self.add(self._capsfilter)
fakesink = gst.element_factory_make('fakesink', 'fakesink')
fakesink.set_property("sync", True)
self.add(fakesink)
self._capsfilter.link(fakesink)
pad = self._capsfilter.get_pad("sink")
ghostpad = gst.GhostPad("sink", pad)
pad2probe = fakesink.get_pad("sink")
pad2probe.add_buffer_probe(self.buffer_probe)
self.add_pad(ghostpad)
self.sink = self._capsfilter
def __init__(self):
self.node_name = rospy.get_name()
self.bridge = CvBridge()
self.distance_between_centers = self.setupParam(
'distance_between_centers', 0.0125)
self.max_reproj_pixelerror_pose_estimation = self.setupParam(
'max_reproj_pixelerror_pose_estimation', 5)
self.sub_corners = rospy.Subscriber("~corners",
VehicleCorners,
self.processCorners,
queue_size=1)
self.pub_pose = rospy.Publisher("~pose", VehiclePose, queue_size=1)
self.sub_info = rospy.Subscriber("~camera_info",
CameraInfo,
self.processCameraInfo,
queue_size=1)
self.pub_time_elapsed = rospy.Publisher("~pose_calculation_time",
Float32,
queue_size=1)
self.pcm = PinholeCameraModel()
rospy.loginfo("[%s] Initialization completed" % (self.node_name))
self.lock = mutex()
def __init__(self):
try:
self.mutex
except:
self.audioProxy = naoqi.ALProxy("ALAudioPlayer")
self.mutex = mutex.mutex()
self.aSoundBank = {}
def __init__(self):
if (system.isOnNao()):
self.strFileName = "/home/nao/www/blog/index.html"
elif (system.isOnWin32()):
self.strFileName = "D:/ApacheRootWebSite2/htdocs/naoblog/index.html"
else:
self.strFileName = "/www/blog"
self.strImgFolderAbs = os.path.dirname(self.strFileName) + "/img/"
self.strImgFolderLocal = "img/"
self.strEmoFolderAbs = os.path.dirname(self.strFileName) + "/emo/"
self.strEmoFolderLocal = "emo/"
self.logMutex = mutex.mutex()
self.logLastTime = None
# constants:
self.none = 0
self.happy = 1
self.sad = 2
self.proud = 3
self.excitement = 4
self.fear = 5
self.anger = 6
self.neutral = 7
self.hot = 8
def __init__(self):
self.node_name = rospy.get_name()
self.bridge = CvBridge()
self.active = True
self.config = self.setupParam("~config", "baseline")
self.cali_file_name = self.setupParam("~cali_file_name", "default")
rospack = rospkg.RosPack()
self.cali_file = rospack.get_path('duckietown') + \
"/config/" + self.config + \
"/vehicle_detection/vehicle_detection_node/" + \
self.cali_file_name + ".yaml"
if not os.path.isfile(self.cali_file):
rospy.logwarn("[%s] Can't find calibration file: %s.\n"
% (self.node_name, self.cali_file))
self.loadConfig(self.cali_file)
self.sub_image = rospy.Subscriber("~image", Image,
self.cbImage, queue_size=1)
self.sub_switch = rospy.Subscriber("~switch", BoolStamped,
self.cbSwitch, queue_size=1)
self.pub_detection = rospy.Publisher("~detection",
BoolStamped, queue_size=1)
self.pub_circlepattern_image = rospy.Publisher("~circlepattern_image",
Image, queue_size=1)
self.pub_time_elapsed = rospy.Publisher("~detection_time",
Float32, queue_size=1)
self.lock = mutex()
rospy.loginfo("[%s] Initialization completed" % (self.node_name))
def __init__(self, value_type=None, py_value=None):
self._del_mutex = mutex.mutex()
GObjectModule.Value.__init__(self)
if value_type is not None:
self.init(value_type)
if py_value is not None:
self.set_value(py_value)
def __init__(self):
try:
self.mutex
except:
self.audioProxy = naoqi.ALProxy("ALAudioPlayer")
self.mutex = mutex.mutex()
self.aSoundBank = {}
def __init__(self, uid, path):
self.id = None
self.proxy = None
self.uid = uid
self.path = path
self.mutex = mutex.mutex()
self.loaded = False
def __init__(self):
self.node_name = rospy.get_name()
self.bridge = CvBridge()
self.active = True
self.publish_freq = self.setupParam("~publish_freq", 2.0)
self.circlepattern_dims = tuple(self.setupParam('~circlepattern_dims/data', [7, 3]))
self.blobdetector_min_area = self.setupParam('~blobdetector_min_area', 10)
self.blobdetector_min_dist_between_blobs = self.setupParam('~blobdetector_min_dist_between_blobs', 2)
self.publish_circles = self.setupParam('~publish_circles', True)
self.publish_duration = rospy.Duration.from_sec(1.0/self.publish_freq)
self.last_stamp = rospy.Time.now()
self.lock = mutex()
self.sub_image = rospy.Subscriber("~image", CompressedImage,
self.processImage, buff_size=921600,
queue_size=1)
self.sub_switch = rospy.Subscriber("~switch", BoolStamped,
self.cbSwitch, queue_size=1)
self.pub_detection = rospy.Publisher("~detection",
BoolStamped, queue_size=1)
self.pub_corners = rospy.Publisher("~corners",
VehicleCorners, queue_size=1)
self.pub_circlepattern_image = rospy.Publisher("~circlepattern_image",
Image, queue_size=1)
self.pub_time_elapsed = rospy.Publisher("~detection_time",
Float32, queue_size=1)
rospy.loginfo("[%s] Initialization completed" % (self.node_name))
def __init__(self):
self.node_name = rospy.get_name()
self.bridge = CvBridge()
self.config = self.setupParam("~config", "baseline")
self.cali_file_name = self.setupParam("~cali_file_name", "default")
rospack = rospkg.RosPack()
self.cali_file = "/code/catkin_ws/src/dt-core/packages/vehicle_detection/config/vehicle_filter_node/" + \
self.cali_file_name + ".yaml"
if not os.path.isfile(self.cali_file):
rospy.logwarn("[%s] Can't find calibration file: %s.\n" %
(self.node_name, self.cali_file))
self.loadConfig(self.cali_file)
self.sub_corners = rospy.Subscriber("~corners",
VehicleCorners,
self.processCorners,
queue_size=1)
self.pub_pose = rospy.Publisher("~pose", VehiclePose, queue_size=1)
self.sub_info = rospy.Subscriber("~camera_info",
CameraInfo,
self.processCameraInfo,
queue_size=1)
self.pub_time_elapsed = rospy.Publisher("~pose_calculation_time",
Float32,
queue_size=1)
self.pcm = PinholeCameraModel()
rospy.loginfo("[%s] Initialization completed" % (self.node_name))
self.lock = mutex()
def __init__(self):
if( system.isOnNao() ):
self.strFileName = "/home/nao/www/blog/index.html";
elif( system.isOnWin32() ):
self.strFileName = "D:/ApacheRootWebSite2/htdocs/naoblog/index.html";
else:
self.strFileName = "/www/blog";
self.strImgFolderAbs = os.path.dirname( self.strFileName ) + "/img/";
self.strImgFolderLocal = "img/";
self.strEmoFolderAbs = os.path.dirname( self.strFileName ) + "/emo/";
self.strEmoFolderLocal = "emo/";
self.logMutex = mutex.mutex();
self.logLastTime = None;
# constants:
self.none = 0;
self.happy = 1;
self.sad = 2;
self.proud = 3;
self.excitement = 4;
self.fear = 5;
self.anger = 6;
self.neutral = 7;
self.hot= 8;
def __init__(self):
self.node_name = rospy.get_name()
self.bridge = CvBridge()
self.config = self.setupParam("~config", "baseline")
self.cali_file_name = self.setupParam("~cali_file_name", "default")
rospack = rospkg.RosPack()
self.cali_file = rospack.get_path('duckietown') + \
"/config/" + self.config + \
"/vehicle_detection/vehicle_filter_node/" + \
self.cali_file_name + ".yaml"
if not os.path.isfile(self.cali_file):
rospy.logwarn("[%s] Can't find calibration file: %s.\n" %
(self.node_name, self.cali_file))
self.loadConfig(self.cali_file)
self.sub_corners = rospy.Subscriber("~corners",
VehicleCorners,
self.cbCorners,
queue_size=1)
self.pub_pose = rospy.Publisher("~pose", VehiclePose, queue_size=1)
self.sub_info = rospy.Subscriber("~camera_info",
CameraInfo,
self.cbCameraInfo,
queue_size=1)
self.pcm = PinholeCameraModel()
rospy.loginfo("[%s] Initialization completed" % (self.node_name))
self.lock = mutex()
def compare_all_files(file_name = 'file', magdir = 'Magdir', exact = False):
pool = ThreadPool(4)
m = mutex.mutex()
split_patterns(magdir, file_name)
compile_patterns(file_name)
compiled = is_compilation_supported(file_name)
entries = get_stored_files("db")
def store_mimedata(data):
metadata = get_full_metadata(data[0], file_name, compiled)
stored_metadata = get_stored_metadata(data[0])
text = "PASS " + data[0]
if is_regression(stored_metadata, metadata, exact):
text = "FAIL " + data[0] + "\n" + get_diff(stored_metadata, metadata, exact)
return text
def data_print(data):
print data
m.unlock()
def data_stored(data):
m.lock(data_print, data)
for i,entry in enumerate(entries):
# Insert tasks into the queue and let them run
pool.queueTask(store_mimedata, (entry, i % 2), data_stored)
# When all tasks are finished, allow the threads to terminate
pool.joinAll()
print ''
def __init__(self, nImgSizeW, nImgSizeH, nScreenSizeW, nScreenSizeH):
self.nImgSizeW = nImgSizeW # rendering resolution, could and will be different than window size
self.nImgSizeH = nImgSizeH
self.nScreenSizeW = nScreenSizeW # rendering resolution, could and will be different than window size
self.nScreenSizeH = nScreenSizeH
self.resetPixels()
self.colors = []
self.colors.append((0, 0, 0))
self.colors.append((255, 255, 255))
self.colors.append((127, 127, 127))
self.colors.append((0, 0, 255))
self.colors.append((0, 255, 0))
self.colors.append((255, 0, 0))
self.nExtraColorIndex = 2
# test:
self.pixels[0][0] = 0
self.pixels[-1][-1] = 0
self.bMouseDown = False
self.lastDrawX = self.lastDrawY = -1
self.currentColorIndex = -1
self.bAlreadyToggled = False
self.mutexMouse = mutex.mutex()
self.strSaveFilename = "/tmp/fastscheme.dat"
self.loadFromDisk()
self.computeScreenLayout()
self.timeBeginDraw = time.time()
def __init__(self):
self.node_name = rospy.get_name()
self.bridge = CvBridge()
self.active = True
self.config = self.setupParam("~config", "baseline")
self.cali_file_name = self.setupParam("~cali_file_name", "default")
rospack = rospkg.RosPack()
self.cali_file = rospack.get_path('duckietown') + \
"/config/" + self.config + \
"/vehicle_detection/vehicle_detection_node/" + \
self.cali_file_name + ".yaml"
if not os.path.isfile(self.cali_file):
rospy.logwarn("[%s] Can't find calibration file: %s.\n"
% (self.node_name, self.cali_file))
self.loadConfig(self.cali_file)
self.sub_image = rospy.Subscriber("~image", Image,
self.cbImage, queue_size=1)
self.sub_switch = rospy.Subscriber("~switch", BoolStamped,
self.cbSwitch, queue_size=1)
self.pub_detection = rospy.Publisher("~detection",
BoolStamped, queue_size=1)
self.pub_circlepattern_image = rospy.Publisher("~circlepattern_image",
Image, queue_size=1)
self.pub_time_elapsed = rospy.Publisher("~detection_time",
Float32, queue_size=1)
self.lock = mutex()
rospy.loginfo("[%s] Initialization completed" % (self.node_name))
def __init__(self):
self.map_data = {}
self.building_names = {}
self.map_mutex = mutex.mutex()
for i in range(10000):
self.map_data[i] = UDMapEntry(i)
self.load()
self.load_types()
def __init__(self):
debug.debug( "INF: PersistentMemoryDataManager.__init__ called" );
self.allData = {};
self.mutexListData = mutex.mutex();
try:
os.makedirs( PersistentMemoryData.getVarPath() );
except:
pass # le dossier existe deja !
def __init__(self, settings, camera):
self.settings = settings
self.camera = camera
self.mutex = mutex.mutex()
self.jancodes = []
self.last_appear_time = time.time()
self.shuttered = False
def __init__(self):
debug.debug("INF: PersistentMemoryDataManager.__init__ called")
self.allData = {}
self.mutexListData = mutex.mutex()
try:
os.makedirs(PersistentMemoryData.getVarPath())
except:
pass # le dossier existe deja !
def __init__(self):
try:
self.mutex
except:
self.fm = naoqi.ALProxy("ALFrameManager")
self.mutex = mutex.mutex()
self.aLoaded = {}
self.aRunning = {}
def __init__(self):
try:
self.mutex
except:
self.fm = naoqi.ALProxy("ALFrameManager")
self.mutex = mutex.mutex()
self.aLoaded = {}
self.aRunning = {}
def __init__(self) :
self.map_data = {}
self.building_names = {}
self.map_mutex = mutex.mutex()
for i in range(10000) :
self.map_data[i] = UDMapEntry(i)
self.load()
self.load_types()
def __init__(self):
self.__cmdRegex = re.compile("(?P<qtype>who|what|where|when) (?P<verb>is|are|was|were) (?P<query>[^?]+)", re.I)
self.__cacheFile = "googlism_cache"
try: self.__cache = shelve.open(self.__cacheFile, protocol=2)
except TypeError:
# pre-2.3 didn't have a protocol argument.
self.__cache = shelve.open(self.__cacheFile)
self.__cacheMutex = mutex.mutex()
self.__cacheKeys = self.__cache.keys()
def __init__(self):
self.__cmdRegex = re.compile("(?P<qtype>who|what|where|when) (?P<verb>is|are|was|were) (?P<query>[^?]+)", re.I)
self.__cacheFile = "var/cache/inet/google_cache"
try: self.__cache = shelve.open(self.__cacheFile, protocol=2)
except TypeError:
# pre-2.3 didn't have a protocol argument.
self.__cache = shelve.open(self.__cacheFile)
self.__cacheMutex = mutex.mutex()
self.__cacheKeys = self.__cache.keys()
def __init__(self, eventTgt):
logging.debug( 'Harmony __INIT__ ' )
self._eventTgt = eventTgt
threading.Thread.__init__(self)
self.harmonySkt = None
self.bufferedData = ""
self.opened = False
self.running = True
self.mut = mutex.mutex()
def __init__(self, strName = None ):
self.mutex = mutex.mutex();
self.strName = strName;
self.allValue = []; # a big array of triple [time, type, value] but because type is self explained => [time, value] # from older to newer
# precomputed value:
self.lastValue = None;
if( strName != None ):
self.readFromFile();
self.timeLastSave = time.time(); # for autosaving
def __init__(self, tmp_dir, final_dir):
self.tmp_dir = tmp_dir
self.final_dir = final_dir
self.filename = None
self.fh = None
self.mutex = mutex.mutex()
self.roll()
def __init__(self, strName=None):
self.mutex = mutex.mutex()
self.strName = strName
self.allValue = []
# a big array of triple [time, type, value] but because type is self explained => [time, value] # from older to newer
# precomputed value:
self.lastValue = None
if (strName != None):
self.readFromFile()
self.timeLastSave = time.time()
def __init__(self, port, baud, target):
self.data = 0
self.command = 0
self.port = serial.Serial(port, baudrate=baud, timeout=5)
self.lock = mutex.mutex()
self.target = target
thread = threading.Thread(target=self.run, args=())
thread.daemon = True # Daemonize thread
thread.start() # Start the execution
def _install_restore_mode_child():
global _mode_write_pipe
global _restore_mode_child_installed
if _restore_mode_child_installed:
return
# Parent communicates to child by sending "mode packets" through a pipe:
mode_read_pipe, _mode_write_pipe = os.pipe()
if os.fork() == 0:
# Child process (watches for parent to die then restores video mode(s).
os.close(_mode_write_pipe)
# Set up SIGHUP to be the signal for when the parent dies.
PR_SET_PDEATHSIG = 1
libc = ctypes.cdll.LoadLibrary('libc.so.6')
libc.prctl.argtypes = (ctypes.c_int, ctypes.c_ulong, ctypes.c_ulong,
ctypes.c_ulong, ctypes.c_ulong)
libc.prctl(PR_SET_PDEATHSIG, signal.SIGHUP, 0, 0, 0)
# SIGHUP indicates the parent has died. The child mutex is unlocked, it
# stops reading from the mode packet pipe and restores video modes on
# all displays/screens it knows about.
def _sighup(signum, frame):
parent_wait_mutex.unlock()
parent_wait_mutex = mutex.mutex()
parent_wait_mutex.lock(lambda arg: arg, None)
signal.signal(signal.SIGHUP, _sighup)
# Wait for parent to die and read packets from parent pipe
packets = []
buffer = ''
while parent_wait_mutex.test():
try:
data = os.read(mode_read_pipe, ModePacket.size)
buffer += data
# Decode packets
while len(buffer) >= ModePacket.size:
packet = ModePacket.decode(buffer[:ModePacket.size])
packets.append(packet)
buffer = buffer[ModePacket.size:]
except OSError:
pass # Interrupted system call
for packet in packets:
packet.set()
os._exit(0)
else:
# Parent process. Clean up pipe then continue running program as
# normal. Send mode packets through pipe as additional
# displays/screens are mode switched.
os.close(mode_read_pipe)
_restore_mode_child_installed = True
def __init__(self):
self.node_name = "Image Average"
self.bridge = CvBridge()
self.pub_image = rospy.Publisher("~average_image", Image, queue_size=1)
self.sub_image = rospy.Subscriber("/ferrari/camera_node/image/compressed", CompressedImage,
self.cbImage, queue_size=1)
rospy.loginfo("Initialization of [%s] completed" % (self.node_name))
self.lock = mutex()
self.lock.unlock()
self.avg_img = None
self.count_images = 0
def __init__(self):
self.urlhost = ""
self.urlport = 0
self.ssl = ""
self.id = None
self.fd = None
self.inited = False
# thread safe by grace of mutexing ...
self.outbuffer = ""
self.inbuffer = ""
self.timeout = 5
self.closed = False
self.lastoutlen = 0
self.outMutex = mutex.mutex()
self.inMutex = mutex.mutex()
return
def __init__(self, person_no,conf):
self.me = person_no
self.realme = person_no
self.mutex = mutex.mutex()
self.conf = conf
if conf.has_key('divert_incoming_to'):
self.me = int(conf['divert_incoming_to'])
t=threading.Thread(target=self.jabbermain)
t.setDaemon(1)
t.start()
def __init__(self):
print('intiailizing processing')
self.gpsmutex = mutex()
self.estmutex = mutex()
self.attmutex = mutex()
self.radarmutex = mutex()
self.radarmsgavailable = False
self.gpsavail = threading.Event()
self.estavail = threading.Event()
self.attavail = threading.Event()
self.radarupdate = threading.Event()
self.att = None
self.est = None
self.gps = None
self.lastatt = None
self.lastest = None
self.lastgps = None
self.I = None
self.lastI = None
self.radarmsgavailable = False
self.shutdown = False
def _install_restore_mode_child():
global _mode_write_pipe
global _restore_mode_child_installed
if _restore_mode_child_installed:
return
# Parent communicates to child by sending "mode packets" through a pipe:
mode_read_pipe, _mode_write_pipe = os.pipe()
if os.fork() == 0:
# Child process (watches for parent to die then restores video mode(s).
os.close(_mode_write_pipe)
# Set up SIGHUP to be the signal for when the parent dies.
PR_SET_PDEATHSIG = 1
libc = ctypes.cdll.LoadLibrary('libc.so.6')
libc.prctl.argtypes = (ctypes.c_int, ctypes.c_ulong, ctypes.c_ulong,
ctypes.c_ulong, ctypes.c_ulong)
libc.prctl(PR_SET_PDEATHSIG, signal.SIGHUP, 0, 0, 0)
# SIGHUP indicates the parent has died. The child mutex is unlocked, it
# stops reading from the mode packet pipe and restores video modes on
# all displays/screens it knows about.
def _sighup(signum, frame):
parent_wait_mutex.unlock()
parent_wait_mutex = mutex.mutex()
parent_wait_mutex.lock(lambda arg: arg, None)
signal.signal(signal.SIGHUP, _sighup)
# Wait for parent to die and read packets from parent pipe
packets = list()
buffer = ''
while parent_wait_mutex.test():
data = os.read(mode_read_pipe, ModePacket.size)
buffer += data
# Decode packets
while len(buffer) >= ModePacket.size:
packet = ModePacket.decode(buffer[:ModePacket.size])
packets.append(packet)
buffer = buffer[ModePacket.size:]
for packet in packets:
packet.set()
sys.exit(0)
else:
# Parent process. Clean up pipe then continue running program as
# normal. Send mode packets through pipe as additional
# displays/screens are mode switched.
os.close(mode_read_pipe)
_restore_mode_child_installed = True
def test_all_files(exact=False, binary="file"):
"""Compare output of given file(1) binary with db for all entries."""
global ret
ret = 0
print_file_info(binary)
print_lock = mutex.mutex()
entries = sorted(get_stored_files("db"))
def store_mimedata(filename):
"""Compare file(1) output with db for single entry."""
metadata = get_simple_metadata(filename, binary)
try:
stored_metadata = get_stored_metadata(filename)
except IOError:
# file not found or corrupt
text = "FAIL " + filename + "\n" + \
"FAIL could not find stored metadata!\n" + \
"This can mean that the File failed to generate " + \
"any output for this file."
else:
text = "PASS " + filename
if is_regression(stored_metadata, metadata, exact):
text = "FAIL " + filename + "\n" + \
get_diff(stored_metadata, metadata, exact)
return text
def data_print(data):
"""Print given text, set global return value, unlock print lock."""
print(data)
if data[0] == "F":
global ret
ret = 1
print_lock.unlock()
def data_stored(data):
"""Acquire print lock and call :py:function:`data_print`."""
print_lock.lock(data_print, data)
# create here so program exits if error occurs earlier
n_threads = 1
pool = ThreadPool(n_threads)
for entry in entries:
# Insert tasks into the queue and let them run
pool.queueTask(store_mimedata, entry, data_stored)
# When all tasks are finished, allow the threads to terminate
pool.joinAll()
print('')
return ret
def test_all_files(exact=False, binary="file"):
"""Compare output of given file(1) binary with db for all entries."""
global ret
ret = 0
print_file_info(binary)
print_lock = mutex.mutex()
entries = sorted(get_stored_files("db"))
def store_mimedata(filename):
"""Compare file(1) output with db for single entry."""
metadata = get_simple_metadata(filename, binary)
try:
stored_metadata = get_stored_metadata(filename)
except IOError:
# file not found or corrupt
text = "FAIL " + filename + "\n" + \
"FAIL could not find stored metadata!\n" + \
"This can mean that the File failed to generate " + \
"any output for this file."
else:
text = "PASS " + filename
if is_regression(stored_metadata, metadata, exact):
text = "FAIL " + filename + "\n" + \
get_diff(stored_metadata, metadata, exact)
return text
def data_print(data):
"""Print given text, set global return value, unlock print lock."""
print(data)
if data[0] == "F":
global ret
ret = 1
print_lock.unlock()
def data_stored(data):
"""Acquire print lock and call :py:function:`data_print`."""
print_lock.lock(data_print, data)
# create here so program exits if error occurs earlier
n_threads = 1
pool = ThreadPool(n_threads)
for entry in entries:
# Insert tasks into the queue and let them run
pool.queueTask(store_mimedata, entry, data_stored)
# When all tasks are finished, allow the threads to terminate
pool.joinAll()
print('')
return ret
def __init__(self, parent):
"""クラスの初期化
[引数]
parent -- 親クラス
[戻り値]
void
"""
RtmDictCore.__init__(self, parent)
self.parent = parent
self.Mutex = mutex.mutex()
def __init__(self, parent):
"""クラスの初期化
[引数]
parent -- 親クラス
[戻り値]
void
"""
RtmDictCore.__init__(self, parent)
self.parent = parent
self.Mutex = mutex.mutex()
def __init__(self, indexes, dataPuller, blockSize, temporaryStorageSize=1):
self.__dataPuller = dataPuller
self.__indexes = indexes
if blockSize > len(indexes):
blockSize = len(indexes)
self.__blockSize = blockSize
self.__indexesBlockBorders = self._getBlockBorders(
self.__blockSize, len(self.__indexes))
self.__len = len(self.__indexesBlockBorders)
if temporaryStorageSize > self.__len:
temporaryStorageSize = self.__len
self.__temporaryStorageSize = max(temporaryStorageSize, 1)
self.__getItemMutex = mutex.mutex()
def __init__(self, name, notebook):
wx.PyLog.__init__(self)
self.tc = wx.TextCtrl(notebook, -1, style = wx.TE_MULTILINE|wx.TE_READONLY)
self.logTime = True
self.mutex = mutex.mutex() #control access to text controls
self.name = name
try:
os.mkdir('logs')
except OSError:
#directory already exists
pass
self.filename = 'logs/'+time.strftime("%Y%m%d-%H%M")+self.name+'.txt'
self.logfile_opened = False
def __init__(self,
servername,
username,
nQueueLen=40,
nNbrSimultaneousSend=1):
self.nQueueLen = nQueueLen
self.nNbrSimultaneousSend = nNbrSimultaneousSend # NDEV
self.servername = servername
self.username = username
self.listWaiting = [] # a list of pair src/dst file(s) to be send
self.mutex = mutex.mutex()
self.bst = None
self.launchBackgroundThread()
def __init__(self, mpdclient, library, config):
'''
Initialize all models.
'''
self.mpdclient = mpdclient
self.library = library
self.config = config
self.libraryMutex = mutex.mutex()
self.playQueue = PlayQueueModel(mpdclient, library, config)
self.playlists = PlaylistsModel(mpdclient, library)
self.fileSystem = FileSystemModel(library)
self.artists = ArtistsModel(library)
self.albums = AlbumsModel(library)
self.tracks = TracksModel(library)
self.playerState = PlayerState(self.mpdclient, self.playQueue)
def __init__(self):
try:
self.path = "RecordDB.db"
self.table = "Record"
SlaveNode.__init__(self) # parent class, to do the internal database operation.
self.connect = sqlite3.connect(self.path)
self.cursor = self.connect.cursor()
self.cursor.execute("select * from sqlite_master where tbl_name = '%s'" % self.table)
self.data_row = self.cursor.fetchone()
self.mutex = mutex.mutex()
self.sync = 0
if not self.data_row:
self.cursor.execute("CREATE TABLE %s %s" % (self.table, self.template))
except Exception, e:
print("MoDb init failed\n")
print(e)
def __init__(self):
self.bt = Serial();
self.bt.port = '/dev/cu.Group_2_are_shit-SPP'
self.bt.baudrate = 57600
self.bt.timeout = 1
self.camera = Camera(self.bt)
self.camera_state = 'idle'
self.mut = mutex()
fd = sys.stdin.fileno()
tty.setcbreak(sys.stdin.fileno())
try:
self.bt.open()
except SerialException, e:
sys.stderr.write("Could not open serial port %s: %s\n" % (self.bt.portstr, e))
sys.exit(1)
def __init__(self, name, dim=100, window=10, min_count=1,
parallelism=1, use_stem=False, iterations=100, learning_rate=0.025):
self.name = name
self.dimension = dim
self.window = window
self.min_count = min_count
self.parallelism = parallelism
self.sample = 1
self.iterations = iterations
self.alpha = learning_rate
self.sentence_func = self.strip_non_ascii
self.stemmer = PorterStemmer().stem if use_stem else lambda e: e
self.stop_words = stopwords.words('english')
self.stopwords = {self.stemmer(w): True for w in self.stop_words}
self.tokenizer = self.form_sentences
self.train_lock = mutex.mutex()
self.model = None
def __init__(self, id=None, factory=None):
"""
Create an element. As optional parameters an id and factory can be
given.
Id is a serial number for the element. The default id is None and will
result in an automatic creation of an id. An existing id (such as an
int or string) can be provided as well. An id False will result in no
id being given (for "transient" or helper classes).
Factory can be provided to refer to the class that maintains the
lifecycle of the element.
"""
self._id = id or (id is not False and str(uuid.uuid1()) or False)
# The factory this element belongs to.
self._factory = factory
self.__in_unlink = mutex.mutex()
def __init__(self, **kwargs):
self.__query = kwargs.get('query')
self.__numItems = 0
self.__mutex = mutex()
#self.__fbid = kwargs.get('user_id')
self.__user = kwargs.get('user')
#self.__access_token = kwargs.get('token')
#self.__index_location_base = kwargs.get('index_loc')
self.__cursor_handler = kwargs.get('cursor_handler')
self.__THRESHOLD_MULTIPLIER = 1
# Not sure what this is doing?
mda = md5.new()
mda.update(str(self.__user.getId()) + '-' + datetime.datetime.now().isoformat())
self.__id = mda.hexdigest()
def test_all_files(exact = False, binary = "file"):
global ret
ret = 0
print_file_info(binary)
m = mutex.mutex()
entries = sorted(get_stored_files("db"))
def store_mimedata(filename):
metadata = get_simple_metadata(filename, binary)
try:
stored_metadata = get_stored_metadata(filename)
except IOError:
# file not found or corrupt
text = "FAIL " + filename + "\n" + "FAIL could not find stored metadata!\n\
This can mean that the File failed to generate any output for this file."
else:
text = "PASS " + filename
if is_regression(stored_metadata, metadata, exact):
text = "FAIL " + filename + "\n" + get_diff(stored_metadata, metadata, exact)
return text
def data_print(data):
print data
if data[0] == "F":
global ret
ret = 1
m.unlock()
def data_stored(data):
m.lock(data_print, data)
pool = ThreadPool(4) # create here so program exits if error occurs earlier
for entry in entries:
# Insert tasks into the queue and let them run
pool.queueTask(store_mimedata, entry, data_stored)
# When all tasks are finished, allow the threads to terminate
pool.joinAll()
print ''
return ret
def __init__(self, func, interval, maxn, args, kwargs):
# Thread Initialize
threading.Thread.__init__(self)
self.setDaemon(True)
# Event lock
self.lock = threading.Event()
self.addlock = mutex.mutex()
self.func = func
self.interval = interval
self.lastid = None
self.timeline = set()
# API Arguments
self.args = args
self.kwargs = kwargs
self.kwargs["count"] = maxn
