def __init__(self, global_queue): """ Initializes the private queue :param global_queue: Object of the global Queue """ Queue.__init__(self) self.global_queue = global_queue
def __init__(self, maxsize=0, num_workers=1, verbosity=0): Queue.__init__(self, maxsize=maxsize) self.num_workers = num_workers self.verbosity = verbosity self.threads = [] self.start_workers()
def __init__(self, db_base_dir=None, on_scan_complete=None, extra_module_dirs=None, env=None, db_event_reporter=None, db_catalog_dirs=None, db_import_everything_langs=None): """Create a CodeIntel manager. "db_base_dir" (optional) specifies the base directory for the codeintel database. If not given it will default to '~/.codeintel'. "on_scan_complete" (optional) is a callback for Citadel scan completion. It will be passed the ScanRequest instance as an argument. "extra_module_dirs" (optional) is a list of extra dirs in which to look for and use "codeintel_*.py" support modules (and "lang_*.py" modules, DEPRECATED). "env" (optional) is an Environment instance (or subclass). See environment.py for details. "db_event_reporter" (optional) is a callback that will be called db_event_reporter(<event-desc-string>) before "significant" long processing events in the DB. This may be useful to forward to a status bar in a GUI. "db_catalog_dirs" (optional) is a list of catalog dirs in addition to the std one to use for the CatalogsZone. All *.cix files in a catalog dir are made available. "db_import_everything_langs" (optional) is a set of langs for which the extra effort to support Database `lib.hits_from_lpath()' should be made. See class Database for more details. """ threading.Thread.__init__(self, name="CodeIntel Manager") self.setDaemon(True) Queue.__init__(self) self.citadel = Citadel(self) # Module registry bits. self._registered_module_canon_paths = set() self.silvercity_lexer_from_lang = {} self.buf_class_from_lang = {} self.langintel_class_from_lang = {} self._langintel_from_lang_cache = {} self.import_handler_class_from_lang = {} self._is_citadel_from_lang = { } # registered langs that are Citadel-based self._is_cpln_from_lang = { } # registered langs for which completion is supported self._hook_handlers_from_lang = defaultdict(list) self.env = env or DefaultEnvironment() # The database must be enabled before registering modules. self.db = Database(self, base_dir=db_base_dir, catalog_dirs=db_catalog_dirs, event_reporter=db_event_reporter, import_everything_langs=db_import_everything_langs) self.lidb = langinfo.get_default_database() self._register_modules(extra_module_dirs) self.idxr = indexer.Indexer(self, on_scan_complete)
def __init__(self, id, blocking=False, timeout=None, throwing=False): Queue.__init__(self) self.id = id self.owner = owner self.blocking = blocking self.timeout = timeout self.throwing = throwing self.event_handlers = []
def __init__(self, *qargs, **qkeys): """Construct an execution queue. `qargs` and `qkeys` are passed to the underlying `Queue` object. """ Queue.__init__(self, *qargs, **qkeys) self.__current_exec = None self.__exec_mutex = threading.Lock()
def __init__(self, workers=1): """ initialize a new Queue :param workers: number of workers """ Queue.__init__(self) self.workers_count = workers self.workers = []
def __init__(self, maxsize=10): """ Class constructor. Instantiates a new :class:`.XBeeQueue` with the provided parameters. Args: maxsize (Integer, default: 10) the maximum size of the queue. """ Queue.__init__(self, maxsize)
def __init__(self, size): Queue.__init__(self, maxsize=size) self.logger = self.create_logger() self.is_stopped_lock = Lock() self.is_stopped = False self.is_running_lock = Lock() self.is_running = True self.thread = None
def __init__(self, config, prefix, producer = True): # base class init Queue.__init__(self, config, prefix, producer) # get other attributes self._folder = config.getMulti(prefix, "folder") self._ext = "." + config.getMulti(prefix, "extension", "bin") self._period = config.getMulti(prefix, "rescan", 5) self._pid = config.getMulti(prefix, "lockfile", "queue.pid") self._keep = config.getMulti(prefix, "keep", False) self._errFolder = config.getMulti(prefix, "errFolder", "err") self._newFolder = config.getMulti(prefix, "newFolder", "new") self._doneFolder = config.getMulti(prefix, "doneFolder", "done") self._workFolder = config.getMulti(prefix, "workFolder", "work") self._errFolder = self._folder + os.sep + self._errFolder self._newFolder = self._folder + os.sep + self._newFolder self._doneFolder = self._folder + os.sep + self._doneFolder self._workFolder = self._folder + os.sep + self._workFolder self._pattern = re.compile("^[0-9]{20}-[0-9a-fA-F]{12}-[0-9a-fA-F]{8}" + self._ext + "$") # only for consumer queue instances, but define for all self._seq = Sequencer(0) self._queue = [ ] # check we have a folder if self._folder is None: raise QueueConfigurationException("Missing folder path for queue [%s]" % prefix) # be sure all folders exist self._ensureFolder(self._folder) if not self._producer: self._ensureFolder(self._errFolder) self._ensureFolder(self._newFolder) self._ensureFolder(self._doneFolder) self._ensureFolder(self._workFolder) # if a consumer, lock the queue if not self._producer: # the pid file pidfile = self._folder + os.sep + self._pid # try locking self._lockFile = None try: self._lockFile = zc.lockfile.LockFile(pidfile) except zc.lockfile.LockError: raise QueueFolderLockException("Cannot lock queue, pid file [%s]" % pidfile) # if there are entries in work, move them to ready # # NOTE: only if we are consumers if not self._producer: self._undoWork() # if not a producer, scan the queue if not self._producer: self._rescan()
def __init__(self, **kwargs): Queue.__init__(self) SchemaConstructor.__init__(self, schema=CONFIG_CREATE_JOB_QUEUE, default_values=self.DEFAULT_VALUES, defined_values=kwargs) ARNObject.__init__(self, name=self.jobQueueName, resource="job-queue/" + self.jobQueueName)
def __init__(self, maxsize=BUFFER_SIZE): Queue.__init__(self, maxsize) self._runlevel = 0 self._writable_runlevel = 0 self.on_initialize = noop self.on_begin = noop self.on_end = noop self.on_finalize = noop
def __init__(self, maxsize=0): """Constructor Parameters: maxsize -- Maximium size of this Pile """ Queue.__init__(self, maxsize) self._tasks = c_int(0) self._tasks_lock = Lock()
def __init__(self, name, size=0, threads=-1, profile=False, target=None): Queue.__init__(self, size) self.name = name self.__threads = [] for i in range(threads): th = WorkThread(self, None, ThreadPool.worker, "%s-%d" % (name, i), (target, profile)) self.__threads.append(th) th.start()
def __init__(self, maxsize=0, timeout=None, name=None): # extend the base class Queue.__init__(self, maxsize) self.timeout = timeout logger_name = __name__ self.name = name if name is not None: logger_name = '{}.{}'.format(logger_name, name) self._logger = logging.getLogger(logger_name)
def __init__(self): """ Inits self. self.c_callback is the real C-like callback function. """ Event.__init__(self) Queue.__init__(self) self.c_callback = \ ctypes.WINFUNCTYPE(ctypes.c_void_p, ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int))(self.Callbackfunc)
def __init__(self,maxsize=0,autoSetup=True, outstream=None): Queue.__init__(self,maxsize) EThread.__init__(self, outstream) self._queueWait = 1 self._retryWait = 5 if autoSetup: try: self._cleanSetup() except Exception as e: self._log(e)
def __init__(self, maxsize, timeout=None): """ Queue helper class Args: maxsize (int): Create a queue object with a given maximum size. 0 means infinite. time_out (int, optional): timeout of waiting block in seconds. Defaults to None. """ Queue.__init__(self, maxsize) self._timeout = timeout
def __init__(self, wbxmlBytes): self.bytesDequeued = 0 self.bytesEnqueued = 0 Queue.__init__(self) for byte in wbxmlBytes: self.put(ord(byte)) self.bytesEnqueued += 1 logging.debug("Array byte count: %d, enqueued: %d" % (self.qsize(), self.bytesEnqueued))
def __init__(self, wbxmlBytes): self.bytesDequeued = 0 self.bytesEnqueued = 0 Queue.__init__(self) for byte in wbxmlBytes: self.put(byte) self.bytesEnqueued += 1 logging.debug("Array byte count: %d, enqueued: %d" % (self.qsize(), self.bytesEnqueued))
def __init__(self, poolType, poolLimit, dbClass, *args, **kwargs): """ poolLimit: if elastic, this is the min connection number, otherwise this is the max number of connection """ self.poolType= self._dbPoolType or poolType self.dbClass= self._dbClass or dbClass self.args= self._dbArgs or args self.kwargs= self._dbKwargs or kwargs self.dbifaces= 0 self.poolLimit= self._dbPoolLimit or poolLimit # We Need a Lock because, altough Queue is thread safe, # we want a full control on queue size self.mpoolingLock= Lock() self.dbemployed= [] Queue.__init__(self)
def __init__(self, size=1, maxjobs=0, worker_factory=default_worker_factory): if not isinstance(worker_factory, collections.Callable): raise TypeError("worker_factory must be callable") self.worker_factory = worker_factory # Used to build new workers self._size = 0 # Number of active workers we have # Initialize the Queue Queue.__init__(self, maxjobs) # The queue contains job that are read by workers self._jobs = self # Pointer to the queue, for backwards compatibility with version 0.9.1 and earlier # Hire some workers! for i in range(size): self.grow()
def __init__(self, path, exclude=None): class _EH(ProcessEvent): def process_default(self, event): _handleEvent(event) Queue.__init__(self) self._path = path self.exclude = exclude or [] _handleEvent = self.put self._wm = WatchManager() self._iNotifier = ThreadedNotifier(self._wm, _EH(), timeout=10) self._iNotifier.start() self.started = False self._watch = []
def __init__(self, width=200, height=200): Thread.__init__(self) Queue.__init__(self) self.dims = (width, height) self.cam = picamera.PiCamera() self.daemon = True self.cam.iso = 100 self.cam.brightness = 40 self.cam.color_effects = (128, 128) self.cam.hflip = True self.cam.meter_mode = 'matrix' self.cam.shutter_speed = 7500 sleep(0.5) #wait for camera to update
def __init__(self, name, type): """ This is the default constructor for the class. :param name: The name of the queue :param type: The type of the queue :return: """ # Override the base class Queue.__init__(self) # Set internals self.__name = name self.__type = type return
def __init__(self, path, maxsize=0, chunksize=100, tempdir=None): """Create a persistent queue object on a given path. The argument path indicates a directory where enqueued data should be persisted. If the directory doesn't exist, one will be created. If maxsize is <= 0, the queue size is infinite. The optional argument chunksize indicates how many entries should exist in each chunk file on disk. The tempdir parameter indicates where temporary files should be stored. The tempdir has to be located on the same disk as the enqueued data in order to obtain atomic operations. """ self.path = path self.chunksize = chunksize self.tempdir = tempdir if self.tempdir: if os.stat(self.path).st_dev != os.stat(self.tempdir).st_dev: raise ValueError("tempdir has to be located " "on same path filesystem") SyncQ.__init__(self, maxsize) self.info = self._loadinfo() # truncate head case it contains garbage hnum, hcnt, hoffset = self.info['head'] headfn = self._qfile(hnum) if os.path.exists(headfn): if hoffset < os.path.getsize(headfn): _truncate(headfn, hoffset) # let the head file open self.headf = self._openchunk(hnum, 'ab+') # let the tail file open tnum, _, toffset = self.info['tail'] self.tailf = self._openchunk(tnum) self.tailf.seek(toffset) # update unfinished tasks with the current number of enqueued tasks self.unfinished_tasks = self.info['size'] # optimize info file updates self.update_info = True
def __init__(self): Queue.__init__(self) self.virgin = True
def __init__(self, application, num_workers=1): Queue.__init__(self) self.application = application self.num_workers = num_workers self.processor = Processor(application) self.start_workers()
def __init__(self, mc=None, n_slots=None): Queue.__init__(self, n_slots) if mc is not None: self.fill(mc, n_slots)
def __init__(self, constructor, poolsize): Queue.__init__(self, poolsize) self.constructor = constructor
def __init__(self, notify_func, **kwargs): Queue.__init__(self, **kwargs) self.notify_func = notify_func
def __init__(self, *args): Queue.__init__(self, *args)
def __init__(self, *args, **kwargs): Queue.__init__(self, *args, **kwargs) self._close_event = Event() self._close_event.clear()
def __init__(self): Queue.__init__(self, queue='basic')
def __init__(self, *args): Queue.__init__(self, *args) # Queue does not inherit from object (is an old-style class) self._all_jobs_submitted = threading.Event()
def __init__(self, maxsize=1000): Queue.__init__(self, maxsize=maxsize)
def __init__(self, **kwargs): Queue.__init__(self)
def __init__(self): """""" gtk.GenericTreeModel.__init__(self) Queue.__init__(self) self.column_types = (gtk.gdk.Pixbuf, str, int, int, int, int) self.cache = Cache()
def __init__(self, maxsize=1000): """Queue constructor.""" Queue.__init__(self, maxsize=maxsize)
def __init__(self): Queue.__init__(self, queue='work')
def __init__(self, patients=[]): Queue.__init__(self, patients)
def __init__(self, f, maxsize=0): Queue.__init__(self, maxsize) self.queue = [] self.f = f
def __init__(self, session, destination): Queue.__init__(self) self.session = session self.destination = destination
def __init__(self, exchange='exchange_001', type='direct'): Queue.__init__(self) self.channel.exchange_declare(exchange=exchange, type=type) self.exchange = exchange self.type = type
def __init__(self): Queue.__init__(self)
def __init__(self): Queue.__init__(self) self.patients = []
def __init__(self): Queue.__init__(self) self.all_tasks_done = threading.Condition(self.mutex) self.unfinished_tasks = 0