def __init__(self, parsed): Thread.__init__(self) self.results = ParseEvaluator() self.parsed = parsed self.daemon = True self.start()
def __init__(self, newJobsQueue, updatedJobsQueue, boss): Thread.__init__(self) self.newJobsQueue = newJobsQueue self.updatedJobsQueue = updatedJobsQueue self.currentjobs = list() self.runningjobs = set() self.boss = boss
def __init__(self, tname, task_queue, flt, suc, fail, headers={}, proxy=None, proxy_policy=None, retry=3, timeout=10, logger=None, keep_alive=None, stream_mode=False): """ Construct a new 'HttpWorker' obkect :param tname: The name of this http worker :param task_queue: The task Queue instance :param flt: the filter function :param suc: the function to call when succeeded :param fail: the function to call when failed :param headers: custom HTTP headers :param proxy: proxy dict :param proxy_policy: a function to determine whether proxy should be used :param retry: retry count :param timeout: timeout in seconds :param logger: the Logger instance :param keep_alive: the callback to send keep alive :param stream_mode: set the request to use stream mode, keep_alive will be called every iteration :return: returns nothing """ HttpReq.__init__(self, headers, proxy, proxy_policy, retry, timeout, logger, tname = tname) Thread.__init__(self, name = tname) Thread.setDaemon(self, True) self.task_queue = task_queue self.logger = logger self._keepalive = keep_alive self._exit = lambda x: False self.flt = flt self.f_suc = suc self.f_fail = fail self.stream_mode = stream_mode # if we don't checkin in this zombie_threshold time, monitor will regard us as zombie self.zombie_threshold = timeout * (retry + 1) self.run_once = False
def __init__(self, function, sleep=30): Thread.__init__(self) self.daemon = True self.sleepTime = sleep self.runTimer = True self.function = function
def __init__(self, req, proxy, logger, task, exit_check=None, ignored_errors=[]): Thread.__init__(self, name = "monitor%s" % task.guid) Thread.setDaemon(self, True) # the count of votes per error code self.vote_result = {} # the error code to be ignored self.vote_cleared = set().union(ignored_errors) self.thread_last_seen = {} self.dctlock = RLock() self.votelock = RLock() self.thread_ref = {} self.thread_zombie = set() # HttpReq instance self.req = req # proxy.Pool instance self.proxy = proxy self.logger = logger self.task = task self._exit = exit_check if exit_check else lambda x: False self._cleaning_up = False if os.name == "nt": self.set_title = lambda s:os.system("TITLE %s" % ( s if PY3K else s.encode(CODEPAGE, 'replace'))) elif os.name == 'posix': import sys self.set_title = lambda s:sys.stdout.write("\033]2;%s\007" % ( s if PY3K else s.encode(CODEPAGE, 'replace')))
def __init__(self, port, deviceFd, deviceLock, debug = False, aexServer = None): ''' Constructor ''' self.running = False self.__dataQueue = Queue(0) self.__clients = [] self.debug = debug self.__deviceFd = deviceFd self.deviceLock = deviceLock self.aexServer=aexServer self.runningTime = 0 self.receivingTime = 0 self.packetsReceived = 0 self.sleepingTimes = 0 ThreadingTCPServer.__init__(self, ("", port), StimNetCom, False) ThreadingTCPServer.allow_reuse_address = True self.server_bind() self.server_activate() Thread.__init__(self)
def __init__(self, interval_sec, get_connection_holders): Thread.__init__(self, name="Connection heartbeat") self._interval = interval_sec self._get_connection_holders = get_connection_holders self._shutdown_event = Event() self.daemon = True self.start()
def __init__(self, server): """ constructor @param server to run """ Thread.__init__(self) self.server = server
def __init__(self, prompt="> ", stdin=None, stdout=None): if _debug: ConsoleCmd._debug("__init__") cmd.Cmd.__init__(self, stdin=stdin, stdout=stdout) Thread.__init__(self, name="ConsoleCmd") # check to see if this is running interactive self.interactive = sys.__stdin__.isatty() # save the prompt for interactive sessions, otherwise be quiet if self.interactive: self.prompt = prompt else: self.prompt = '' # gc counters self.type2count = {} self.type2all = {} # logging handlers self.handlers = {} # set a INT signal handler, ^C will only get sent to the # main thread and there's no way to break the readline # call initiated by this thread - sigh if hasattr(signal, 'SIGINT'): signal.signal(signal.SIGINT, console_interrupt) # start the thread self.start()
def __init__(self, log = None): from threading import Event Thread.__init__(self) self.__mytid = P.mytid() try: ## get process ID of parent self.__parent = P.parent() except: self.__parent = None self.__bindings = {} self.__stop = 0 self.__tasks = {} self.setMessageLoopDelay(0.1) self.__loopEvent = Event() if log: self.__log = Logfile() else: self.__log = None ## add ping-mechanism self.setPingTimeout(5.) self.bind(MSG_PING, -1, self._ping)
def __init__(self, name, event, function, args=[], period = 5.0): Thread.__init__(self) self.name = name self.stopped = event self.period = period self.function = function self.args = args
def __init__(self, stationBase): Thread.__init__(self) self.stationBase = stationBase self.imageVirtuelle = None self.anciennePosRobot = [] self.police = cv2.FONT_HERSHEY_SIMPLEX self.chargerImageVirtuelle()
def __init__(self, config, pipe_name=PIPE): """@param pipe_name: Cuckoo PIPE server name.""" Thread.__init__(self) self.pipe_name = pipe_name self.config = config self.options = config.get_options() self.do_run = True
def __init__(self, scanner, files): IdleObject.__init__(self) Thread.__init__(self) self.files = files self.scanner = scanner self.daemon = True self.stop = False
def __init__(self, params): Thread.__init__(self) self.tid = params['tid'] #work线程id self.apns_gateway = ApnsGateway(certfile=params['certfile'], #apns连接 host=params['host'], port=params['port'], retry=params['retry'])
def __init__(self, host, port, tor): Thread.__init__(self) self.host = host self.port = port self.socks = socks.socksocket() self.tor = tor self.running = True
def __init__(self, model=None, ishome=False): IdleObject.__init__(self) Thread.__init__(self) self.model = model self.ishome = ishome self.daemon = True self.stop = False
def __init__ (self): Thread.__init__(self) self.status = 0. self.running = True self.datastr=0. self.Value=0. self.OldData=0.
def __init__(self, app, port, timeout=5): self.timeout = timeout Thread.__init__(self) self.app = app self.port = port if isinstance(app, object): self.name = app.__class__.__name__ else: self.name = app.__name__ from paste import httpserver self.server = httpserver.serve(self.app, host='127.0.0.1', port=str(self.port), start_loop=False, use_threadpool=True, protocol_version="HTTP/1.1", socket_timeout=5, threadpool_options={ "hung_thread_limit": 10, "kill_thread_limit" : 20, "dying_limit": 30, "hung_check_period" : 5 } ) self.server.thread_pool.logger.setLevel(logging.WARN) if not hasattr(self.server, "timeout") or self.server.timeout is None: self.server.timeout = 1 if self.server.timeout != 1: warn("server.timeout was changed from %d to 1" % (self.server.timeout)) self.server.timeout = 1 assert self.server.timeout == 1 self.server.handle_timeout = _Watchdog(self.server, limit=self.timeout).getTimeoutHandler()
def __init__(self,threadSum): Thread.__init__(self) sqldb = DB_Helper()#将序号重新恢复 sqldb.updateID() self.pool =[] for i in range(threadSum): self.pool.append(Detect_Proxy(DB_Helper(),i+1,threadSum))
def __init__ (self, world, controller, sock): Thread.__init__(self) self.world = world self.controller = controller self._stop = Event() self.lock = Lock() self.sock = sock
def __init__(self, watchers, endpoint, pubsub_endpoint, check_delay=1., prereload_fn=None, context=None, loop=None, stats_endpoint=None, plugins=None): Thread.__init__(self) Arbiter.__init__(self, watchers, endpoint, pubsub_endpoint, check_delay, prereload_fn, context, loop, stats_endpoint, plugins)
def __init__(self): Thread.__init__(self) self.daemon = True # flush the input buffer ser.read(1000)
def __init__(self, sock): Thread.__init__(self) self.sendingQueue = Utils.globals.sendingQueue self.sock = sock self.ping = "" self.outfile = open("data_received_from_node.txt", 'w')
def __init__(self): Thread.__init__(self) self.daemon = True self.start() self.status = '' self._sleep_time = 0
def __init__(self, sensor_name, sensor_type, serial): Thread.__init__(self) if sensor_name[-1] == '/': sensor_name = sensor_name[:-1] if (sensor_type == "Kinect2") or (sensor_type == "Kinectv2") or (sensor_type == "Kinect_v2"): self.kinect_type = "Kinect2" print "Loading Kinect2 with serial : "+serial self.kinect = Kinect_v2(sensor_name,serial,queue_size=10,compression=False,use_rect=True,use_ir=True) elif (sensor_type == "Kinect") or (sensor_type == "Kinect1") or (sensor_type == "Kinectv1") or (sensor_type == "Kinect_v1"): self.kinect_type = "Kinect1" print "Loading "+sensor_name+" of type Kinect1" self.kinect = Kinect(sensor_name,queue_size=10,compression=False,use_rect=True,use_depth_registered=True,use_ir=False) else: print "ERROR: Sensor type must be Kinect2 or Kinect" return self.sensor_name = sensor_name self.kinect.wait_until_ready() self.listener = tf.TransformListener() self.list_robot_links = ['link_0','link_1','link_2','link_3','link_4','link_5','link_6','link_7'] self.last_pose = None rospy.Subscriber("/kinect_merge/tracking_state", MarkerArray , self.callback)
def __init__(self, proxy, url, file): Thread.__init__(self) self.proxy = proxy self.url = url self.file = file self.result = False self.data = ""
def __init__(self, app, baseurl, mount, cacertdir = "/etc/grid-security/certificates", minreq = 1000, interval = 300, instance = "test"): Thread.__init__(self, name = "LdapSync") self.sectoken = "".join(random.sample(string.letters, 30)) self._inturl = "http://localhost:%d%s/%s/ldapsync" % \ (app.srvconfig.port, mount, instance) self._headers = \ fake_authz_headers(open(app.srvconfig.tools.cms_auth.key_file).read(), method = "Internal", login = self.sectoken, name = self.__class__.__name__, dn = None, roles = {"Global Admin": {"group": ["global"]}}) \ + [("Accept", "application/json")] self._cv = Condition() if isinstance(baseurl, str): self._baseurl = baseurl self._cacertdir = cacertdir self._minreq = minreq self._interval = interval self._stopme = False self._full = (0, [], []) self._warnings = {} self._intreq = RequestManager(num_connections = 2, user_agent = self._ident, handle_init = self._handle_init, request_respond = self._respond, request_init = self._int_init) cherrypy.engine.subscribe("stop", self.stop) cherrypy.engine.subscribe("start", self.start)
def __init__(self, files, outDir, dirFormat, fileFormat, anon=dict(), keep_filename=False, iterator=None, test=False, listener=None, total=None, root=None, seriesFirst=False): self.dirFormat = dirFormat self.fileFormat = fileFormat self.fileList = files self.anondict = anon self.keep_filename = keep_filename self.seriesFirst = seriesFirst self.outDir = outDir self.test = test self.iter = iterator self.root = root if not isinstance(self.fileList, tuple): self.fileList = (self.fileList,) if total is None: self.total = len(self.fileList) else: self.total = total self.isgui = False if listener: self.listener = listener self.isgui = True Thread.__init__(self) self.start()
def __init__(self, sync): Thread.__init__(self) self.sync = sync self.IPorts = [] self.OPorts = [] self.myOutput = {} self.myInput = {}
def __init__(self, localhost, port=9999, data_ids={}): Thread.__init__(self) self.localhost = localhost self.port = port self.data_ids = data_ids
def __init__(self, queue): Thread.__init__(self) self.queue = queue
def __init__(self, ppa_path, keyserver=None): Thread.__init__(self) AddPPASigningKey.__init__(self, ppa_path=ppa_path, keyserver=keyserver)
def __init__(self, event, config_file, log=True, show=False): Thread.__init__(self) self.stopped = event ### Initialize controller variables ### config = ConfigParser.RawConfigParser() config.read(config_file) self.Td = config.getfloat('Controller', 'Td') self.__heli = Heli(config.getstring('Motors', 'port')) # Initialize motors self.__heli.set_12v_motor_sleep_state(False) self.__heli.set_5v_motor_sleep_state(False) # State variables (psi, theta, phi) = self.__heli.read_sensor_data() self.theta = [theta, theta] self.theta_ref = [0] self.phi = [phi, phi] self.phi_ref = [0] self.ref_idx = 0 self.e_theta = [0, 0] self.e_phi = [0, 0] self.u_1 = [0, 0] self.u_2 = [0, 0] # Yaw controller parameters self.Kp2 = 1 self.Ti2 = 1 # Pitch fuzzy controller parameters # Input variables self.e_trimf = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] self.de_trimf = [[0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0], [0.0, 0.0, 0.0]] # Output singletons # Rows: de # Columns: e self.A = [[0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0]] # Proposition vectors self.mu_e_theta = [0 for i in range(len(self.e_trimf))] self.mu_e_phi = [0 for i in range(len(self.e_trimf))] self.mu_de_theta = [0 for i in range(len(self.de_trimf))] self.mu_de_phi = [0 for i in range(len(self.de_trimf))] self.antecedent_theta = [[0 for j in range(len(self.A))] for i in range(len(self.A))] self.antecedent_phi = [[0 for j in range(len(self.A))] for i in range(len(self.A))] self.__log_on = log if self.__log_on: self.log = True now_str = datetime.now().__str__().split('.')[0] now_str = now_str.replace(' ', '-').replace(':', '-') self.logfile = open(now_str + '_ctrl_log.csv', 'wb') self.logger = csv.writer(self.logfile, delimiter=';')
def __init__(self, *args, **kwargs): Thread.__init__(self) NodeUpdater.__init__(self, *args, **kwargs) self.exitcode = -1
def __init__(self, hash_queue): ''' Constructor ''' Thread.__init__(self) self.hash_queue = hash_queue
def __init__(self): Thread.__init__(self) self.lock = Lock() self.status = {'status': 'connecting', 'messages': []} self.input_dir = '/dev/input/by-id/' self.open_devices = [] self.barcodes = Queue() self.keymap = { 2: ("1", "!"), 3: ("2", "@"), 4: ("3", "#"), 5: ("4", "$"), 6: ("5", "%"), 7: ("6", "^"), 8: ("7", "&"), 9: ("8", "*"), 10: ("9", "("), 11: ("0", ")"), 12: ("-", "_"), 13: ("=", "+"), # 14 BACKSPACE # 15 TAB 16: ("q", "Q"), 17: ("w", "W"), 18: ("e", "E"), 19: ("r", "R"), 20: ("t", "T"), 21: ("y", "Y"), 22: ("u", "U"), 23: ("i", "I"), 24: ("o", "O"), 25: ("p", "P"), 26: ("[", "{"), 27: ("]", "}"), # 28 ENTER # 29 LEFT_CTRL 30: ("a", "A"), 31: ("s", "S"), 32: ("d", "D"), 33: ("f", "F"), 34: ("g", "G"), 35: ("h", "H"), 36: ("j", "J"), 37: ("k", "K"), 38: ("l", "L"), 39: (";", ":"), 40: ("'", "\""), 41: ("`", "~"), # 42 LEFT SHIFT 43: ("\\", "|"), 44: ("z", "Z"), 45: ("x", "X"), 46: ("c", "C"), 47: ("v", "V"), 48: ("b", "B"), 49: ("n", "N"), 50: ("m", "M"), 51: (",", "<"), 52: (".", ">"), 53: ("/", "?"), 55: ("*", "*"), # 54 RIGHT SHIFT 57: (" ", " "), 71: ("7", "7"), 72: ("8", "8"), 73: ("9", "9"), 75: ("4", "4"), 76: ("5", "5"), 77: ("6", "6"), 79: ("1", "1"), 80: ("2", "2"), 81: ("3", "3"), 82: ("0", "0"), # 96 enter }
def __init__(self, task): Thread.__init__(self) self.task = task self.success = False self.done = False self.value = None
def __init__(self): Thread.__init__(self) self.stop = Event() self.messages = Queue() self.setDaemon(True)
def __init__(self, parent, sudo=False): self.parent = parent self.sudo = sudo Thread.__init__(self)
def __init__(self, sid): Thread.__init__(self) self.sid = sid
def __init__(self): Thread.__init__(self) self.queue = Queue() self.lock = Lock() self.status = {'status': 'connecting', 'messages': []}
def __init__(self, capture=False, captureMove=False): Thread.__init__(self) self.daemon = True self.capture = capture self.captureMove = captureMove self.state = True
def __init__(self): Thread.__init__(self) self.do_run = True
def __init__(self, _error=None, ): Thread.__init__(self) self._error = _error
def __init__(self, listen_port: int): Thread.__init__(self) self.exit_f = False self.listen_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.setup_socket(listen_port)
def __init__(self, backend, cancelled, sleep_time): Thread.__init__(self) self.sleep_time = sleep_time self.backend = backend self.cancelled = cancelled
def __init__(self): Thread.__init__(self) self.active = True
def __init__(self, f, args, stdin=None, stdout=None, stderr=None, universal_newlines=False): """Parameters ---------- f : function The function to be executed. args : list A (possibly empty) list containing the arguments that were given on the command line stdin : file-like, optional A file-like object representing stdin (input can be read from here). If `stdin` is not provided or if it is explicitly set to `None`, then an instance of `io.StringIO` representing an empty file is used. stdout : file-like, optional A file-like object representing stdout (normal output can be written here). If `stdout` is not provided or if it is explicitly set to `None`, then `sys.stdout` is used. stderr : file-like, optional A file-like object representing stderr (error output can be written here). If `stderr` is not provided or if it is explicitly set to `None`, then `sys.stderr` is used. """ self.f = f """ The function to be executed. It should be a function of four arguments, described below. Parameters ---------- args : list A (possibly empty) list containing the arguments that were given on the command line stdin : file-like A file-like object representing stdin (input can be read from here). stdout : file-like A file-like object representing stdout (normal output can be written here). stderr : file-like A file-like object representing stderr (error output can be written here). """ self.args = args self.pid = None self.returncode = None self.wait = self.join handles = self._get_handles(stdin, stdout, stderr) (self.p2cread, self.p2cwrite, self.c2pread, self.c2pwrite, self.errread, self.errwrite) = handles # default values self.stdin = stdin self.stdout = None self.stderr = None if ON_WINDOWS: if self.p2cwrite != -1: self.p2cwrite = msvcrt.open_osfhandle(self.p2cwrite.Detach(), 0) if self.c2pread != -1: self.c2pread = msvcrt.open_osfhandle(self.c2pread.Detach(), 0) if self.errread != -1: self.errread = msvcrt.open_osfhandle(self.errread.Detach(), 0) if self.p2cwrite != -1: self.stdin = io.open(self.p2cwrite, 'wb', -1) if universal_newlines: self.stdin = io.TextIOWrapper(self.stdin, write_through=True, line_buffering=False) if self.c2pread != -1: self.stdout = io.open(self.c2pread, 'rb', -1) if universal_newlines: self.stdout = io.TextIOWrapper(self.stdout) if self.errread != -1: self.stderr = io.open(self.errread, 'rb', -1) if universal_newlines: self.stderr = io.TextIOWrapper(self.stderr) Thread.__init__(self) self.start()
def __init__(self, name): Thread.__init__(self) self._socket = None self._name = name
def __init__(self, loop): Thread.__init__(self) self.rds = redis.StrictRedis(REDIS_HOST, 6379, db=1) self.loop_count = loop
def __init__(self, socket): Thread.__init__(self) self.socket = socket
def __init__(self, func): Thread.__init__(self) self.__action = func self.debug = False
def __init__(self): Thread.__init__(self) #dichiarazione attributi del thread self.id = myId self.ip = ip self.url_conn = "http://" + ip + "/api/v1/receive"
def __init__(self, attrs): Thread.__init__(self) self.queue = Queue() self.timer = None self.loop = True self._attrs = attrs
def __init__(self, queue, selected_item_list, details): Thread.__init__(self) self.queue = queue self.selected_item_list = selected_item_list self.details = details
def __init__(self, database=DEFAULT_DB_ALIAS): self.database = database Thread.__init__(self) self.daemon = True
def __init__(self, tasks, logger): Thread.__init__(self) self.logger = logger self.tasks = tasks self.daemon = True self.start()
def start(self, target=None, args=()): if target: Thread.__init__(self, target=target, args=args) else: Thread.__init__(self, name="postgres") super(postgres, self).start()
def __init__(self): Thread.__init__(self)