def __init__(self, q, dbs):
Process.__init__(self)
self.subscribe = q[listenTo[0] + '_' + name]
self.dbs = dbs
dbConnector.connectToDB(self)
self.openIssues = {}
self.callbackQueue = Queue()
def __init__(self, **kwargs):
self.addressManager = OSC.CallbackManager()
self.queue = Queue()
Process.__init__(self, args=(self.queue,))
self.daemon = True
self._isRunning = Value('b', True)
self._haveSocket= Value('b', False)
def __init__(self, func):
Process.__init__(self)
self.in_buffer = None
self.out_buffer = None
self.func = func
# number of tokens popped from the input buffer each time
self.n_args = len(inspect.getargspec(func).args)
def __init__(self, alive_event, work_event, email, queue, index_queue,
passed, robots, unavailable_urls,
agent_name=DEFAULT_AGENT_NAME, headers=DEFAULT_HEADERS,
url_filter=lambda x: True):
Process.__init__(self)
self.alive_event = alive_event
self.work_event = work_event
self.email = email
self.queue = queue
self.index_queue = index_queue
self.passed = passed
self.robots = robots
self.unavailable_urls = unavailable_urls
self.agent_name = agent_name
self.url_filter = url_filter
self.is_working = False
self.handler = request.build_opener(RobotHandler(agent_name, robots))
handler_headers = [(k, v) for k, v in copy.copy(headers).items()]
handler_headers.append(("User-Agent", agent_name))
handler_headers.append(("From", email))
self.handler.addheaders = handler_headers
self.html_parser = HTMLParser(tree=treebuilders.getTreeBuilder("dom"))
self.connection = None
def __init__(self, _output_file, header, _input_pipe, _disk_rows):
Process.__init__(self)
self.file_name = _output_file
self.input_pipe = _input_pipe
self.write_rows = _disk_rows
self.header = header
def __init__(self, callback=None, log=True, log_level="DEBUG"):
""" Initialize the data parser, connect to the can bus. """
Process.__init__(self)
self.callback = callback
self.log = log
self.log_level = log_level
self.data = {}
def __init__(self, dt=1):
import psutil
Process.__init__(self)
self.daemon = True
self.dt = dt
self.parent = psutil.Process(current_process().pid)
self.parent_conn, self.child_conn = Pipe()
def __init__(self, response_queue, backup_name, host_port, user, password, authdb, base_dir, binary,
dump_gzip=False, verbose=False):
Process.__init__(self)
self.host, port = host_port.split(":")
self.host_port = host_port
self.port = int(port)
self.response_queue = response_queue
self.backup_name = backup_name
self.user = user
self.password = password
self.authdb = authdb
self.base_dir = base_dir
self.binary = binary
self.dump_gzip = dump_gzip
self.verbose = verbose
self._command = None
self.completed = False
self.backup_dir = "%s/%s" % (self.base_dir, self.backup_name)
self.dump_dir = "%s/dump" % self.backup_dir
self.oplog_file = "%s/oplog.bson" % self.dump_dir
self.start_time = time()
signal(SIGINT, self.close)
signal(SIGTERM, self.close)
def __init__(self, worker, outlist, index):
Process.__init__(self)
self.worker = worker
if worker is None or worker.element is None:
raise MultiProjectException("Bug: Invalid Worker")
self.outlist = outlist
self.index = index
def __init__(self, uid=None, gid=None, group=None, target=None, name=None, args=(), kwargs={}):
Process.__init__(self, group, target, name, args, kwargs)
self.uid = uid
self.gid = gid
self.target = target
self.args = args
OwnedProcess.add(self)
def __init__(self, procnum, data, row_flags, x_coords, *args, **kwds):
"""A helper process for generating the Mandelbrot set."""
Process.__init__(self, *args, **kwds)
self.offset = procnum
self.data = data
self.row_flags = row_flags
self.x_coords = x_coords
def __init__(self, schema, dir, postingqueue, resultqueue, limitmb):
Process.__init__(self)
self.schema = schema
self.dir = dir
self.postingqueue = postingqueue
self.resultqueue = resultqueue
self.limitmb = limitmb
def __init__(self, input_queue, output_path, time_queue, temp_overlay_file=None):
self.input_queue = input_queue
self.time_queue = time_queue
self.output_path = output_path
self.decompressor = LZMADecompressor()
self.temp_overlay_file = temp_overlay_file
Process.__init__(self, target=self.decompress_blobs)
def __init__(self, cmd, data_out):
Process.__init__(self)
self.cmd = cmd
self.data_out = data_out
self.dt_des =1/200.0
self.airprobe = airprobe_main(self.dt_des)
self.cycles = 0
def __init__(self, sequence_queue, fade_engine):
Process.__init__(self)
self.__sequence_queue = sequence_queue
self.__engine = fade_engine
self.__current_sequence = None
self.__black = rgb_light_color(0, 0, 0)
self.__keepRunning = True
def __init__(self,inp,output=False,logger=None):
"""
***TESTING for splitting up jobs further on the compute cluster***
***NOT ACTIVE***
#The minimum input
{'input':{'data':self.datafile,'pdb':self.input_pdb,'sg':self.sg,}
'output','logger}
"""
logger.info('RunPhaser.__init__')
self.input = inp
self.output = output
self.logger = logger
#setup params
self.run_before = self.input.get('run_before',False)
self.verbose = self.input.get('verbose',False)
self.copy = self.input.get('copy',1)
self.res = self.input.get('res',False)
self.test = self.input.get('test',False)
self.cluster_use = self.input.get('cluster',True)
self.datafile = self.input.get('data')
self.input_pdb = self.input.get('pdb')
self.sg = self.input.get('sg')
self.ca = self.input.get('cell analysis',False)
#self.mwaa = self.input.get('mwaa',False)
#self.mwna = self.input.get('mwna',False)
self.n = self.input.get('name',self.sg)
self.large_cell = self.input.get('large',False)
Process.__init__(self,name='RunPhaser2')
self.start()
def __init__(self, priority_queue_in, queue_in, queue_out, available_commands, shared_settings):
Process.__init__(self)
self.priority_queue_in = priority_queue_in
self.queue_in = queue_in
self.queue_out = queue_out
self.available_commands = available_commands
self.shared_settings = shared_settings
def __init__(self, pathq, outputq, process_dump, callback=lambda: None, logger=logger):
self.pathq = pathq
self.outputq = outputq
self.process_dump = process_dump
self.callback = callback
self.logger = logger
Process.__init__(self)
def __init__(self, inp, output=False, logger=None):
"""
#The minimum input
{"input":{"data":self.datafile,"pdb":self.input_pdb,"sg":self.sg,}
"output","logger}
"""
logger.info("RunPhaser.__init__")
self.input = inp
self.output = output
self.logger = logger
# setup params
self.run_before = self.input.get("run_before", False)
self.verbose = self.input.get("verbose", False)
self.copy = self.input.get("copy", 1)
self.res = self.input.get("res", False)
self.test = self.input.get("test", False)
self.cluster_use = self.input.get("cluster", True)
self.datafile = self.input.get("data")
self.input_pdb = self.input.get("pdb")
self.sg = self.input.get("sg")
self.ca = self.input.get("cell analysis", False)
#self.mwaa = self.input.get("mwaa", False)
#self.mwna = self.input.get("mwna", False)
self.n = self.input.get("name", self.sg)
self.large_cell = self.input.get("large", False)
Process.__init__(self, name="RunPhaser")
self.start()
def __init__(self, nombre, diccL, intento, master):
Process.__init__(self)
self.nombre = nombre
self.diccL = diccL
self.intento = intento
self.master = master
self.lockM = self.master.lockM
def __init__(self, openoffice, interval, limit_memory_usage): """Expects to receive an object that implements the interfaces IApplication and ILockable, the limit of memory usage that the openoffice can use and the interval to check the object.""" Monitor.__init__(self, openoffice, interval) Process.__init__(self) self.limit = limit_memory_usage
def __init__(self, qi, qo, server_ips):
Process.__init__(self)
self.qi = qi
self.qo = qo
self.server_ips = server_ips
self.logics = set()
self.remcon = set()
def __init__(self, send_queue, recv_queue, port=9999):
Process.__init__(self)
self.send_queue = send_queue
self.recv_queue = recv_queue
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.bind(("", port))
self.socket.listen(1)
def __init__(self, settings, callback_queue, mount_devices, grub_device, fs_devices, ssd=None, alternate_package_list=""):
Process.__init__(self)
self.alternate_package_list = alternate_package_list
self.callback_queue = callback_queue
self.settings = settings
self.method = self.settings.get('partition_mode')
self.queue_event('info', _("Installing using the '%s' method") % self.method)
self.ssd = ssd
self.mount_devices = mount_devices
self.grub_device = grub_device
# Check desktop selected to load packages needed
self.desktop = self.settings.get('desktop')
self.desktop_manager = 'gdm'
self.network_manager = 'NetworkManager'
self.card = []
# Packages to be removed
self.conflicts = []
self.fs_devices = fs_devices
self.running = True
self.error = False
def __init__(self, proj, stat, idQueue, status, genotypes):
'''Use sql to process sample passed from queue, set results in status'''
self.proj = proj
# query, where, idx
self.stat = []
for field, item in stat:
if item == '#(GT)':
self.stat.append(('count(*)', None))
elif item == '#(alt)':
self.stat.append(('sum(abs(GT))', None))
elif item == '#(hom)':
self.stat.append(('count(*)', 'GT=2'))
elif item == '#(het)':
self.stat.append(('count(*)', 'GT=1'))
elif item == '#(other)':
self.stat.append(('count(*)', 'GT=-1'))
elif item == '#(wtGT)':
self.stat.append(('count(*)', 'GT=0'))
elif item == '#(mutGT)':
self.stat.append(('count(*)', 'GT!=0'))
elif item.startswith('#'):
raise ValueError('{} is not a valid special function (only #(GT), #(wtGT), #(mutGT), #(alt), #(hom), #(het), and #(other) are allowed).'.format(item))
else:
self.stat.append((item, None))
self.queue = idQueue
self.status = status
self.genotypes = genotypes
# threading.Thread.__init__(self, name='Calculate genotype statistics')
Process.__init__(self, name='Calculate genotype statistics')
def __init__(self, task_queue, results_queue, individuals):
"""
Initialize the VariantAnnotator
Consume variant batches from the task queue, annotate them with the
genetic inheritance patterns that they follow and put them in the
results queue.
Arguments:
task_queue (Queue)
results_queue (Queue)
individuals (list)
"""
Process.__init__(self)
self.proc_name = self.name
logger.info("Setting up variant_annotator: {0}".format(
self.proc_name))
logger.debug("Setting up task queue")
self.task_queue = task_queue
logger.debug("Setting up results queue")
self.results_queue = results_queue
logger.debug("Setting up individuals")
self.individuals = individuals
if len(self.individuals) == 1:
self.models = ['AR_comp', 'AR_comp_dn', 'AD', 'AD_dn']
else:
self.models = ['AR_comp', 'AR_comp_dn']
def __init__(self, id, GPR, crawlers_queue):
Process.__init__(self)
self.id = id
self.GPR = GPR
# Making a queue only contains 1 element.
self.__queue = Queue(1)
self.__crawlers_queue = crawlers_queue
def __init__(self,
name,
files,
output_queue,
logging_queue,
gridmode=False,
metadata=None,
profile=False,
nice=0,
**kwargs):
Process.__init__(self)
self.uuid = uuid.uuid4().hex
self.filters = {}
self.name = name
self.files = files
self.metadata = metadata
self.logging_queue = logging_queue
self.output_queue = output_queue
self.output = None
self.gridmode = gridmode
self.nice = nice
self.kwargs = kwargs
self.output = None
self.queuemode = isinstance(files, multiprocessing.queues.Queue)
self.profile = profile
def __init__(self,connection,size,type_,title,fit):
"""
**SUMMARY**
Creates a new process to handle the gtk mainloop for a display.
**PARAMETERS**
* *connection* - The connection used to communicate with parent
* *size* - Initial size of display.
* *type_* - The type of dispay.
* *fit* - the fitting methods of the display.
"""
#TODO , the doc references
Process.__init__(self)
self.connection = connection
self.size = size
self.fit = fit
self.title = title
self.type_ = type_
self.daemon = True
def __init__(self, job, update_heartbeat=True, *args, **kwargs):
self.job = job
Process.__init__(self, *args, **kwargs)
# Don't let this process hold up the parent.
self.daemon = True
self.update_heartbeat = update_heartbeat
def __init__(self, gpuid, queue):
Process.__init__(self, name='ModelProcessor')
self._gpuid = gpuid
self._queue = queue
def __init__(self, *args):
Process.__init__(self)
self.daemon = True
super(ResultCollectorProcess,self).__init__(*args)
def __init__(self, gpuid, queue):
Process.__init__(self,
name='ModelProcessor') # inheritance from Process
self._gpuid = gpuid #assigined gpu id for this thread
self._queue = queue
def __init__(self, options, resultsQueue):
Process.__init__(self)
self.daemon = True
self.options = options
self._resultsQueue = resultsQueue
def __init__(self, start, queue): # сохраняет данные для
self.state = start # использования в методе run
self.post = queue
Process.__init__(self)
def __init__(self, blobs_queue, repo_path, output_dir):
Process.__init__(self)
self.blobs_queue = blobs_queue
self.output_dir = output_dir
self.repo_path = repo_path
def __init__(self, connec, *args, **kwargs):
self.connec = connec
Process.__init__(self, *args, **kwargs)
def __init__(self, queue, rezqueue):
Process.__init__(self)
self.queue = queue
self.rezqueue = rezqueue
def __init__(self,controlq,statusq,qs):
Process.__init__(self)
self.controlq = controlq
self.statusq = statusq
self.qs = qs
self.exception_raised = False
def __init__(self, rezqueue):
Process.__init__(self)
self.rezqueue = rezqueue
def __init__(self, uri, archivo, tipo):
gobject.GObject.__init__(self)
Process.__init__(self)
self.tipo = tipo
if not archivo.endswith(".ogg"):
archivo = "%s%s" % (archivo, ".ogg")
self.patharchivo = archivo
self.actualizador = False
self.estado = None
self.control = 0
self.tamanio = 0
self.uri = ""
self.pipeline = None
self.player = None
self.archivo = None
self.bus = None
self.pipeline = gst.Pipeline()
self.player = gst.element_factory_make("uridecodebin", "uridecodebin")
self.player.set_property("buffer-size", 40000)
self.player.set_property("download", True)
self.pipeline.add(self.player)
# AUDIO
audioconvert = gst.element_factory_make('audioconvert', 'audioconvert')
audioresample = gst.element_factory_make(
'audioresample', 'audioresample')
audioresample.set_property('quality', 10)
vorbisenc = gst.element_factory_make('vorbisenc', 'vorbisenc')
self.pipeline.add(audioconvert)
self.pipeline.add(audioresample)
self.pipeline.add(vorbisenc)
audioconvert.link(audioresample)
audioresample.link(vorbisenc)
self.audio_sink = audioconvert.get_static_pad('sink')
# VIDEO
videoconvert = gst.element_factory_make(
'ffmpegcolorspace', 'videoconvert')
videorate = gst.element_factory_make('videorate', 'videorate')
try:
videorate.set_property('max-rate', 30)
except:
pass
theoraenc = gst.element_factory_make('theoraenc', 'theoraenc')
if self.tipo == "video":
self.pipeline.add(videoconvert)
self.pipeline.add(videorate)
self.pipeline.add(theoraenc)
videoconvert.link(videorate)
videorate.link(theoraenc)
self.video_sink = videoconvert.get_static_pad('sink')
# MUXOR y ARCHIVO
oggmux = gst.element_factory_make('oggmux', "oggmux")
self.archivo = gst.element_factory_make('filesink', "filesink")
self.pipeline.add(oggmux)
self.pipeline.add(self.archivo)
vorbisenc.link(oggmux)
if self.tipo == "video":
theoraenc.link(oggmux)
oggmux.link(self.archivo)
self.bus = self.pipeline.get_bus()
self.bus.add_signal_watch()
self.bus.connect('message', self.__on_mensaje)
self.bus.enable_sync_message_emission()
self.bus.connect('sync-message', self.__sync_message)
self.player.connect('pad-added', self.__pad_added)
self.load(uri)
def __init__(self, *args, **kwargs):
Process.__init__(self, *args, **kwargs)
self._receive_pipe, self._send_pipe = Pipe()
self._exception = None
self.called_function = kwargs.get('target')
def __init__(self, driver):
Process.__init__(self)
self.name = driver.__class__.__name__
self.driver = driver
def __init__(self,qin,qout):
Process.__init__(self)
self.qin = qin
self.qout = qout
def __init__(self, paths, queue): self.paths = paths self.post = queue Process.__init__(self)
def __init__(self):
Process.__init__(self)
def __init__(self, voiceFilePath):
Process.__init__(self)
self.voiceFilePath = voiceFilePath
def __init__(self, outfilename, queue): self.out = outfilename self.post = queue Process.__init__(self)
def __init__(self, conf_file_path, queue: Queue):
Process.__init__(self)
logging.config.fileConfig(conf_file_path)
self.queue = queue
def __init__(self, sid, kanming, i, dic):
Process.__init__(self)
self.row = i
self.sid = sid
self.kanming = kanming
self.dic = dic
def __init__(self, a, b, count1):
Process.__init__(self)
self.a = a
self.b = b
self.count1 = count1
def __init__(self, port, results):
#initialize the process
Process.__init__(self)
self.port = port
self.results = results
def __init__(self, processId, name, q):
Process.__init__(self)
self.processId = processId
self.name = name
self.q = q
def __init__(self, interval, name=''):
Process.__init__(self)
self.interval = interval
if name:
self.name = name
def __init__(self, pipe):
Process.__init__(self)
self.pipe = pipe
def __init__(self, folderList=[], delay=3000, lock=Lock()):
self.folderList = set(folderList)
self.delay = delay
self.lock = lock
self.prevSet = set()
Process.__init__(self)
def __init__(self, queue):
self.queue = queue
Process.__init__(self)
Observable.__init__(self)
def __init__(self, interval):
Process.__init__(self)
self.__interval = interval
def __init__(self, name, queue, lock, result): # <5>
Process.__init__(self)
self.queue = queue
self.result = result
self.lock = lock
self.name = name
def __init__(self, klass, i, kwargs, queue):
Process.__init__(self)
self.simulator = klass(name='{} {}'.format(klass.__name__, i), **kwargs)
self.queue = queue
