Python threading.Thread.__init__() Examples

def __init__(self):

        self.path = "logs/"

        self.names = []

        self.logs = {}
        self.id = {}
        self.current_index = {}

        self.log_file_name = {}
        self.log_file = {}
        self.log_path = ""
        self.log_file_path = {}

        self._running = False
        self.event = None

        Thread.__init__(self) 

def __init__(self, host, user, passwd=None, private_key=None, port=22, proxy_host=None):
        # Atributo para la version "thread"
        self.thread = None

        self.proxy_host = proxy_host
        self.tty = False
        self.port = port
        self.host = host
        self.username = user
        self.password = passwd
        self.private_key = private_key
        self.private_key_obj = None
        if (private_key is not None and private_key.strip() != ""):
            private_key_obj = StringIO()
            if os.path.isfile(private_key):
                pkfile = open(private_key)
                for line in pkfile.readlines():
                    private_key_obj.write(line)
                pkfile.close()
            else:
                private_key_obj.write(private_key)

            private_key_obj.seek(0)
            self.private_key_obj = paramiko.RSAKey.from_private_key(
                private_key_obj) 

def __init__(self, base_addr, size):
        Thread.__init__(self)
        self.base_addr = base_addr  # the vector we are monitoring
        self.size = size            # its size
        self.messages = Queue()     # cross-thread communication
        # store contents of vec
        self.values = []
        int_t = gdb.lookup_type('int')
        for idx in range(0, size):
            self.values.append(int((base_addr + idx).dereference().cast(int_t)))
        self.animations = []

    # Front end code
    # These methods run in the gdb thread in response to breakpoints,
    # and accept gdb.Value objects

    # Updates for instrumented actions 

def __init__(self):
        Thread.__init__(self)
        self.__running = False
        self.__lock = Lock()
        self.__data = {} # key=threadId, value={timeoutHint: timestamp, lastUpdate: timestamp}

        self.__watchDogFile = "/dev/watchdog"
        self.__watchDogDescriptor = None
        self.__watchDogTimeout = 5

        self.__lastWatchdogTimestamp = None
        self.__lastCheckTimestamp = None
        self.__lastNoneIpTimestamp = None
        self.__pause = False

        self.__wifiRefreshTimeout = 60 * 2
        self.__wifiNoneIpTimeout = 60 * 1
        self.__systemTimeChangeThreshold = 60 * 10 # on which system time change(ntpd) threshold we should reset

        self.__mainManager = None

    #----------------------------------------------------------------------------------------
    #
    #
    # 

def __init__(self):
        Thread.__init__(self)

        self.__simulator = None
        self.__parserManager = None
        self.__mixerDataTable = None

        self.__useThreading = False
        if self.__useThreading:
            self.__stop = False
            self.__waitTimeout = 3600
            self.__messageQueue = Queue()

    #----------------------------------------------------------------------------------------
    #
    #
    # 

def __init__(self, laddress, data_callback, family = None, o = None):
        if o == None:
            if family == None:
                if laddress != None and laddress[0].startswith('['):
                    family = socket.AF_INET6
                    laddress = (laddress[0][1:-1], laddress[1])
                else:
                    family = socket.AF_INET
            self.family = family
            self.laddress = laddress
            self.data_callback = data_callback
        else:
            self.laddress, self.data_callback, self.family, self.nworkers, self.flags, \
              self.ploss_out_rate, self.pdelay_out_max, self.ploss_in_rate, \
              self.pdelay_in_max = o.laddress, o.data_callback, o.family, \
              o.nworkers, o.flags, o.ploss_out_rate, o.pdelay_out_max, o.ploss_in_rate, \
              o.pdelay_in_max 

def __init__(self,user,password,socket,logdir,isdebug):
		Thread.__init__(self)

		self.user = user
		self.password = password
		self.socket = socket
		self.logdir = logdir
		self.isdebug = isdebug
		self.errorno = 0

		self.dbcursor = self.init_dbconn()
		self.port = self.init_port()

		self.start_position = 0
		self.stop_position = 0

		self.lockfile = "/tmp/mysql_repl_repair" + str(self.port) + ".lck"

		self.logger = MyLogger(self.port, self.logdir, self.isdebug)

		self.logger.info("*"*64)
		self.logger.info(" "*25 + "PROCESS START")
		self.logger.info("*"*64) 

def __init__(self, num_threads):
        self.tasks = Queue()
        self.retq = Queue()
        self.exception = None
        self.num_tasks = 0

        for _ in range(num_threads):
            Worker(self) 

def __init__(self, snp_queue, sad_out, stats, log_pseudo=1):
    Thread.__init__(self)
    self.queue = snp_queue
    self.daemon = True
    self.sad_out = sad_out
    self.stats = stats
    self.log_pseudo = log_pseudo 

def __init__(self, acc_queue):
    Thread.__init__(self)
    self.queue = acc_queue
    self.daemon = True 

def __init__(self, q, progress, dataset, max, images, controller):
        Thread.__init__(self)
        self.q = q
        self.progress = progress
        self.dataset = dataset
        self.max = max
        self.images = images
        self.controller = controller 

def __init__(self, ssh):
        Thread.__init__(self)

        self.ssh = ssh
        self.command = None
        self.command_return = None
        self.client = None
        self.proxy = None 

def __init__(self):
        Thread.__init__(self) 

def __init__(self,groupname):
        self.groupname=groupname
        Thread.__init__(self) 

def __init__(self, name, url, data_path):
        self.data = url
        self.path = data_path
        Thread.__init__(self) 

def __init__(self, datagen, images, classes_count, batch_size):
        self.index = -1
        self.datagen = datagen
        self.images = images
        random.shuffle(self.images)
        self.lock = Lock()

        self.classes_count = classes_count
        self.batch_size = batch_size 

def __init__(self, job_backend, cpu_cores=1, gpu_devices=None, docker_container=None):
        Thread.__init__(self)

        self.job_backend = job_backend
        self.gpu_devices = gpu_devices
        self.docker_container = docker_container
        self.max_minutes = 0
        self.cpu_cores = cpu_cores

        job = self.job_backend.job
        if 'maxTime' in job['config'] and isinstance(job['config']['maxTime'], int) and job['config']['maxTime'] > 0:
            self.max_minutes = job['config']['maxTime']

        self.hardware_stream = self.job_backend.git.stream_file('aetros/job/monitoring.csv')

        header = ["second", "cpu", "memory"]
        try:
            if self.gpu_devices:
                for gpu_id, gpu in enumerate(aetros.cuda_gpu.get_ordered_devices()):
                    if gpu_id in gpu_devices:
                        header.append("memory_gpu" + str(gpu['id']))
        except aetros.cuda_gpu.CudaNotImplementedException: pass

        if job_backend.get_job_model().has_dpu():
            header += ['dpu0']

        self.hardware_stream.write(simplejson.dumps(header)[1:-1] + "\n")
        self.running = True
        self.early_stopped = False
        self.handle_max_time = True
        self.client = docker.from_env()
        self.docker_api = docker.APIClient(**docker.utils.kwargs_from_env())
        self.stat_stream = None

        self.docker_last_last_reponse = None
        self.docker_last_stream_data = 0
        self.docker_last_mem = None
        self.docker_last_cpu = None 

def __init__(self, group=None, target=None, name=None,
                 args=(), kwargs={}, Verbose=None):
        Thread.__init__(self, group, target, name, args, kwargs)
        self._return = None 

def __init__(self, daemon: bool = True):
        Thread.__init__(self, daemon=daemon, name=self.NAME)
        self.logging_queue = queue.Queue()
        self.cache = [] 

def __init__(self, outcallback=None):
        Thread.__init__(self)
        self.outcallback = outcallback

        self._fd_read, self._fd_write = os.pipe()
        self._pipe_reader = os.fdopen(self._fd_read)
        self._buffer = []

        self.start() 

def __init__(self, node):
        Thread.__init__(self)
        self.node = node 

def __init__(self, node, tablename, filename='debug.log', delay=0):
        Thread.__init__(self)
        self.node = node
        self.tablename = tablename
        self.filename = filename
        self.delay = delay
        self.mark = node.mark_log(filename=self.filename) 

def __init__(self, node):
        Thread.__init__(self)
        self.node = node 

def __init__(self, node):
        Thread.__init__(self)
        self.node = node 

def __init__(self, tag, logdir=None, isdebug=False):
		self.log = logging.getLogger("MYSQLREPLREPAIR" + str(tag))

		self.logdir = logdir
		self.isdebug = isdebug
		self.tag = tag

		self.config_logger() 

def __init__(self, option):
		self.option = option 

def __init__(self, tag, logdir=None, isdebug=False):
		self.log = logging.getLogger("MYSQLREPLREPAIR" + str(tag))

		self.logdir = logdir
		self.isdebug = isdebug
		self.tag = tag

		self.config_logger() 

def __init__(self,user,password,ip,port,logdir,isdebug):
		Thread.__init__(self)

		self.user = user
		self.password = password
		self.ip = ip
		self.port = port
		self.logdir = logdir
		self.isdebug = isdebug
		self.errorno = 0
		self.dbcursor = self.dbconn(self.ip, self.port).cursor()
		self.lockfile = "/tmp/mysql_repl_repair." + ip + "." + port + ".lck"
		self.logger = MyLogger(self.ip+"."+self.port, self.logdir, self.isdebug) 

def __init__(self, option):
		self.option = option 

def __init__(self, folder_name, host="127.0.0.1", verbosity=logging.WARN):
        Thread.__init__(self)
        self.project_key = os.environ["DKU_CURRENT_PROJECT_KEY"]
        self.folder_name = folder_name
        self.client = dataiku.api_client()

        logging.set_verbosity(verbosity)

        # Getting app
        logs_path = self.__get_logs_path()
        app = self.__get_tb_app(logs_path)

        # Setting server
        self.srv = make_server(host, 0, app)