Ex : on a relancer le controller avec ces models par default ?\n # ou si on a retirer 2 fois un model random,\n\n if job_id is not None:\n # I have found something in the queue\n break\n\n must_stop, reason = self.must_stop()\n if must_stop:\n break\n\n current_time = time.time()\n if (\n self.max_queue_waiting_time is not None\n and current_time - _start_time_queue >= self.max_queue_waiting_time\n ):\n logger.info(\"queue was empty...\")\n logger.info(\"stop waiting for queue\")\n break\n else:\n if do_print:\n logger.info(\"queue was empty...\")\n logger.info(\"wait for queue for %d sec(s)\" % self.input_queue_sleeping_time)\n do_print = False # to print only time\n time.sleep(self.input_queue_sleeping_time)\n\n ###########################################\n # max_queue_waiting_time : #\n # * None <=> inf => wait forever #\n # * -1 => don't wait at all #\n # * x => wait x seconds #\n ###########################################\n\n if job_id is None:\n self.worker_informations[\"stopped\"] = True\n self.worker_informations[\"stopping_reason\"] = \"empty queue\"\n self.write_worker_informations()\n\n break\n\n if must_stop:\n self.worker_informations[\"stopped\"] = True\n self.worker_informations[\"stopping_reason\"] = reason\n self.write_worker_informations()\n logger.info(\"I must stop because %s\" % reason)\n break\n\n ###########################################\n ### Retrieve the parameters of that job ###\n ###########################################\n job_param = self.data_persister.read(key=job_id, path=\"job_param\", write_type=SavingType.json)\n\n logger.info(\"start job_id : %s\" % job_id)\n logger.info(\"\")\n\n try:\n _success = False\n start_time = time.time()\n\n #################################\n ### Send job_id and job_param ###\n #################################\n yield job_id, job_param\n\n return_time = time.time()\n _success = True\n \n except Exception as e:\n logger.fatal(e, exc_info=True)\n raise e\n\n finally:\n\n if not _success:\n ####################################\n ### It means there were an error ###\n ####################################\n self.worker_informations[\"stopped\"] = True\n self.worker_informations[\"stopping_reason\"] = \"error\"\n self.write_worker_informations()\n\n ########################\n ### Save time of job ###\n ########################\n self._all_times.append(return_time - start_time)\n\n ##################################\n ### Do a garbage collector run ###\n ##################################\n GARGAGE_COUNT += 1\n if GARGAGE_COUNT >= self.gc_collect_freq:\n GARGAGE_COUNT = 0\n gc.collect()\n\n ###############################\n ### Add job to 'done queue' ###\n ###############################\n could_add = False\n _start_time_done_queue = time.time()\n\n do_print = True\n while True:\n could_add = self.job_done.add(data=job_id)\n\n if could_add:\n break\n\n must_stop, reason = self.must_stop()\n if must_stop:\n break\n\n current_time = time.time()\n if (\n self.max_done_queue_waiting_time is not None\n and current_time - _start_time_done_queue >= self.max_done_queue_waiting_time\n ):\n logger.info(\"done queue was full...\")\n logger.info(\"stop waiting for done queue\")\n break\n else:\n if do_print:\n logger.info(\"done queue was full...\")\n logger.info(\"wait for done queue for %d sec(s)\" % self.done_queue_sleeping_time)\n\n do_print = False # to print only once\n time.sleep(self.done_queue_sleeping_time)\n\n #############################################\n # max_done_queue_waiting_time : #\n # * None <=> inf : wait for ever #\n # * -1 : don't wait at all #\n # * x : wait for x seconds #\n #############################################\n\n # Ici : regarder si on a un flag 'stop'\n\n if not must_stop:\n must_stop, reason = self.must_stop()\n\n if must_stop:\n self.worker_informations[\"stopped\"] = True\n self.worker_informations[\"stopping_reason\"] = reason\n self.write_worker_informations()\n logger.info(\"I must stop because %s\" % reason)\n break","def worker(self, queue):\n with sa.create_engine(dsn).connect() as dbcon:\n while True:\n if queue.qsize() == 0:\n sleep(1)\n if queue.qsize() == 0:\n break\n continue\n item = queue.get()\n try:\n if hash(item['title']) in self.exist_products:\n dbcon.execute(Product.update().values(**item).where(Product.c.id == self.get_id(item)))\n else:\n result = dbcon.execute(Product.insert().values(**item))\n self.exist_products[hash(item['title'])] = result.inserted_primary_key[0]\n except Exception as e:\n print(type(e), e)","def run(self):\n while True:\n self._event.clear()\n self._queue.get().run(self._event)","def run(self):\n init()\n list_name = comet_config.REDIS_NAMESPACE + \"incoming/\" + self.service_name\n list_name_processing = list_name + \"/processing\"\n self.redis = r\n while True:\n try:\n item = self.redis.brpoplpush(list_name, list_name_processing)\n self.process_incoming(item)\n self.redis.lrem(list_name_processing, item)\n\n except redis.ConnectionError:\n pass","def _dispatch(self, batch):\n # If job.get() catches an exception, it closes the queue:\n if self._aborting:\n return\n\n batch_size = len(batch)\n\n self.n_dispatched_tasks += batch_size\n self.n_dispatched_batches += 1\n\n dispatch_timestamp = time.time()\n\n batch_tracker = BatchCompletionCallBack(\n dispatch_timestamp, batch_size, self\n )\n self._jobs.append(batch_tracker)\n\n job = self._backend.apply_async(batch, callback=batch_tracker)\n batch_tracker.register_job(job)","def work(self):\r\n worker = self.worker_place_item()\r\n if not worker:\r\n worker = self.worker_take_item()\r\n\r\n if not worker:\r\n for worker in self.workers:\r\n worker.work()\r\n else:\r\n worker = [w for w in self.workers if w is not worker][0]\r\n worker.work()","def collect(self):\n while True:\n if not self._queue.empty():\n message = self._queue.get()\n self.working_on = message['job_type']\n else:\n break\n logging.info(\"Popped off message: {}\\n\".format(str(message)))\n\n if message['job_type'] == 'STOP':\n break\n\n if message['job_type'] != 'MAINTAIN' and message['job_type'] != 'UPDATE':\n raise ValueError('{} is not a recognized task type'.format(message['job_type']))\n pass\n\n \"\"\" Query all repos with repo url of given task \"\"\"\n repoUrlSQL = s.sql.text(\"\"\"\n SELECT min(repo_id) as repo_id FROM repo WHERE repo_git = '{}'\n \"\"\".format(message['given']['git_url']))\n repo_id = int(pd.read_sql(repoUrlSQL, self.db, params={}).iloc[0]['repo_id'])\n\n try:\n if message['models'][0] == 'badges':\n self.badges_model(message, repo_id)\n except Exception as e:\n register_task_failure(self, logging, message, repo_id, e)\n pass","def _submit_to_queue(self, script_file):","def _wait_empty(self):\n while True:\n if self.queue.empty():\n # We still have to wait for the last queue item being processed\n # (queue.empty() returns True before queue.task_done() is\n # called).\n self.queue.join()\n return\n time.sleep(1)","def enqueue_task(self, next_state):\n\t\t# TODO(bslatkin): Remove these retries when they're not needed in userland.\n\t\tRETRIES = 3\n\t\ttarget_queue = os.environ.get('X_APPENGINE_QUEUENAME', SUBSCRIPTION_QUEUE)\n\t\tfor i in xrange(RETRIES):\n\t\t\ttry:\n\t\t\t\ttaskqueue.Task(\n\t\t\t\t\t\turl='/work/subscriptions',\n\t\t\t\t\t\teta=self.eta,\n\t\t\t\t\t\tparams={'subscription_key_name': self.key().name(),\n\t\t\t\t\t\t\t\t\t\t'next_state': next_state}\n\t\t\t\t\t\t).add(target_queue)\n\t\t\texcept (taskqueue.Error, apiproxy_errors.Error):\n\t\t\t\tlogging.exception('Could not insert task to confirm '\n\t\t\t\t\t\t\t\t\t\t\t\t\t'topic = %s, callback = %s',\n\t\t\t\t\t\t\t\t\t\t\t\t\tself.topic, self.callback)\n\t\t\t\tif i == (RETRIES - 1):\n\t\t\t\t\traise\n\t\t\telse:\n\t\t\t\treturn","def collect(self):\n while True:\n if not self._queue.empty():\n message = self._queue.get()\n self.working_on = message['job_type']\n else:\n break\n logging.info(\"Popped off message: {}\\n\".format(str(message)))\n\n if message['job_type'] == 'STOP':\n break\n\n if message['job_type'] != 'MAINTAIN' and message['job_type'] != 'UPDATE':\n raise ValueError('{} is not a recognized task type'.format(message['job_type']))\n pass\n\n # Query all repos with repo url of given task\n repoUrlSQL = s.sql.text(\"\"\"\n SELECT min(repo_id) as repo_id FROM repo WHERE repo_git = '{}'\n \"\"\".format(message['given']['github_url']))\n repo_id = int(pd.read_sql(repoUrlSQL, self.db, params={}).iloc[0]['repo_id'])\n\n try:\n if message['models'][0] == 'pull_requests':\n self.pull_requests_model(message, repo_id)\n elif message['models'][0] == 'pull_request_commits':\n self.pull_request_commits_model(message, repo_id)\n elif message['models'][0] == 'pull_request_files':\n self.pull_requests_graphql(message, repo_id)\n except Exception as e:\n register_task_failure(self, message, repo_id, e)\n pass","def task_done(self):\n\t\ttry:\n\t\t\tself.logger.debug('Im trying mark queue job item as done')\n\t\t\tself.queue.task_done()\n\t\t\tself.logger.debug('Queue job item mark as done')\n\t\t\treturn True\n\t\texcept ValueError, e:\n\t\t\tself.logger.error('Error method task_done, error: %s'%(e),exc_info=True)\n\t\t\treturn False","def threadWorker(self):\n while True:\n row = self.queue.get() #get a row of data\n if row is None: #ending criterium\n break\n self.similarityQuestions(row) #the actual working function\n self.queue.task_done() #inform the queue one task is done","def worker(**kwargs):\n\t\tident = kwargs[\"ident\"]\n\t\twhile True:\n\t\t\titem = worker_queue.get()\n\t\t\tif item is None:\n\t\t\t\tbreak\n\t\t\tworker_function(ident, item)\n\t\t\tworker_queue.task_done()","def _begin_consuming(self):\n self._consuming = True\n loop = asyncio.get_event_loop()\n self._message_queue = asyncio.Queue(\n maxsize=self.app.settings['SQS_PREFETCH_LIMIT'],\n loop=loop,\n )\n loop.create_task(self._consume())","def reAddJob(self, runner):\n with self.__queueLock:\n if not runner.clientRunner:\n self.__queue.append(runner)\n else:\n self.__clientQueue.append(runner)\n if self.__profileJobs:\n runner.trackTime('queue')\n self.__submittedJobs.append(runner.identifier)","def _worker(self, task, task_queue):\n with _thread_lock:\n task.process_number = self.counter\n self.counter += 1\n if task.output:\n if not task.has_error and task.processtime > 0:\n if not os.path.isfile(task.logfile):\n task.logfile = \"\"\n task_queue.put(task)\n return\n try:\n if not os.path.exists(task.folder):\n task.add_error('Could not find folder: {}'.format(task.folder))\n task.logfile = \"\"\n else:\n tmp_kwargs = dict(mode='a+', prefix=self.logfile_prefix,\n suffix='.log', dir=task.folder, delete=False)\n with NamedTemporaryFile(**tmp_kwargs) as logfile:\n logfile.write('########### MACRO #############\\n')\n logfile.write(\"\\n\".join(task.macro))\n logfile.write('\\n\\n######### OUTPUT LOG ##########')\n logfile.flush()\n task.logfile = logfile.name\n starttime = time.clock()\n exe_args = dict(macro=task.macro,\n logfile=logfile,\n anybodycon_path=self.anybodycon_path,\n timeout=self.timeout,\n keep_macrofile=self.keep_logfiles,\n env=self.env)\n retcode = _execute_anybodycon(**exe_args)\n endtime = time.clock()\n logfile.seek(0)\n if retcode == _KILLED_BY_ANYPYTOOLS:\n task.processtime = 0\n return\n task.processtime = endtime - starttime\n task.output = parse_anybodycon_output(\n logfile.read(),\n self.ignore_errors,\n self.warnings_to_include)\n except Exception as e:\n exc_type, exc_obj, exc_tb = sys.exc_info()\n fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]\n task.add_error(str(exc_type) + '\\n' + str(fname) + '\\n' + str(exc_tb.tb_lineno))\n logger.debug(str(e))\n finally:\n if not self.keep_logfiles and not task.has_error:\n try:\n silentremove(logfile.name)\n task.logfile = \"\"\n except OSError as e:\n pass # Ignore if AnyBody has not released the log file.\n task_queue.put(task)","def _drain_queue(self):\n while self.queue:\n self._export_batch()","def _run(self) -> None:\n while True:\n args: MigrationArgs = self._queue.get(block=True)\n with self._lock:\n if args.collection in self._chunks:\n if args.shard_key not in self._chunks[args.collection]:\n self._split_chunk(args.collection, args.shard_key)\n self._move_chunk(args)","def manage_cache_tasks(self):\n outstanding_threads = self._has_outstanding_threads()\n try:\n # Get a task from the cache queue, waiting less if we have active threads.\n timeout = NONBLOCKING_TIMEOUT if outstanding_threads else BLOCKING_TIMEOUT\n\n # Toggle between refresh and update queues so as to prevent starvation.\n self._check_refresh_queue = not self._check_refresh_queue\n if self._check_refresh_queue:\n catalog, action = self._refresh_queue.get(timeout=timeout)\n else:\n catalog, action = self._update_queue.get(timeout=timeout)\n\n except Empty:\n # No task exists in the cache queue, proceed to check for thread execution\n pass\n\n else:\n # Create and start a thread for the task\n updater_thread = CacheUpdateWorker(\n self._component_cache,\n self._refresh_queue if self._check_refresh_queue else self._update_queue,\n catalog,\n action,\n )\n updater_thread.start()\n queue_clause = \"refreshing\" if self._check_refresh_queue else \"updating\"\n self.log.debug(f\"CacheUpdateWorker {queue_clause} catalog: '{updater_thread.name}', action: '{action}'...\")\n self._threads.append(updater_thread)","def reveille(self):\n now = datetime.datetime.now()\n # TODO: this logic can be optimized if our queue has a peek() method\n while self._queue.size() > 0:\n item = self._queue.get_tuple()\n if item[1] <= now:\n self._callback(item[0])\n else:\n # put the item back & terminate iteration\n self._queue.put(item[0], item[1])\n break","def process_queue(self):\n while self.input_processing_running:\n\n # Process everything in the queue.\n while self.input_queue.qsize() > 0:\n try:\n _telem = self.input_queue.get_nowait()\n self.process_telemetry(_telem)\n\n except Exception as e:\n self.log_error(\"Error processing telemetry dict - %s\" % str(e))\n\n # Sleep while waiting for some new data.\n time.sleep(0.5)","def putting_task(self, func, *args, **kws):\n if self.is_join:\n raise self.TreadPoolException('Thread pool is closed.')\n result_id = kws.pop('_result_id', self.NULLKEY)\n task = self.setup_func(result_id, func, *args, **kws)\n # mark one position in queue has been taken.\n self.task_queue.put(True)\n self.execute_task(task)"],"string":"[\n \"def schdule(self):\\n while self.queue:\\n if self.processing >= self.maxProcessing:\\n # We have reached the maximum number of parallel\\n # tasks.\\n break\\n\\n item, completeDeferred = self.queue.pop(0)\\n\\n self.processing += 1 \\n self.start(item).addBoth(self.done).chainDeferred(completeDeferred)\",\n \"def check_queue():\\n while True:\\n logging.info( 'Awaiting task ' )\\n yield from asyncio.sleep( 5 )\\n loop.create_task( (start_background_tasks()) )\",\n \"def _manager_main(self, queue):\\r\\n for task in self._task_generator():\\r\\n queue.put(task)\",\n \"def _worker_main(self, task_queue, data_queue):\\r\\n while True:\\r\\n task = task_queue.get()\\r\\n sample = self._task_func(task)\\r\\n if sample is None:\\r\\n continue\\r\\n data_queue.put(sample)\",\n \"def _worker(self):\\n while True:\\n request = self.queue.get()\\n self.worker(request)\\n self.queue.task_done()\",\n \"def monitor_queue(self):\\n\\n while True:\\n job = self.queue.next()\\n if job:\\n # print(\\\"found %s\\\" % (job.job_id))\\n\\n job_name = job.payload[\\\"job_name\\\"]\\n\\n if job_name in self.mul_func_map:\\n\\n t = self.mul_func_map[job_name]\\n p = multiprocessing.Process(target=t, args=(job,))\\n p.daemon = True\\n p.start()\\n\\n elif job_name in self.th_func_map:\\n\\n t = self.th_func_map[job_name]\\n # create a thread to process the job\\n p = threading.Thread(target=t, args=(job,))\\n p.daemon = True\\n # start the thread, going into the worker function\\n p.start()\\n\\n elif job_name in self.fk_func_map:\\n t = self.fk_func_map[job_name]\\n if not os.fork():\\n os.setsid()\\n t(job)\\n exit()\\n else:\\n # jobs in this queue that are unknown are presently being skipped\\n # however they could probably get moved to a 'dead letter' queue\\n # for closer examination\\n print(\\\"unknown job name %s, skipping\\\" % (job_name))\\n\\n # throttle so that other worker subscribers get a chance\\n time.sleep(self.queue_delay)\\n else:\\n time.sleep(self.poll_delay)\\n\\n # prints the number of threads\\n # print len(threading.enumerate())\",\n \"def run_once(self):\\r\\n with self._run_lock:\\r\\n self.run(self._process_queue,True) # True: override flag for saving\\r\",\n \"def _maybe_schedule_task(self):\\n if self._tasks.acquire(blocking=False):\\n # Atomically remove the item from the queue and feed it to\\n # the ThreadPoolExecutor.\\n self._queue_lock.acquire()\\n try:\\n outer_future = self._next()\\n except StopIteration:\\n # Oops, there is in fact no task to be served, so we\\n # won't be tying up a worker after all.\\n self._tasks.release()\\n else:\\n callable_, args, kwargs = outer_future.args\\n inner_future = self._submit_one(callable_, *args, **kwargs)\\n # Now that we have the real future (inner_future), chain\\n # its result to what we provided to our client\\n inner_future.add_done_callback(_chain_result(outer_future))\\n finally:\\n self._queue_lock.release()\",\n \"def queue_task(self, job, task_index, current_time):\\r\\n self.queued_tasks += 1\\r\\n self.queues[job.user_id].append((job, task_index))\\r\\n self.stats_manager.task_queued(job.user_id, current_time)\\r\\n if self.running_tasks < self.num_cores:\\r\\n # Not all cores are in use, so launch this task.\\r\\n return [self.__launch_task(current_time)]\",\n \"def _enqueue_task(self):\\n\\t\\t# TODO(bslatkin): Remove these retries when they're not needed in userland.\\n\\t\\tRETRIES = 3\\n\\t\\ttarget_queue = os.environ.get('X_APPENGINE_QUEUENAME', constants.FEED_QUEUE)\\n\\t\\tfor i in xrange(RETRIES):\\n\\t\\t\\ttry:\\n\\t\\t\\t\\ttaskqueue.Task(\\n\\t\\t\\t\\t\\t\\turl='/work/pull_feeds',\\n\\t\\t\\t\\t\\t\\teta=self.eta,\\n\\t\\t\\t\\t\\t\\tparams={'topic': self.topic}\\n\\t\\t\\t\\t\\t\\t).add(target_queue)\\n\\t\\t\\texcept (taskqueue.Error, apiproxy_errors.Error):\\n\\t\\t\\t\\tlogging.exception('Could not insert task to fetch topic = %s',\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tself.topic)\\n\\t\\t\\t\\tif i == (RETRIES - 1):\\n\\t\\t\\t\\t\\traise\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn\",\n \"def _dispatch_new(self):\\n\\n # This steps ensure that auto-baching works as expected.\\n this_batch_duration = time.time() - self.dispatch_timestamp\\n self.parallel._backend.batch_completed(self.batch_size,\\n this_batch_duration)\\n\\n # Schedule the next batch of tasks.\\n with self.parallel._lock:\\n self.parallel.n_completed_tasks += self.batch_size\\n self.parallel.print_progress()\\n if self.parallel._original_iterator is not None:\\n self.parallel.dispatch_next()\",\n \"def run(self):\\n while True:\\n next_task = self.task_queue.get()\\n if next_task is None:\\n # Poison pill means shutdown\\n self.task_queue.task_done()\\n break\\n answer = next_task(self.data)\\n self.task_queue.task_done()\\n self.result_queue.put(answer)\",\n \"def take_task(self, task):\\n self._tasks_in_process.append(task)\",\n \"def run(self):\\n assert self.queue is not None, \\\"Must specify queue or override run()\\\"\\n\\n while not self.terminated():\\n qs = self.queue.objects.filter(status=self.queue.UNSUBMITTED,).order_by(\\n \\\"-seq\\\"\\n )[: django.conf.settings.DAEMONS_MAX_BATCH_SIZE]\\n if not qs:\\n self.sleep(django.conf.settings.DAEMONS_IDLE_SLEEP)\\n continue\\n\\n for task_model in qs:\\n try:\\n self.do_task(task_model)\\n task_model.status = self.queue.SUCCESS\\n except AsyncProcessingIgnored:\\n task_model.status = self.queue.IGNORED\\n except Exception as e:\\n if isinstance(e, AsyncProcessingRemoteError):\\n # This is a bit messy. Do not log a trace when the\\n # error is due to the remote service rejecting the request.\\n # Such an error is still permanent for the task though.\\n self.log.error(e)\\n else:\\n self.log.error('#' * 100)\\n self.log.exception(f'Exception when handling task \\\"{task_model}\\\"')\\n\\n task_model.error = str(e)\\n # if self.is_permanent_error(e):\\n task_model.status = self.queue.FAILURE\\n task_model.errorIsPermanent = True\\n # raise\\n else:\\n task_model.submitTime = self.now_int()\\n\\n task_model.save()\\n\\n self.sleep(django.conf.settings.DAEMONS_BATCH_SLEEP)\\n self.log.info(\\\"Exiting run loop.\\\")\",\n \"def ProcessEvents(self):\\n self.work_queue.put(self.__ProcessEventsAsync)\",\n \"def _EventQueueWorker(self):\\n while not self.stop:\\n gevent.sleep(0)\\n\\n try:\\n with Timer('task_process_time', False) as t:\\n # Pull the next task off the queue.\\n task, enqueue_times = model_provider.GetQueues().GetTask()\\n\\n # Retrieve the Tab Types for the NIDs so we know what handler to use.\\n nid_to_type = model_provider.GetNames().GetTypes(task.keys())\\n\\n # Add the queued state parts to the main states.\\n greenlets = [\\n gevent.spawn(\\n model_provider.GetStates().ReduceInto,\\n nid, cid_to_sstate, nid_to_type[nid])\\n for nid, cid_to_sstate in task.iteritems()]\\n\\n gevent.joinall(greenlets)\\n\\n LOG.info('Processed tasks %3dN %5dC %7.3fs' % (\\n len(task), len(enqueue_times), t.Elapsed))\\n\\n model_provider.GetLatency().RecordForProcessed(enqueue_times)\\n\\n except Exception:\\n LOG.error('Exception in Queue Worker loop')\\n LOG.error(traceback.format_exc())\\n gevent.sleep(1)\",\n \"def queueOn() -> None:\\n\\t\\tLogging.enableQueue = Logging.queueSize > 0\",\n \"def _run_tasks(self):\\n next_tasks = self._job_queue.get_next_tasks()\\n for task in next_tasks:\\n sid = self._docker.start_task(task.identifier, task.image, task.name, task.args)\\n self._job_queue.mark_task_started(task.identifier, task.name, sid)\",\n \"def startingNewStep(self):\\n with self.__queueLock:\\n self.__submittedJobs = []\",\n \"def queue (self):\\n\\n with self.__t.steps():\\n import exception\\n from lib import schema\\n from lib import common\\n from lib import process\\n from lib import data\\n from sqlalchemy import and_\\n import json\\n from collections import OrderedDict\\n\\n with schema.select(\\\"process_queue\\\", schema.table.process_queue.status==None) as select:\\n for queued in select.limit(1000).all():\\n blocked = False\\n if len(queued.depend) > 0:\\n for depend_id in queued.depend:\\n depend = schema.select_one(\\\"series\\\", schema.table.series.id==depend_id)\\n match_tags = json.dumps(OrderedDict(sorted(data.decode_tags(depend.tags).items())))\\n if depend and schema.select_one(\\\"process_queue\\\", schema.table.process_queue.tags==match_tags):\\n blocked = True\\n break # queued dependencies\\n if not blocked:\\n queued.status = \\\"queued\\\"\\n schema.save(queued)\\n run.apply_async([queued.tags]) #queue process\\n self.__t.ok()\\n self.apply_async(queue=\\\"control\\\", countdown=30) #queue next\",\n \"def run(self):\\n while True:\\n next_task = self.task_queue.get()\\n if next_task is None:\\n # Poison pill means shutdown\\n self.task_queue.task_done()\\n break\\n # Fetch answer from task\\n answer = next_task()\\n self.task_queue.task_done()\\n # Put into result queue\\n self.result_queue.put(answer)\\n return\",\n \"def sworker (q):\\n\\t\\t\\twhile True:\\n\\t\\t\\t\\t(run, i) = q.get()\\n\\t\\t\\t\\tsleep (i)\\n\\t\\t\\t\\tif run.isRunning():\\n\\t\\t\\t\\t\\tself.log (\\\"Job #%s is already running, skip submitting.\\\" % run.job.index, 'info')\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\trun.submit()\\n\\t\\t\\t\\trun.wait() \\n\\t\\t\\t\\trun.finish()\\n\\t\\t\\t\\tq.task_done()\",\n \"def on_tick(self):\\n if ((len(self._queue) >= self.config.batchsize) or\\n (time.time() - self._last_get > self.config.batchtime and self._queue)):\\n self._get()\",\n \"def process(self, task):\\n # Predict timestamp for the first run\\n _, date = task.trigger(wait=False, **task.trigger_args)\\n\\n # Adding the task in schedule queue\\n self.task_manager.schedule_task(task, date)\",\n \"def process_queue_slowly(self):\\n start = time.process_time()\\n while self.queue and time.process_time() - start < 1.0 / TICKS_PER_SECOND:\\n self.queue.popleft()()\",\n \"def runQueueEnqueue(self):\\n raise NotImplementedError\",\n \"def run(self):\\n proc_name = self.name\\n while True:\\n next_task = self.task_queue.get()\\n if next_task is None:\\n debug('{}: Exiting'.format(proc_name))\\n self.task_queue.task_done()\\n break\\n debug('{}: {}'.format(proc_name, next_task))\\n answer = next_task()\\n self.task_queue.task_done()\\n self.result_queue.put(answer)\\n return\",\n \"def _wait_queue(self):\\n while True:\\n time.sleep(0.1)\\n if self.queue.unfinished_tasks == 0 or self.stop_signal.is_set():\\n return\",\n \"def _run_task(self, task: Task):\\n\\n self._current = task\\n try:\\n\\n task.coroutine.send(None)\\n self._debug(\\\" current\\\", self._current)\\n # Sleep gate here, in case the current task suspended.\\n # If a sleeping task re-suspends it will have already put itself in the sleeping queue.\\n if self._current is not None:\\n self._tasks.append(task)\\n except StopIteration:\\n # This task is all done.\\n self._debug(\\\" task complete\\\")\\n pass\\n finally:\\n self._current = None\",\n \"def __launch_task(self, current_time):\\r\\n assert self.queued_tasks > 0\\r\\n assert self.running_tasks < self.num_cores\\r\\n\\r\\n self.queued_tasks -= 1\\r\\n if not len(get_param(\\\"relative_weights\\\")) > self.current_user:\\r\\n print get_param(\\\"relative_weights\\\"), self.current_user\\r\\n assert False\\r\\n tasks_per_round = get_param(\\\"relative_weights\\\")[self.current_user]\\r\\n if self.task_count >= tasks_per_round:\\r\\n # Move on to the next user.\\r\\n self.task_count = 0\\r\\n self.current_user = (self.current_user + 1) % self.num_users\\r\\n\\r\\n while len(self.queues[self.current_user]) == 0:\\r\\n self.current_user = (self.current_user + 1) % self.num_users\\r\\n self.task_count = 0\\r\\n # Get the first task from the queue\\r\\n job, task_id = self.queues[self.current_user][0]\\r\\n # Remove the task from the user's queue.\\r\\n self.queues[self.current_user] = self.queues[self.current_user][1:]\\r\\n self.task_count += 1\\r\\n assert job.user_id == self.current_user\\r\\n task_length = job.get_task_length(task_id)\\r\\n event = (current_time + task_length, TaskCompletion(job, self))\\r\\n self.stats_manager.task_started(self.current_user, current_time)\\r\\n self.time_started = current_time\\r\\n if get_param(\\\"record_task_info\\\"):\\r\\n job.record_wait_time(task_id, current_time)\\r\\n self.running_tasks += 1\\r\\n return event\",\n \"def enqueue_task(signature):\\n try:\\n if signature not in g._celery_tasks:\\n g._celery_tasks.append(signature)\\n except RuntimeError:\\n signature()\",\n \"def run(self):\\n self.log.info(\\n \\\"%s - started. Task count: %s\\\", self.id, self._task_queue.qsize()\\n )\\n\\n self._run()\",\n \"def run(self):\\n _threadpool_limits = _no_threadpool_limits\\n if USE_THREADPOOL_LIMITS:\\n _threadpool_limits = threadpool_limits\\n\\n while True:\\n next_task = self.task_queue.get()\\n if next_task is None:\\n # Poison pill means shutdown\\n self.task_queue.task_done()\\n break\\n with _threadpool_limits(limits=1):\\n answer = next_task(self.data)\\n self.task_queue.task_done()\\n self.result_queue.put(answer)\",\n \"def task_done(self, done, **kwargs):\\n\\n # If unknown task, kill execution\\n if done not in self.doing:\\n return\\n\\n # Set the task as completed\\n self.done.append(self.doing.pop(self.doing.index(done)))\\n\\n # Call original method\\n super(Queue, self).task_done(**kwargs)\\n\\n # Stop\\n return\",\n \"def run():\\n curr = getcurrent()\\n _run_calls.append(curr)\\n _scheduler_remove(curr)\\n try:\\n schedule()\\n assert not _squeue\\n finally:\\n _scheduler_append(curr)\",\n \"def submit(self):\\n for async_femag in self.async_femags:\\n async_femag.start()\\n\\n for task in self.job.tasks:\\n self.queue.put(task)\\n\\n return len(self.job.tasks)\",\n \"def do_tasks(self):\\n\\t\\twork_ = self.TASK_LIMIT\\n\\t\\twhile True:\\n\\t\\t\\tif len(self.tasks) == 0 or work_ <= 0:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\tself.tasks[0].work(self)\\n\\t\\t\\tif self.tasks[0].completed:\\n\\t\\t\\t\\tself.tasks.pop(0)\\n\\n\\t\\t\\twork_ -= 1\",\n \"def _add(self, task: Task) -> None:\\n with self._cond:\\n if task not in self._task_set:\\n self._task_set.add(task)\\n self._tasks.append(task)\\n self._cond.notify()\",\n \"def _auto_spark(self):\\n self.auto_queue.clean_up(emphasis=self.emphasis[\\\"redundant\\\"])\\n if not self.auto_queue.is_busy and not self.clear_queue.is_busy:\\n self.auto_queue.is_busy = True\\n self.process(self.auto_queue)\\n\\n self.hyper_queue.clean_up(emphasis=self.emphasis[\\\"redundant\\\"])\\n if not self.hyper_queue.is_busy and not self.clear_queue.is_busy:\\n self.hyper_queue.is_busy = True\\n self.process(self.hyper_queue)\",\n \"def run(self) -> None:\\n while self.data_incoming or len(self._queue):\\n if not self._queue:\\n logging.info(\\\"Consumer %d is sleeping since queue is empty\\\", self._name)\\n time.sleep(0.75)\\n print(self._queue.get())\\n time.sleep(0.5)\",\n \"def _process_run(queue: Queue, func: Callable[[Any], Any] = None,\\n *args, **kwargs):\\n queue.put(func(*args, **kwargs))\",\n \"def worker_function(taskQ, resultQ):\\n \\n while True:\\n try: ivel = taskQ.get(block=True, timeout=10)# try to get the next task, allow some time for process clash (ivel number)\\n except queue.Empty: break# kill process if no more tasks left\\n example = generate_example(ivel)\\n resultQ.put(example)# push the example to the results queue\",\n \"def process_queue(self):\\n if not self.has_queue:\\n log.debug('Thumbnail queue empty.')\\n return\\n\\n queue = []\\n with LockFile(self._queue_path):\\n with open(self._queue_path) as fp:\\n for line in fp:\\n line = line.strip()\\n if not line:\\n continue\\n if not os.path.exists(line):\\n log.debug('File does not exist : %r', line)\\n continue\\n queue.append(line)\\n # Clear queue file\\n with atomic_writer(self._queue_path, 'wb') as fp:\\n fp.write('')\\n\\n succeeded = True\\n for i, img_path in enumerate(queue):\\n log.debug('Generating thumbnail {}/{} ...', i + 1, len(queue))\\n if not self.generate_thumbnail(img_path):\\n succeeded = False\\n\\n return succeeded\",\n \"def run(self) -> None:\\n\\n while True:\\n try:\\n input_element = self.input_queue.get_nowait()\\n self.process(input_element)\\n except Empty:\\n return\",\n \"def run(self):\\n while True:\\n job_id, job_service, = self.input_queue.get()\\n if job_id is None:\\n break\\n # Process the job\\n with self.app.app_context():\\n self.process(job_id, job_service)\\n self.input_queue.task_done()\\n time.sleep(1)\\n # Done\\n self.input_queue.task_done()\\n return\",\n \"def start_processing(self, task, task_name, ignore_SIGINT=False) -> None:\\n self.poll_process_done()\\n print(definitions.PRINT_CODES[0] + blue(\\\"Processes in queue before add: \\\"), blue(len(self.process_queue)))\\n\\n def preexec_function():\\n signal.signal(signal.SIGINT, signal.SIG_IGN)\\n\\n if ignore_SIGINT:\\n sp = subprocess.Popen(task, preexec_fn=preexec_function)\\n else:\\n sp = subprocess.Popen(task)\\n\\n self.process_queue.append((task_name, sp))\\n\\n print(definitions.PRINT_CODES[0] + blue(\\\"Processes in queue after add: \\\"), blue(len(self.process_queue)))\",\n \"def process_queue_fast(self):\\n while self.queue:\\n self.queue.popleft()()\",\n \"def run(self):\\n time_start = datetime.datetime.now()\\n # while there are tasks in queue or tasks running\\n while self.tasks_to_run or self.tasks_running:\\n print(f\\\"\\\\nScheduler ticks... \\\\nElapsed time {(datetime.datetime.now() - time_start).seconds} \\\\n\\\"\\n f\\\"TTR: {list(self.tasks_to_run.keys())} \\\\n\\\"\\n f\\\"TRU: {list(self.tasks_running.keys())} \\\\n\\\"\\n f\\\"TCO: {list(self.tasks_complete.keys())} \\\\n\\\"\\n f\\\"\\\\nMeanwhile:\\\"\\n )\\n # each tick I launch 1 task from queue\\n if self.tasks_to_run:\\n i = list(self.tasks_to_run.keys())[0]\\n self.task_launcher(i, self.tasks_to_run.pop(i))\\n # tick - tock\\n time.sleep(1)\\n\\n # and finishing remarks...\\n print(\\n f\\\"Process finished in {(datetime.datetime.now() - time_start).seconds} seconds\\\\n\\\"\\n f\\\"TTR: {list(self.tasks_to_run.keys())} \\\\n\\\"\\n f\\\"TRU: {list(self.tasks_running.keys())} \\\\n\\\"\\n f\\\"TCO: {list(self.tasks_complete.keys())} \\\\n\\\"\\n )\",\n \"def queue_consumer(self, q):\\n\\n self.status = 'Running...'\\n\\n while True:\\n try:\\n msg = q.get_nowait()\\n if msg is None:\\n break\\n self.update_plot(msg)\\n except Queue.Empty:\\n time.sleep(0.1)\\n\\n self.status = 'Done'\",\n \"def _add_task_action(self, task):\\n if not task.is_alive():\\n return\",\n \"def queue_processor(self):\\n\\n while self.state != consts.SMPP_CLIENT_STATE_CLOSED:\\n try:\\n p = self.queue.get(timeout=1)\\n self._request_handler(p)\\n self.queue.task_done()\\n except Empty:\\n pass\",\n \"def task_done(self):\\n self._queue.task_done()\",\n \"def add_event_queue(self, proc):\\r\\n self.event_queue.append(proc)\\r\\n if not self.running:\\r\\n self.mw.after(self.run_check_ms, self.running_loop) # Start running loop\\r\",\n \"def _check_queue(self):\\n self._process_incoming_queue_messages()\\n self._root.after(200, self._check_queue)\",\n \"def put(self, task):\\n self.queue.put(task, task.priority)\",\n \"def process_queue_item(self, job_details):\\n raise NotImplementedError(\\\"Workers must implement run.\\\")\",\n \"def _process_queue(self, spider):\\n site = self.sites.get(spider)\\n if not site:\\n return\\n\\n # Delay queue processing if a download_delay is configured\\n now = time()\\n delay = site.download_delay()\\n if delay:\\n penalty = delay - now + site.lastseen\\n if penalty > 0:\\n d = defer.Deferred()\\n d.addCallback(self._process_queue)\\n call = reactor.callLater(penalty, d.callback, spider)\\n site.next_request_calls.add(call)\\n d.addBoth(lambda x: site.next_request_calls.remove(call))\\n return\\n site.lastseen = now\\n\\n # Process enqueued requests if there are free slots to transfer for this site\\n while site.queue and site.free_transfer_slots() > 0:\\n request, deferred = site.queue.pop(0)\\n if site.closing:\\n dfd = defer.fail(Failure(IgnoreRequest()))\\n else:\\n dfd = self._download(site, request, spider)\\n dfd.chainDeferred(deferred)\\n\\n self._close_if_idle(spider)\",\n \"def task(self, value):\\n \\n if value['job_type'] == \\\"UPDATE\\\" or value['job_type'] == \\\"MAINTAIN\\\":\\n self._queue.put(value)\\n\\n if 'focused_task' in value:\\n if value['focused_task'] == 1:\\n logging.info(\\\"Focused task is ON\\\\n\\\")\\n self.finishing_task = True\\n else:\\n self.finishing_task = False\\n logging.info(\\\"Focused task is OFF\\\\n\\\")\\n else:\\n self.finishing_task = False\\n logging.info(\\\"focused task is OFF\\\\n\\\")\\n \\n self._task = value\\n self.run()\",\n \"def process_tasks(task_queue):\\n logger = multiprocessing.get_logger()\\n proc = os.getpid()\\n while not task_queue.empty():\\n try:\\n food = task_queue.get()\\n get_word_counts(food)\\n except Exception as e:\\n logger.error(e)\\n logger.info(f'Process {proc} completed successfully')\\n return True\",\n \"def add_task(self, func, *args, **kwargs):\\n self.queue.put((func, args, kwargs))\",\n \"def queue_tasks(self, layer, tasks) -> int:\\n pass\",\n \"def process_todo_q(self):\\n self.logger.debug(\\\"==> %s files to process\\\" % len(self.todo_queue))\\n\\n while len(self.todo_queue) > 0:\\n if len(self.active_queue) == 0:\\n # add job to [active] queue...\\n self.active_queue.append(self.todo_queue.pop(0))\\n job_id = self.active_queue[0][\\\"id\\\"]\\n # ...log his 'id'...\\n self.logger.info(\\\"[active/%s] processing file '%s'\\\"\\n % (job_id,\\n self.active_queue[0][\\\"objects_filename\\\"]))\\n # ...and process it\\n has_config, cfg_file = self._check_object_config()\\n if has_config:\\n self.logger.debug(\\\"[active/%s] config file '%s' is present\\\"\\n % (job_id,\\n cfg_file))\\n self._set_target_symlinks()\\n self._run_operations()\\n else:\\n self.logger.error(\\\"[active/%s] config file '%s' is absent\\\"\\n % (job_id,\\n cfg_file))\\n self._send_alert(\\\"the configuration file is absent '%s'\\\" %\\n cfg_file)\\n\\n # remove the job from the [active] queue\\n self.active_queue = []\\n else:\\n raise ProfileProcessingError(\\\"only one job is permitted \\\\\\n in [active] queue\\\")\\n\\n self.logger.info(\\\"all files has been processed\\\")\",\n \"def check_process_done(self):\\n for task_name, sp in self.process_queue:\\n if sp.poll() is not None:\\n self.process_queue.remove((task_name, sp))\\n print(definitions.PRINT_CODES[0] + blue(\\\"Query done: \\\"), blue(task_name))\\n if self.handler is not None:\\n self.handler(task_name, sp.returncode)\",\n \"def run(self):\\n while True:\\n # Check to see if we should stop\\n if self._stop.isSet():\\n logger.debug(\\\"Worker thread stopping.\\\")\\n break\\n\\n # Try to pull from the queue\\n try:\\n func, args, kwargs = self.queue.get_nowait()\\n func(*args, **kwargs)\\n except Queue.Empty:\\n time.sleep(5)\\n continue\\n except Exception as e:\\n logger.exception(e)\",\n \"def curr_queue(self):\\n pass\",\n \"def queue_task(self, task_name):\\n task_response = self.do_task(\\n self.types[task_name],\\n self.data_dict[task_name]['taskId']\\n )\\n self.data_dict[task_name]['job_id'] = json.loads(\\n task_response.content\\n )['JobId']\\n logger.info(\\n 'Queued {name} task response: '.format(name=task_name) +\\n task_response.content\\n )\",\n \"def process_queue(self, queue):\\n\\n while queue:\\n deferred, data = queue.popleft()\\n deferred.callback(data)\",\n \"def add(self, task, qhigh, qlow):\\n try:\\n qlen = self.tasks.qsize()\\n if qlen > qhigh:\\n print \\\"Throttling input, reached HWM:\\\", qhigh\\n while qlen > qlow:\\n delay = random.randint(1,10)\\n time.sleep(delay)\\n qlen = self.tasks.qsize()\\n print \\\"Throttling released, down to LWM:\\\", qlow\\n except NotImplementedError:\\n # Skip on Mac OS X (WARNING - use on OS X in testing only, queue \\n # size will max out at a paltry 32768 items)\\n pass\\n try:\\n self.tasks.put(task)\\n self.recordsProcessed += task.datalen\\n except qFull:\\n # While testing: we shouldn't hopefully end up here...\\n print \\\"ERR: queue full\\\"\\n sys.exit(-1)\",\n \"def tasks(self):\\n\\n while len(self.pending_tasks) > 0:\\n while True:\\n task = self.queue.pop()\\n if not task:\\n yield None\\n break\\n\\n elif self._can_start_task(task):\\n yield task\\n break\\n\\n else:\\n self.hold.append(task)\",\n \"def performTask(self):\\n task = self.task.peek()\\n position = self.rover.getPosition()\\n if str(self.map[position.y,position.x]) == task.getName() + 'broken':\\n for part in task.getSupplies():\\n if not self.inventory.isPartinList(part.getData(),part.getCount()):\\n return\\n for part in task.getSupplies():\\n self.inventory.removePart(part.getData(),part.getCount())\\n self.task.dequeue()\\n self.map[position.y,position.x].setType(task.getName())\",\n \"def done(self):\\n self.__queue.task_done()\",\n \"def put(self, task):\\n self.put_idx += 1\\n self.task_queue.put(task)\",\n \"def run_one_queued_pass(self, classification):\\n if self.has_queued_passes(classification):\\n self.pop_queued_pass(classification)\",\n \"def process_thread(self):\",\n \"def run(self):\\n\\n logging.info(\\\"Pool scheduler started\\\")\\n\\n # do forever\\n while True:\\n\\n try :\\n # get job information about new jobs\\n JobStatus.addNewJobs()\\n\\n # apply policy\\n groups = self.applyPolicy()\\n\\n # any job to check?\\n if len(groups) == 0:\\n\\n # no, wait for jobs to arrive\\n logging.info( \\\"No work to do, \\\" + \\\\\\n \\\"scheduler goes to sleep for \\\" + \\\\\\n str(self.delay) + \\\" seconds\\\")\\n sleep(self.delay)\\n continue\\n\\n # new threads to start?\\n if len(groups) >= self.threadsWorking:\\n\\n # yes, start threads\\n for grp in groups:\\n\\n # but only for new groups\\n if grp not in self.groupsUnderProcessing:\\n\\n # insert group ID into queue\\n # to trigger thread start\\n self.groupsUnderProcessing.add(grp)\\n self.pool.enqueue(grp, grp)\\n\\n # wait for a thread to finish\\n (group, result) = self.pool.dequeue()\\n logging.info(\\\"Thread processing group \\\" + str(group) + \\\\\\n \\\" has finished\\\")\\n\\n # decrement threads counter\\n self.threadsWorking = self.threadsWorking - 1\\n\\n # remove its ID from groups\\n self.groupsUnderProcessing.remove(group)\\n\\n # remove all finished jobs from this group\\n JobStatus.removeFinishedJobs(group)\\n\\n except Exception, ex :\\n import traceback\\n logging.error( 'Error in PoolScheduler : [%s]' % str(ex) )\\n logging.error( \\\"Traceback: %s\\\" % traceback.format_exc() )\\n logging.error( \\\"PoolScheduler goes to sleep for \\\" + \\\\\\n str(self.delay) + \\\" seconds\\\" )\\n sleep(self.delay)\",\n \"def run(self):\\n while True:\\n task = self.queue.get()\\n if task is None:\\n break\\n fslfile = os.path.join(task.directory, task.fsl_file)\\n # TODO: there must be a better way to set the workdir\\n workdir = '/'.join(task.directory.split('/')[-3:])\\n logger.info('Docker task %s %s workdir %s',\\n task.id, task.fsl_file, workdir)\\n fslcmds = ['save_model(close)',\\n \\\"chdir('{}')\\\".format(workdir)]\\n \\n with open(fslfile) as f:\\n fslcmds += f.readlines()\\n r = [json.loads(s)\\n for s in self.container.send_fsl(\\n '\\\\n'.join(fslcmds), publish_receive)[:2]]\\n try:\\n if r[0]['status'] == 'ok':\\n task.status = 'C'\\n else:\\n task.status = 'X'\\n except:\\n task.status = 'X'\\n logger.info(\\\"Finished %s\\\", r)\\n if self.stoponend:\\n self.container.quit()\\n # lets hope that docker will always restart this container\\n self.queue.task_done()\",\n \"def put_task(self, task):\\n # Check if current task is valid\\n if not task.connect(self): # Check if task can be used\\n return # Drop current task\\n self.queue.put(task) # Add current task in schedule queue\",\n \"def loop_once(self):\\n while 1:\\n if not self._active_nodes:\\n # If everything has died stop looping\\n self.triggershutdown()\\n raise RuntimeError(\\\"Unexpectedly no active workers available\\\")\\n try:\\n eventcall = self.queue.get(timeout=2.0)\\n break\\n except Empty:\\n continue\\n callname, kwargs = eventcall\\n assert callname, kwargs\\n method = \\\"worker_\\\" + callname\\n call = getattr(self, method)\\n self.log(\\\"calling method\\\", method, kwargs)\\n call(**kwargs)\\n if self.sched.tests_finished:\\n self.triggershutdown()\",\n \"def iterate(self):\\n self._prepare_workers()\\n self.prepare()\\n\\n self.job_queue = self.get_job_queue()\\n self.job_done = self.get_job_done()\\n\\n self.worker_informations[\\\"started\\\"] = True\\n self.write_worker_informations()\\n # Ici : enregistrer son worker\\n\\n GARGAGE_COUNT = 0\\n while True:\\n\\n #############################################\\n ### Try to retrieve a job_id in the queue ###\\n #############################################\\n _start_time_queue = time.time()\\n must_stop = False\\n\\n do_print = True\\n while True:\\n\\n try:\\n job_id = self.job_queue.remove()\\n except Exception as e:\\n logger.fatal(e, exc_info=True)\\n raise e\\n\\n # Ici : on peut peut etre verifier si on a pas deja fait le job\\n # ce qui peut arriver, si on a mal synchroniser en entree ? => Ex : on a relancer le controller avec ces models par default ?\\n # ou si on a retirer 2 fois un model random,\\n\\n if job_id is not None:\\n # I have found something in the queue\\n break\\n\\n must_stop, reason = self.must_stop()\\n if must_stop:\\n break\\n\\n current_time = time.time()\\n if (\\n self.max_queue_waiting_time is not None\\n and current_time - _start_time_queue >= self.max_queue_waiting_time\\n ):\\n logger.info(\\\"queue was empty...\\\")\\n logger.info(\\\"stop waiting for queue\\\")\\n break\\n else:\\n if do_print:\\n logger.info(\\\"queue was empty...\\\")\\n logger.info(\\\"wait for queue for %d sec(s)\\\" % self.input_queue_sleeping_time)\\n do_print = False # to print only time\\n time.sleep(self.input_queue_sleeping_time)\\n\\n ###########################################\\n # max_queue_waiting_time : #\\n # * None <=> inf => wait forever #\\n # * -1 => don't wait at all #\\n # * x => wait x seconds #\\n ###########################################\\n\\n if job_id is None:\\n self.worker_informations[\\\"stopped\\\"] = True\\n self.worker_informations[\\\"stopping_reason\\\"] = \\\"empty queue\\\"\\n self.write_worker_informations()\\n\\n break\\n\\n if must_stop:\\n self.worker_informations[\\\"stopped\\\"] = True\\n self.worker_informations[\\\"stopping_reason\\\"] = reason\\n self.write_worker_informations()\\n logger.info(\\\"I must stop because %s\\\" % reason)\\n break\\n\\n ###########################################\\n ### Retrieve the parameters of that job ###\\n ###########################################\\n job_param = self.data_persister.read(key=job_id, path=\\\"job_param\\\", write_type=SavingType.json)\\n\\n logger.info(\\\"start job_id : %s\\\" % job_id)\\n logger.info(\\\"\\\")\\n\\n try:\\n _success = False\\n start_time = time.time()\\n\\n #################################\\n ### Send job_id and job_param ###\\n #################################\\n yield job_id, job_param\\n\\n return_time = time.time()\\n _success = True\\n \\n except Exception as e:\\n logger.fatal(e, exc_info=True)\\n raise e\\n\\n finally:\\n\\n if not _success:\\n ####################################\\n ### It means there were an error ###\\n ####################################\\n self.worker_informations[\\\"stopped\\\"] = True\\n self.worker_informations[\\\"stopping_reason\\\"] = \\\"error\\\"\\n self.write_worker_informations()\\n\\n ########################\\n ### Save time of job ###\\n ########################\\n self._all_times.append(return_time - start_time)\\n\\n ##################################\\n ### Do a garbage collector run ###\\n ##################################\\n GARGAGE_COUNT += 1\\n if GARGAGE_COUNT >= self.gc_collect_freq:\\n GARGAGE_COUNT = 0\\n gc.collect()\\n\\n ###############################\\n ### Add job to 'done queue' ###\\n ###############################\\n could_add = False\\n _start_time_done_queue = time.time()\\n\\n do_print = True\\n while True:\\n could_add = self.job_done.add(data=job_id)\\n\\n if could_add:\\n break\\n\\n must_stop, reason = self.must_stop()\\n if must_stop:\\n break\\n\\n current_time = time.time()\\n if (\\n self.max_done_queue_waiting_time is not None\\n and current_time - _start_time_done_queue >= self.max_done_queue_waiting_time\\n ):\\n logger.info(\\\"done queue was full...\\\")\\n logger.info(\\\"stop waiting for done queue\\\")\\n break\\n else:\\n if do_print:\\n logger.info(\\\"done queue was full...\\\")\\n logger.info(\\\"wait for done queue for %d sec(s)\\\" % self.done_queue_sleeping_time)\\n\\n do_print = False # to print only once\\n time.sleep(self.done_queue_sleeping_time)\\n\\n #############################################\\n # max_done_queue_waiting_time : #\\n # * None <=> inf : wait for ever #\\n # * -1 : don't wait at all #\\n # * x : wait for x seconds #\\n #############################################\\n\\n # Ici : regarder si on a un flag 'stop'\\n\\n if not must_stop:\\n must_stop, reason = self.must_stop()\\n\\n if must_stop:\\n self.worker_informations[\\\"stopped\\\"] = True\\n self.worker_informations[\\\"stopping_reason\\\"] = reason\\n self.write_worker_informations()\\n logger.info(\\\"I must stop because %s\\\" % reason)\\n break\",\n \"def worker(self, queue):\\n with sa.create_engine(dsn).connect() as dbcon:\\n while True:\\n if queue.qsize() == 0:\\n sleep(1)\\n if queue.qsize() == 0:\\n break\\n continue\\n item = queue.get()\\n try:\\n if hash(item['title']) in self.exist_products:\\n dbcon.execute(Product.update().values(**item).where(Product.c.id == self.get_id(item)))\\n else:\\n result = dbcon.execute(Product.insert().values(**item))\\n self.exist_products[hash(item['title'])] = result.inserted_primary_key[0]\\n except Exception as e:\\n print(type(e), e)\",\n \"def run(self):\\n while True:\\n self._event.clear()\\n self._queue.get().run(self._event)\",\n \"def run(self):\\n init()\\n list_name = comet_config.REDIS_NAMESPACE + \\\"incoming/\\\" + self.service_name\\n list_name_processing = list_name + \\\"/processing\\\"\\n self.redis = r\\n while True:\\n try:\\n item = self.redis.brpoplpush(list_name, list_name_processing)\\n self.process_incoming(item)\\n self.redis.lrem(list_name_processing, item)\\n\\n except redis.ConnectionError:\\n pass\",\n \"def _dispatch(self, batch):\\n # If job.get() catches an exception, it closes the queue:\\n if self._aborting:\\n return\\n\\n batch_size = len(batch)\\n\\n self.n_dispatched_tasks += batch_size\\n self.n_dispatched_batches += 1\\n\\n dispatch_timestamp = time.time()\\n\\n batch_tracker = BatchCompletionCallBack(\\n dispatch_timestamp, batch_size, self\\n )\\n self._jobs.append(batch_tracker)\\n\\n job = self._backend.apply_async(batch, callback=batch_tracker)\\n batch_tracker.register_job(job)\",\n \"def work(self):\\r\\n worker = self.worker_place_item()\\r\\n if not worker:\\r\\n worker = self.worker_take_item()\\r\\n\\r\\n if not worker:\\r\\n for worker in self.workers:\\r\\n worker.work()\\r\\n else:\\r\\n worker = [w for w in self.workers if w is not worker][0]\\r\\n worker.work()\",\n \"def collect(self):\\n while True:\\n if not self._queue.empty():\\n message = self._queue.get()\\n self.working_on = message['job_type']\\n else:\\n break\\n logging.info(\\\"Popped off message: {}\\\\n\\\".format(str(message)))\\n\\n if message['job_type'] == 'STOP':\\n break\\n\\n if message['job_type'] != 'MAINTAIN' and message['job_type'] != 'UPDATE':\\n raise ValueError('{} is not a recognized task type'.format(message['job_type']))\\n pass\\n\\n \\\"\\\"\\\" Query all repos with repo url of given task \\\"\\\"\\\"\\n repoUrlSQL = s.sql.text(\\\"\\\"\\\"\\n SELECT min(repo_id) as repo_id FROM repo WHERE repo_git = '{}'\\n \\\"\\\"\\\".format(message['given']['git_url']))\\n repo_id = int(pd.read_sql(repoUrlSQL, self.db, params={}).iloc[0]['repo_id'])\\n\\n try:\\n if message['models'][0] == 'badges':\\n self.badges_model(message, repo_id)\\n except Exception as e:\\n register_task_failure(self, logging, message, repo_id, e)\\n pass\",\n \"def _submit_to_queue(self, script_file):\",\n \"def _wait_empty(self):\\n while True:\\n if self.queue.empty():\\n # We still have to wait for the last queue item being processed\\n # (queue.empty() returns True before queue.task_done() is\\n # called).\\n self.queue.join()\\n return\\n time.sleep(1)\",\n \"def enqueue_task(self, next_state):\\n\\t\\t# TODO(bslatkin): Remove these retries when they're not needed in userland.\\n\\t\\tRETRIES = 3\\n\\t\\ttarget_queue = os.environ.get('X_APPENGINE_QUEUENAME', SUBSCRIPTION_QUEUE)\\n\\t\\tfor i in xrange(RETRIES):\\n\\t\\t\\ttry:\\n\\t\\t\\t\\ttaskqueue.Task(\\n\\t\\t\\t\\t\\t\\turl='/work/subscriptions',\\n\\t\\t\\t\\t\\t\\teta=self.eta,\\n\\t\\t\\t\\t\\t\\tparams={'subscription_key_name': self.key().name(),\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t'next_state': next_state}\\n\\t\\t\\t\\t\\t\\t).add(target_queue)\\n\\t\\t\\texcept (taskqueue.Error, apiproxy_errors.Error):\\n\\t\\t\\t\\tlogging.exception('Could not insert task to confirm '\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t'topic = %s, callback = %s',\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tself.topic, self.callback)\\n\\t\\t\\t\\tif i == (RETRIES - 1):\\n\\t\\t\\t\\t\\traise\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn\",\n \"def collect(self):\\n while True:\\n if not self._queue.empty():\\n message = self._queue.get()\\n self.working_on = message['job_type']\\n else:\\n break\\n logging.info(\\\"Popped off message: {}\\\\n\\\".format(str(message)))\\n\\n if message['job_type'] == 'STOP':\\n break\\n\\n if message['job_type'] != 'MAINTAIN' and message['job_type'] != 'UPDATE':\\n raise ValueError('{} is not a recognized task type'.format(message['job_type']))\\n pass\\n\\n # Query all repos with repo url of given task\\n repoUrlSQL = s.sql.text(\\\"\\\"\\\"\\n SELECT min(repo_id) as repo_id FROM repo WHERE repo_git = '{}'\\n \\\"\\\"\\\".format(message['given']['github_url']))\\n repo_id = int(pd.read_sql(repoUrlSQL, self.db, params={}).iloc[0]['repo_id'])\\n\\n try:\\n if message['models'][0] == 'pull_requests':\\n self.pull_requests_model(message, repo_id)\\n elif message['models'][0] == 'pull_request_commits':\\n self.pull_request_commits_model(message, repo_id)\\n elif message['models'][0] == 'pull_request_files':\\n self.pull_requests_graphql(message, repo_id)\\n except Exception as e:\\n register_task_failure(self, message, repo_id, e)\\n pass\",\n \"def task_done(self):\\n\\t\\ttry:\\n\\t\\t\\tself.logger.debug('Im trying mark queue job item as done')\\n\\t\\t\\tself.queue.task_done()\\n\\t\\t\\tself.logger.debug('Queue job item mark as done')\\n\\t\\t\\treturn True\\n\\t\\texcept ValueError, e:\\n\\t\\t\\tself.logger.error('Error method task_done, error: %s'%(e),exc_info=True)\\n\\t\\t\\treturn False\",\n \"def threadWorker(self):\\n while True:\\n row = self.queue.get() #get a row of data\\n if row is None: #ending criterium\\n break\\n self.similarityQuestions(row) #the actual working function\\n self.queue.task_done() #inform the queue one task is done\",\n \"def worker(**kwargs):\\n\\t\\tident = kwargs[\\\"ident\\\"]\\n\\t\\twhile True:\\n\\t\\t\\titem = worker_queue.get()\\n\\t\\t\\tif item is None:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\tworker_function(ident, item)\\n\\t\\t\\tworker_queue.task_done()\",\n \"def _begin_consuming(self):\\n self._consuming = True\\n loop = asyncio.get_event_loop()\\n self._message_queue = asyncio.Queue(\\n maxsize=self.app.settings['SQS_PREFETCH_LIMIT'],\\n loop=loop,\\n )\\n loop.create_task(self._consume())\",\n \"def reAddJob(self, runner):\\n with self.__queueLock:\\n if not runner.clientRunner:\\n self.__queue.append(runner)\\n else:\\n self.__clientQueue.append(runner)\\n if self.__profileJobs:\\n runner.trackTime('queue')\\n self.__submittedJobs.append(runner.identifier)\",\n \"def _worker(self, task, task_queue):\\n with _thread_lock:\\n task.process_number = self.counter\\n self.counter += 1\\n if task.output:\\n if not task.has_error and task.processtime > 0:\\n if not os.path.isfile(task.logfile):\\n task.logfile = \\\"\\\"\\n task_queue.put(task)\\n return\\n try:\\n if not os.path.exists(task.folder):\\n task.add_error('Could not find folder: {}'.format(task.folder))\\n task.logfile = \\\"\\\"\\n else:\\n tmp_kwargs = dict(mode='a+', prefix=self.logfile_prefix,\\n suffix='.log', dir=task.folder, delete=False)\\n with NamedTemporaryFile(**tmp_kwargs) as logfile:\\n logfile.write('########### MACRO #############\\\\n')\\n logfile.write(\\\"\\\\n\\\".join(task.macro))\\n logfile.write('\\\\n\\\\n######### OUTPUT LOG ##########')\\n logfile.flush()\\n task.logfile = logfile.name\\n starttime = time.clock()\\n exe_args = dict(macro=task.macro,\\n logfile=logfile,\\n anybodycon_path=self.anybodycon_path,\\n timeout=self.timeout,\\n keep_macrofile=self.keep_logfiles,\\n env=self.env)\\n retcode = _execute_anybodycon(**exe_args)\\n endtime = time.clock()\\n logfile.seek(0)\\n if retcode == _KILLED_BY_ANYPYTOOLS:\\n task.processtime = 0\\n return\\n task.processtime = endtime - starttime\\n task.output = parse_anybodycon_output(\\n logfile.read(),\\n self.ignore_errors,\\n self.warnings_to_include)\\n except Exception as e:\\n exc_type, exc_obj, exc_tb = sys.exc_info()\\n fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]\\n task.add_error(str(exc_type) + '\\\\n' + str(fname) + '\\\\n' + str(exc_tb.tb_lineno))\\n logger.debug(str(e))\\n finally:\\n if not self.keep_logfiles and not task.has_error:\\n try:\\n silentremove(logfile.name)\\n task.logfile = \\\"\\\"\\n except OSError as e:\\n pass # Ignore if AnyBody has not released the log file.\\n task_queue.put(task)\",\n \"def _drain_queue(self):\\n while self.queue:\\n self._export_batch()\",\n \"def _run(self) -> None:\\n while True:\\n args: MigrationArgs = self._queue.get(block=True)\\n with self._lock:\\n if args.collection in self._chunks:\\n if args.shard_key not in self._chunks[args.collection]:\\n self._split_chunk(args.collection, args.shard_key)\\n self._move_chunk(args)\",\n \"def manage_cache_tasks(self):\\n outstanding_threads = self._has_outstanding_threads()\\n try:\\n # Get a task from the cache queue, waiting less if we have active threads.\\n timeout = NONBLOCKING_TIMEOUT if outstanding_threads else BLOCKING_TIMEOUT\\n\\n # Toggle between refresh and update queues so as to prevent starvation.\\n self._check_refresh_queue = not self._check_refresh_queue\\n if self._check_refresh_queue:\\n catalog, action = self._refresh_queue.get(timeout=timeout)\\n else:\\n catalog, action = self._update_queue.get(timeout=timeout)\\n\\n except Empty:\\n # No task exists in the cache queue, proceed to check for thread execution\\n pass\\n\\n else:\\n # Create and start a thread for the task\\n updater_thread = CacheUpdateWorker(\\n self._component_cache,\\n self._refresh_queue if self._check_refresh_queue else self._update_queue,\\n catalog,\\n action,\\n )\\n updater_thread.start()\\n queue_clause = \\\"refreshing\\\" if self._check_refresh_queue else \\\"updating\\\"\\n self.log.debug(f\\\"CacheUpdateWorker {queue_clause} catalog: '{updater_thread.name}', action: '{action}'...\\\")\\n self._threads.append(updater_thread)\",\n \"def reveille(self):\\n now = datetime.datetime.now()\\n # TODO: this logic can be optimized if our queue has a peek() method\\n while self._queue.size() > 0:\\n item = self._queue.get_tuple()\\n if item[1] <= now:\\n self._callback(item[0])\\n else:\\n # put the item back & terminate iteration\\n self._queue.put(item[0], item[1])\\n break\",\n \"def process_queue(self):\\n while self.input_processing_running:\\n\\n # Process everything in the queue.\\n while self.input_queue.qsize() > 0:\\n try:\\n _telem = self.input_queue.get_nowait()\\n self.process_telemetry(_telem)\\n\\n except Exception as e:\\n self.log_error(\\\"Error processing telemetry dict - %s\\\" % str(e))\\n\\n # Sleep while waiting for some new data.\\n time.sleep(0.5)\",\n \"def putting_task(self, func, *args, **kws):\\n if self.is_join:\\n raise self.TreadPoolException('Thread pool is closed.')\\n result_id = kws.pop('_result_id', self.NULLKEY)\\n task = self.setup_func(result_id, func, *args, **kws)\\n # mark one position in queue has been taken.\\n self.task_queue.put(True)\\n self.execute_task(task)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69388866","0.6733097","0.67244655","0.67082673","0.66665846","0.6658585","0.6600161","0.65939516","0.65230006","0.6475039","0.6474375","0.6474239","0.6462289","0.643574","0.6401118","0.6358066","0.6355609","0.6351405","0.63341194","0.63219726","0.63071495","0.629435","0.6256534","0.6222414","0.62162393","0.6204056","0.6196573","0.61932164","0.61779845","0.61696756","0.6157787","0.61366624","0.61282325","0.6109811","0.60888606","0.60668886","0.60610807","0.60583454","0.6046474","0.60428584","0.6024416","0.602372","0.60035646","0.5981264","0.5968618","0.5964111","0.5960539","0.5957937","0.59541905","0.59541124","0.59474164","0.5944491","0.59393317","0.5922572","0.59098387","0.5907155","0.59025395","0.58956444","0.5887618","0.58717114","0.58651394","0.585191","0.5847542","0.5839155","0.5837245","0.5836621","0.58238626","0.5823547","0.58187395","0.5802048","0.57920027","0.57833856","0.5781099","0.5777646","0.5777106","0.57497025","0.5747822","0.57472926","0.574669","0.57438","0.57434875","0.5738773","0.57212186","0.57199657","0.5719133","0.5714653","0.57144624","0.57105947","0.570456","0.570212","0.57012767","0.5699044","0.5695817","0.5694215","0.5693477","0.569264","0.56912225","0.56885463","0.567784","0.5677667","0.5674678"],"string":"[\n \"0.69388866\",\n \"0.6733097\",\n \"0.67244655\",\n \"0.67082673\",\n \"0.66665846\",\n \"0.6658585\",\n \"0.6600161\",\n \"0.65939516\",\n \"0.65230006\",\n \"0.6475039\",\n \"0.6474375\",\n \"0.6474239\",\n \"0.6462289\",\n \"0.643574\",\n \"0.6401118\",\n \"0.6358066\",\n \"0.6355609\",\n \"0.6351405\",\n \"0.63341194\",\n \"0.63219726\",\n \"0.63071495\",\n \"0.629435\",\n \"0.6256534\",\n \"0.6222414\",\n \"0.62162393\",\n \"0.6204056\",\n \"0.6196573\",\n \"0.61932164\",\n \"0.61779845\",\n \"0.61696756\",\n \"0.6157787\",\n \"0.61366624\",\n \"0.61282325\",\n \"0.6109811\",\n \"0.60888606\",\n \"0.60668886\",\n \"0.60610807\",\n \"0.60583454\",\n \"0.6046474\",\n \"0.60428584\",\n \"0.6024416\",\n \"0.602372\",\n \"0.60035646\",\n \"0.5981264\",\n \"0.5968618\",\n \"0.5964111\",\n \"0.5960539\",\n \"0.5957937\",\n \"0.59541905\",\n \"0.59541124\",\n \"0.59474164\",\n \"0.5944491\",\n \"0.59393317\",\n \"0.5922572\",\n \"0.59098387\",\n \"0.5907155\",\n \"0.59025395\",\n \"0.58956444\",\n \"0.5887618\",\n \"0.58717114\",\n \"0.58651394\",\n \"0.585191\",\n \"0.5847542\",\n \"0.5839155\",\n \"0.5837245\",\n \"0.5836621\",\n \"0.58238626\",\n \"0.5823547\",\n \"0.58187395\",\n \"0.5802048\",\n \"0.57920027\",\n \"0.57833856\",\n \"0.5781099\",\n \"0.5777646\",\n \"0.5777106\",\n \"0.57497025\",\n \"0.5747822\",\n \"0.57472926\",\n \"0.574669\",\n \"0.57438\",\n \"0.57434875\",\n \"0.5738773\",\n \"0.57212186\",\n \"0.57199657\",\n \"0.5719133\",\n \"0.5714653\",\n \"0.57144624\",\n \"0.57105947\",\n \"0.570456\",\n \"0.570212\",\n \"0.57012767\",\n \"0.5699044\",\n \"0.5695817\",\n \"0.5694215\",\n \"0.5693477\",\n \"0.569264\",\n \"0.56912225\",\n \"0.56885463\",\n \"0.567784\",\n \"0.5677667\",\n \"0.5674678\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80296,"cells":{"query":{"kind":"string","value":"Indicates if the group is discoverable for users to selfregister to it."},"document":{"kind":"string","value":"def discoverable(self):\n return sa.Column(sa.Boolean(), default=False)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def is_registered(self) -> bool:\n from arkouda.util import is_registered\n\n if self.registered_name is None:\n return False\n return is_registered(self.registered_name)","def can_group(self) -> bool:\n return (\n self.all_icon is not None and\n self.all_name is not None\n )","def is_registered(self):\n return self._is_registered","def belongs_to(self, group):\n return self in group.users","def registration_allowed(self):\n return getattr(settings, 'REGISTRATION_OPEN', True)","def registration_allowed(self):\n return getattr(settings, 'REGISTRATION_OPEN', True)","def is_scanlator(self) -> bool:\n return self.groups.filter(name='Scanlator').exists()","def is_registered(self):\n if self.user == getpass.getuser():\n return True\n else:\n return False","def registration_allowed(self, request):\n\t\treturn getattr(settings, 'REGISTRATION_OPEN', True)","def has_permission(self, request, view):\n authenticated = super(IsRpcRacker, self).has_permission(request, view)\n user_groups = getattr(request.user, 'roles', set())\n if not isinstance(user_groups, set):\n user_groups = set(user_groups)\n return authenticated and bool(self.rpc_groups & user_groups)","def is_user_registered(self):\n return IsUserRegisteredRequest(self)","def check_security_group(self):\n return True","def es_utilizado(self):\n group = Group.objects.filter(id=self.id)\n group = group.all()[0] if group.exists() else None\n # group = Group.objects.get(name=self.nombre)\n return group.user_set.all().exists() if group is not None else False","def gatekeeper():\n\n if user.name in GATEKEEPERS:\n return True\n\n return False","def can_be_accessed(self, user):\n if self.shared_with_everyone:\n return True\n\n if self.user == user or self.users_allowed.filter(pk=user.pk).exists():\n return True\n\n for group in self.groups_allowed.all():\n if user.groups.filter(pk=group.pk).exists():\n return True\n\n return False","def have_mister(self):\n return bool(self.mister)","def is_registered(self):\n return self.faucet is not None","def has_nominations_priority_access(local_group):\n if local_group is not None and hasattr(\n local_group,\n 'organizinghubaccess',\n ):\n access = local_group.organizinghubaccess\n has_feature_access = access.has_feature_access(\n OrganizingHubFeature.nominations_priority_support\n )\n return has_feature_access\n else:\n return False","def in_group(self, group):\n\n return self.secondary_groups.filter(\n groups_users.c.group_id == group.id).count() > 0","def has_module_permission(self, request):\n if request.user.groups.filter(name__in=['Sellers', 'Supporters']).exists():\n return True\n return False","def is_usable(self):\n return self._is_usable","def has_object_permission(self, request, view, obj):\n if request.user.is_manager or request.user == obj.registration.child.family:\n return True\n return False","def has_permission(self, request, view):\n usuario = request.user\n grupo = usuario.grupo\n return grupo.name in [\"SuperUsuario\", \"Administrador\"]","def is_on(self):\n return bool(self._insteon_device_group.value)","def available(self):\n #return not self.anonymous and len(self._data())\n return True","def has_permission(self, request):\n return request.user.is_active \\\n and request.user.groups.filter(name='users').count()","def available(self) -> bool:\n raise NotImplementedError","def IsAllowed(self):\r\n\r\n return self.notify.IsAllowed()","def IsAllowed(self):\r\n\r\n return self.notify.IsAllowed()","def IsAllowed(self):\r\n\r\n return self.notify.IsAllowed()","def is_admin(self,user):\n if user.is_superuser:\n return True\n\n if user.groups.filter(name=self.admin_group_name).count() > 0:\n return True\n else:\n return False","def isInternal(self):\n\n\t\t# TODO optimization do we really need to look at the host attributes?\n\t\t# maybe we can just use the global attribute (faster)\n\t\tfe = self.newdb.getFrontendName()\n\t\tnetwork = self.newdb.getHostAttr(fe, 'Kickstart_PrivateNetwork')\n\t\tnetmask = self.newdb.getHostAttr(fe, 'Kickstart_PrivateNetmask')\n\n\t\t# Test based on our client's IP address.\n\t\twork = string.split(network, '.')\n\t\tmask = string.split(netmask, '.')\n\t\tip = string.split(self.clientList[-1], '.')\n\n\t\tfor i in range(0, len(ip)):\n\t\t\ta = int(ip[i]) & int(mask[i])\n\t\t\tb = int(work[i]) & int(mask[i])\n\n\t\t\tif a != b:\n\t\t\t\treturn 0\n\n\t\treturn 1","def has_friendliness(self):\n trait = self.traitDao.get_friendliness(self.name)\n if trait is None:\n return False\n else:\n return True","def is_in_retina_graders_group(user):\n return user.groups.filter(name=settings.RETINA_GRADERS_GROUP_NAME).exists()","def available(self) -> bool:\n if self._avm_wrapper.devices[self._mac].wan_access is None:\n return False\n return super().available","def userMemebership(self, username, group):\r\n return group in self.getUserGroups(username)","def has_permission(self, request, view):\n usuario = request.user\n return str(usuario.grupo) == \"Vendedor\"","def on_private_cluster(self) -> bool:\n return self.cluster.spec.private if self.cluster.spec else False","def gethooverable(self):\n try:\n return self.hooverable\n except:\n return False","def has_super_access():\n current_user = frappe.get_doc('User', frappe.session.user)\n roles = set([role.role for role in current_user.roles])\n return bool(roles & {'Administrator', 'Instructor', 'Education Manager', 'System Manager', 'Academic User'})","def has_upnp_devices(self) -> bool:\n return self._has_upnp_devices","def is_administrator(self):\n return self.can(Permission.ADMIN)","def is_administrator(self):\n return self.can(Permission.ADMIN)","def available(self):\n return (\n hub.get_first(\n \"$.doorLockStatusList[?(@.deviceLabel=='%s')]\", self._device_label\n )\n is not None\n )","def available(self) -> bool:\n return bool(self._connected)","def has_group(self, resolvable):\n group = self._resolve_group(resolvable)\n\n for g in self.groups.query(name=group.name):\n if g.name == group.name:\n return True\n\n return False","def available(self):\n return True","def available(self):\n return True","def is_in_retina_group(user):\n return is_in_retina_graders_group(user) or is_in_retina_admins_group(user)","def user_has_groups(self, groups):\n if ('base.group_no_one' in groups.split(',') and\n self.env.user.has_group(\n 'cq_technical_features.group_technical_features')):\n return True\n return super(Base, self).user_has_groups(groups)","def is_available(self) -> bool:\n raise NotImplementedError","def can_be_registered(self, event_type):\n return True","def is_visible(cls, request):\n if cls.permission_required:\n return request.user.has_perm(cls.permission_uri)\n else:\n return True","def get_enable_private_cluster(self) -> bool:\n\n return self._get_enable_private_cluster(enable_validation=True)","def has_group(group, user, request):\n return group_names[group] in groupfinder(user.username, request)","def is_registered(self, type):\n attr = self._type_to_attr(type)\n return getattr(self, attr, None) is not None","def enable_private_nodes(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"enable_private_nodes\")","def enable_private_nodes(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"enable_private_nodes\")","def can(self):\n return self._can","def can(self):\n return self._can","def is_administrator(self):\n return False","def has_access(self):\n self._has_access = False\n\n if self.read_contact_info is not None:\n if self.read_contact_info['USERNAME'] == consts.USERNAME or \\\n consts.USERNAME in consts.REGISTEREDADMINS:\n self._has_access = True\n\n return self._has_access","def available(self) -> bool:\n return True","def available(self) -> bool:\n return True","def has_custom_gate(self) -> bool:\n for qubit_inst in self._map.values():\n for entry in qubit_inst.values():\n if entry.user_provided:\n return True\n return False","def has_access(self, user):\n if user.is_superuser:\n return True\n return self.user_objects(user).filter(id=self.id).exists()","def available(self) -> bool:\n return self._device.is_connected","def user_has_access(self, user):\n if self.visibility == self.PUBLIC:\n return True\n elif self.visibility == self.PRIVATE and self.created_by == user:\n return True\n elif self.visibility in (self.ORG_ONLY, self.ORG_ONLY_NO_EXTERNAL):\n if user.external and self.visibility == self.ORG_ONLY_NO_EXTERNAL:\n return False\n elif self.organization.memberships.filter(user=user).count() >= 1:\n return True\n return False","def is_participant(self,user):\n if user.is_superuser:\n return True\n\n if user.groups.filter(name=self.participants_group_name).count() > 0:\n return True\n else:\n return False","def has_permission(self, request, view):\n return request.user.group == 'admin'","def is_usermanager(self):\n return self.can(Permission.CRUD_USERS)","def privileged(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"privileged\")","def privileged(self) -> Optional[pulumi.Input[bool]]:\n return pulumi.get(self, \"privileged\")","def is_visible_to(self, user):\n return True","def accepting_private_patients(self):\n return self._accepting_private_patients","def can_be_registered(self, event_type):\n return (event_type in self._watchable_events or\n (event_type == self.ANY and self._allow_any))","def has_user(self, user): # pylint: disable=unused-argument\r\n return False","def no_network_access_check(user):\n return not user.has_property(\"network_access\")","def support_group_messaging(self) -> ConfigNodePropertyBoolean:\n return self._support_group_messaging","def is_available(self):\n if not is_optional_task_permissions_revoking_enabled():\n return False\n if not ITask.providedBy(self.context):\n return False\n if not self.context.get_review_state() in FINAL_TASK_STATES:\n return False\n if api.user.has_permission('cmf.ManagePortal'):\n return True\n issuer = self.context.get_issuer_actor()\n return issuer.identifier == api.user.get_current().id","def available(self):\n return True if self._device.status == \"AVAILABLE\" else False","def available(self):\n\t\t\treturn False","def available(self):\n\t\t\treturn False","def available(self):\n\t\t\treturn False","def is_mgr():\n if get_cluster_vendor() == \"sgi\":\n return sgi_cluster.is_sac()\n elif get_cluster_vendor() == \"ibm\": \n return ibm_cluster.is_xcat_mgr()\n\n return False","def available(self, o):\n return not self.locked() or self.isowner(o)","def get_viewable(self, user):\n return True","def is_group(self):\n return self._is_group","def check_user(self):\n try:\n if self.get_customer()[0][0] == self.dni:\n return True\n else:\n return False\n except:\n return False","def is_available(cls):\n\n try:\n proc = subprocess.Popen(\n ['systemctl', 'status', 'NetworkManager'],\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE,\n )\n proc.communicate()\n return proc.returncode == 0\n except OSError:\n return False","def available(self) -> bool:\n return self._api.available","def available(self):\n\t\t\treturn True","def available(self):\n\t\t\treturn True","def available(self):\n\t\t\treturn True","def is_eligible(self) -> Optional[bool]:\n return pulumi.get(self, \"is_eligible\")","def is_in_retina_admins_group(user):\n return user.groups.filter(name=settings.RETINA_ADMINS_GROUP_NAME).exists()","def is_available(self) -> bool:\n raise NotImplementedError() # pragma: nocover","def is_group_admin_group(self):\n groups = self['__store']\n return self.group_id in groups.get_group_admin_group_ids()","def current_user_has_access(self):\n return self.user_has_access(users.get_current_user())","def available(self) -> bool:\n return self._is_available"],"string":"[\n \"def is_registered(self) -> bool:\\n from arkouda.util import is_registered\\n\\n if self.registered_name is None:\\n return False\\n return is_registered(self.registered_name)\",\n \"def can_group(self) -> bool:\\n return (\\n self.all_icon is not None and\\n self.all_name is not None\\n )\",\n \"def is_registered(self):\\n return self._is_registered\",\n \"def belongs_to(self, group):\\n return self in group.users\",\n \"def registration_allowed(self):\\n return getattr(settings, 'REGISTRATION_OPEN', True)\",\n \"def registration_allowed(self):\\n return getattr(settings, 'REGISTRATION_OPEN', True)\",\n \"def is_scanlator(self) -> bool:\\n return self.groups.filter(name='Scanlator').exists()\",\n \"def is_registered(self):\\n if self.user == getpass.getuser():\\n return True\\n else:\\n return False\",\n \"def registration_allowed(self, request):\\n\\t\\treturn getattr(settings, 'REGISTRATION_OPEN', True)\",\n \"def has_permission(self, request, view):\\n authenticated = super(IsRpcRacker, self).has_permission(request, view)\\n user_groups = getattr(request.user, 'roles', set())\\n if not isinstance(user_groups, set):\\n user_groups = set(user_groups)\\n return authenticated and bool(self.rpc_groups & user_groups)\",\n \"def is_user_registered(self):\\n return IsUserRegisteredRequest(self)\",\n \"def check_security_group(self):\\n return True\",\n \"def es_utilizado(self):\\n group = Group.objects.filter(id=self.id)\\n group = group.all()[0] if group.exists() else None\\n # group = Group.objects.get(name=self.nombre)\\n return group.user_set.all().exists() if group is not None else False\",\n \"def gatekeeper():\\n\\n if user.name in GATEKEEPERS:\\n return True\\n\\n return False\",\n \"def can_be_accessed(self, user):\\n if self.shared_with_everyone:\\n return True\\n\\n if self.user == user or self.users_allowed.filter(pk=user.pk).exists():\\n return True\\n\\n for group in self.groups_allowed.all():\\n if user.groups.filter(pk=group.pk).exists():\\n return True\\n\\n return False\",\n \"def have_mister(self):\\n return bool(self.mister)\",\n \"def is_registered(self):\\n return self.faucet is not None\",\n \"def has_nominations_priority_access(local_group):\\n if local_group is not None and hasattr(\\n local_group,\\n 'organizinghubaccess',\\n ):\\n access = local_group.organizinghubaccess\\n has_feature_access = access.has_feature_access(\\n OrganizingHubFeature.nominations_priority_support\\n )\\n return has_feature_access\\n else:\\n return False\",\n \"def in_group(self, group):\\n\\n return self.secondary_groups.filter(\\n groups_users.c.group_id == group.id).count() > 0\",\n \"def has_module_permission(self, request):\\n if request.user.groups.filter(name__in=['Sellers', 'Supporters']).exists():\\n return True\\n return False\",\n \"def is_usable(self):\\n return self._is_usable\",\n \"def has_object_permission(self, request, view, obj):\\n if request.user.is_manager or request.user == obj.registration.child.family:\\n return True\\n return False\",\n \"def has_permission(self, request, view):\\n usuario = request.user\\n grupo = usuario.grupo\\n return grupo.name in [\\\"SuperUsuario\\\", \\\"Administrador\\\"]\",\n \"def is_on(self):\\n return bool(self._insteon_device_group.value)\",\n \"def available(self):\\n #return not self.anonymous and len(self._data())\\n return True\",\n \"def has_permission(self, request):\\n return request.user.is_active \\\\\\n and request.user.groups.filter(name='users').count()\",\n \"def available(self) -> bool:\\n raise NotImplementedError\",\n \"def IsAllowed(self):\\r\\n\\r\\n return self.notify.IsAllowed()\",\n \"def IsAllowed(self):\\r\\n\\r\\n return self.notify.IsAllowed()\",\n \"def IsAllowed(self):\\r\\n\\r\\n return self.notify.IsAllowed()\",\n \"def is_admin(self,user):\\n if user.is_superuser:\\n return True\\n\\n if user.groups.filter(name=self.admin_group_name).count() > 0:\\n return True\\n else:\\n return False\",\n \"def isInternal(self):\\n\\n\\t\\t# TODO optimization do we really need to look at the host attributes?\\n\\t\\t# maybe we can just use the global attribute (faster)\\n\\t\\tfe = self.newdb.getFrontendName()\\n\\t\\tnetwork = self.newdb.getHostAttr(fe, 'Kickstart_PrivateNetwork')\\n\\t\\tnetmask = self.newdb.getHostAttr(fe, 'Kickstart_PrivateNetmask')\\n\\n\\t\\t# Test based on our client's IP address.\\n\\t\\twork = string.split(network, '.')\\n\\t\\tmask = string.split(netmask, '.')\\n\\t\\tip = string.split(self.clientList[-1], '.')\\n\\n\\t\\tfor i in range(0, len(ip)):\\n\\t\\t\\ta = int(ip[i]) & int(mask[i])\\n\\t\\t\\tb = int(work[i]) & int(mask[i])\\n\\n\\t\\t\\tif a != b:\\n\\t\\t\\t\\treturn 0\\n\\n\\t\\treturn 1\",\n \"def has_friendliness(self):\\n trait = self.traitDao.get_friendliness(self.name)\\n if trait is None:\\n return False\\n else:\\n return True\",\n \"def is_in_retina_graders_group(user):\\n return user.groups.filter(name=settings.RETINA_GRADERS_GROUP_NAME).exists()\",\n \"def available(self) -> bool:\\n if self._avm_wrapper.devices[self._mac].wan_access is None:\\n return False\\n return super().available\",\n \"def userMemebership(self, username, group):\\r\\n return group in self.getUserGroups(username)\",\n \"def has_permission(self, request, view):\\n usuario = request.user\\n return str(usuario.grupo) == \\\"Vendedor\\\"\",\n \"def on_private_cluster(self) -> bool:\\n return self.cluster.spec.private if self.cluster.spec else False\",\n \"def gethooverable(self):\\n try:\\n return self.hooverable\\n except:\\n return False\",\n \"def has_super_access():\\n current_user = frappe.get_doc('User', frappe.session.user)\\n roles = set([role.role for role in current_user.roles])\\n return bool(roles & {'Administrator', 'Instructor', 'Education Manager', 'System Manager', 'Academic User'})\",\n \"def has_upnp_devices(self) -> bool:\\n return self._has_upnp_devices\",\n \"def is_administrator(self):\\n return self.can(Permission.ADMIN)\",\n \"def is_administrator(self):\\n return self.can(Permission.ADMIN)\",\n \"def available(self):\\n return (\\n hub.get_first(\\n \\\"$.doorLockStatusList[?(@.deviceLabel=='%s')]\\\", self._device_label\\n )\\n is not None\\n )\",\n \"def available(self) -> bool:\\n return bool(self._connected)\",\n \"def has_group(self, resolvable):\\n group = self._resolve_group(resolvable)\\n\\n for g in self.groups.query(name=group.name):\\n if g.name == group.name:\\n return True\\n\\n return False\",\n \"def available(self):\\n return True\",\n \"def available(self):\\n return True\",\n \"def is_in_retina_group(user):\\n return is_in_retina_graders_group(user) or is_in_retina_admins_group(user)\",\n \"def user_has_groups(self, groups):\\n if ('base.group_no_one' in groups.split(',') and\\n self.env.user.has_group(\\n 'cq_technical_features.group_technical_features')):\\n return True\\n return super(Base, self).user_has_groups(groups)\",\n \"def is_available(self) -> bool:\\n raise NotImplementedError\",\n \"def can_be_registered(self, event_type):\\n return True\",\n \"def is_visible(cls, request):\\n if cls.permission_required:\\n return request.user.has_perm(cls.permission_uri)\\n else:\\n return True\",\n \"def get_enable_private_cluster(self) -> bool:\\n\\n return self._get_enable_private_cluster(enable_validation=True)\",\n \"def has_group(group, user, request):\\n return group_names[group] in groupfinder(user.username, request)\",\n \"def is_registered(self, type):\\n attr = self._type_to_attr(type)\\n return getattr(self, attr, None) is not None\",\n \"def enable_private_nodes(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"enable_private_nodes\\\")\",\n \"def enable_private_nodes(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"enable_private_nodes\\\")\",\n \"def can(self):\\n return self._can\",\n \"def can(self):\\n return self._can\",\n \"def is_administrator(self):\\n return False\",\n \"def has_access(self):\\n self._has_access = False\\n\\n if self.read_contact_info is not None:\\n if self.read_contact_info['USERNAME'] == consts.USERNAME or \\\\\\n consts.USERNAME in consts.REGISTEREDADMINS:\\n self._has_access = True\\n\\n return self._has_access\",\n \"def available(self) -> bool:\\n return True\",\n \"def available(self) -> bool:\\n return True\",\n \"def has_custom_gate(self) -> bool:\\n for qubit_inst in self._map.values():\\n for entry in qubit_inst.values():\\n if entry.user_provided:\\n return True\\n return False\",\n \"def has_access(self, user):\\n if user.is_superuser:\\n return True\\n return self.user_objects(user).filter(id=self.id).exists()\",\n \"def available(self) -> bool:\\n return self._device.is_connected\",\n \"def user_has_access(self, user):\\n if self.visibility == self.PUBLIC:\\n return True\\n elif self.visibility == self.PRIVATE and self.created_by == user:\\n return True\\n elif self.visibility in (self.ORG_ONLY, self.ORG_ONLY_NO_EXTERNAL):\\n if user.external and self.visibility == self.ORG_ONLY_NO_EXTERNAL:\\n return False\\n elif self.organization.memberships.filter(user=user).count() >= 1:\\n return True\\n return False\",\n \"def is_participant(self,user):\\n if user.is_superuser:\\n return True\\n\\n if user.groups.filter(name=self.participants_group_name).count() > 0:\\n return True\\n else:\\n return False\",\n \"def has_permission(self, request, view):\\n return request.user.group == 'admin'\",\n \"def is_usermanager(self):\\n return self.can(Permission.CRUD_USERS)\",\n \"def privileged(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"privileged\\\")\",\n \"def privileged(self) -> Optional[pulumi.Input[bool]]:\\n return pulumi.get(self, \\\"privileged\\\")\",\n \"def is_visible_to(self, user):\\n return True\",\n \"def accepting_private_patients(self):\\n return self._accepting_private_patients\",\n \"def can_be_registered(self, event_type):\\n return (event_type in self._watchable_events or\\n (event_type == self.ANY and self._allow_any))\",\n \"def has_user(self, user): # pylint: disable=unused-argument\\r\\n return False\",\n \"def no_network_access_check(user):\\n return not user.has_property(\\\"network_access\\\")\",\n \"def support_group_messaging(self) -> ConfigNodePropertyBoolean:\\n return self._support_group_messaging\",\n \"def is_available(self):\\n if not is_optional_task_permissions_revoking_enabled():\\n return False\\n if not ITask.providedBy(self.context):\\n return False\\n if not self.context.get_review_state() in FINAL_TASK_STATES:\\n return False\\n if api.user.has_permission('cmf.ManagePortal'):\\n return True\\n issuer = self.context.get_issuer_actor()\\n return issuer.identifier == api.user.get_current().id\",\n \"def available(self):\\n return True if self._device.status == \\\"AVAILABLE\\\" else False\",\n \"def available(self):\\n\\t\\t\\treturn False\",\n \"def available(self):\\n\\t\\t\\treturn False\",\n \"def available(self):\\n\\t\\t\\treturn False\",\n \"def is_mgr():\\n if get_cluster_vendor() == \\\"sgi\\\":\\n return sgi_cluster.is_sac()\\n elif get_cluster_vendor() == \\\"ibm\\\": \\n return ibm_cluster.is_xcat_mgr()\\n\\n return False\",\n \"def available(self, o):\\n return not self.locked() or self.isowner(o)\",\n \"def get_viewable(self, user):\\n return True\",\n \"def is_group(self):\\n return self._is_group\",\n \"def check_user(self):\\n try:\\n if self.get_customer()[0][0] == self.dni:\\n return True\\n else:\\n return False\\n except:\\n return False\",\n \"def is_available(cls):\\n\\n try:\\n proc = subprocess.Popen(\\n ['systemctl', 'status', 'NetworkManager'],\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE,\\n )\\n proc.communicate()\\n return proc.returncode == 0\\n except OSError:\\n return False\",\n \"def available(self) -> bool:\\n return self._api.available\",\n \"def available(self):\\n\\t\\t\\treturn True\",\n \"def available(self):\\n\\t\\t\\treturn True\",\n \"def available(self):\\n\\t\\t\\treturn True\",\n \"def is_eligible(self) -> Optional[bool]:\\n return pulumi.get(self, \\\"is_eligible\\\")\",\n \"def is_in_retina_admins_group(user):\\n return user.groups.filter(name=settings.RETINA_ADMINS_GROUP_NAME).exists()\",\n \"def is_available(self) -> bool:\\n raise NotImplementedError() # pragma: nocover\",\n \"def is_group_admin_group(self):\\n groups = self['__store']\\n return self.group_id in groups.get_group_admin_group_ids()\",\n \"def current_user_has_access(self):\\n return self.user_has_access(users.get_current_user())\",\n \"def available(self) -> bool:\\n return self._is_available\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6570439","0.6480385","0.64103687","0.63470215","0.62850165","0.62850165","0.61633754","0.6154956","0.61019635","0.607818","0.60778564","0.6061658","0.60249096","0.59742856","0.5905762","0.5863819","0.58594495","0.58562326","0.5855537","0.58496606","0.582957","0.5823098","0.5744128","0.574261","0.5738534","0.57353085","0.5728086","0.57182896","0.57182896","0.57182896","0.57026035","0.57022375","0.57011986","0.56908464","0.5690241","0.5681836","0.56741375","0.5668181","0.5639387","0.5635614","0.5634785","0.5624994","0.5624994","0.56222194","0.56168157","0.5614024","0.5611552","0.5611552","0.5607562","0.56043077","0.5604055","0.5601434","0.5597955","0.5593564","0.5585412","0.55845463","0.55755794","0.55755794","0.5573915","0.5573915","0.55724955","0.55675876","0.55635715","0.55635715","0.5561302","0.5553927","0.55459553","0.5543646","0.55404913","0.5533","0.5532476","0.5532371","0.5532371","0.5528004","0.55225354","0.5522038","0.5521675","0.55215615","0.5519254","0.5517136","0.5514771","0.55080926","0.55080926","0.55080926","0.55078006","0.55026466","0.5502081","0.5498984","0.5495542","0.54951835","0.54901755","0.54765743","0.54765743","0.54765743","0.5474415","0.547349","0.54724646","0.5471787","0.54705167","0.54653597"],"string":"[\n \"0.6570439\",\n \"0.6480385\",\n \"0.64103687\",\n \"0.63470215\",\n \"0.62850165\",\n \"0.62850165\",\n \"0.61633754\",\n \"0.6154956\",\n \"0.61019635\",\n \"0.607818\",\n \"0.60778564\",\n \"0.6061658\",\n \"0.60249096\",\n \"0.59742856\",\n \"0.5905762\",\n \"0.5863819\",\n \"0.58594495\",\n \"0.58562326\",\n \"0.5855537\",\n \"0.58496606\",\n \"0.582957\",\n \"0.5823098\",\n \"0.5744128\",\n \"0.574261\",\n \"0.5738534\",\n \"0.57353085\",\n \"0.5728086\",\n \"0.57182896\",\n \"0.57182896\",\n \"0.57182896\",\n \"0.57026035\",\n \"0.57022375\",\n \"0.57011986\",\n \"0.56908464\",\n \"0.5690241\",\n \"0.5681836\",\n \"0.56741375\",\n \"0.5668181\",\n \"0.5639387\",\n \"0.5635614\",\n \"0.5634785\",\n \"0.5624994\",\n \"0.5624994\",\n \"0.56222194\",\n \"0.56168157\",\n \"0.5614024\",\n \"0.5611552\",\n \"0.5611552\",\n \"0.5607562\",\n \"0.56043077\",\n \"0.5604055\",\n \"0.5601434\",\n \"0.5597955\",\n \"0.5593564\",\n \"0.5585412\",\n \"0.55845463\",\n \"0.55755794\",\n \"0.55755794\",\n \"0.5573915\",\n \"0.5573915\",\n \"0.55724955\",\n \"0.55675876\",\n \"0.55635715\",\n \"0.55635715\",\n \"0.5561302\",\n \"0.5553927\",\n \"0.55459553\",\n \"0.5543646\",\n \"0.55404913\",\n \"0.5533\",\n \"0.5532476\",\n \"0.5532371\",\n \"0.5532371\",\n \"0.5528004\",\n \"0.55225354\",\n \"0.5522038\",\n \"0.5521675\",\n \"0.55215615\",\n \"0.5519254\",\n \"0.5517136\",\n \"0.5514771\",\n \"0.55080926\",\n \"0.55080926\",\n \"0.55080926\",\n \"0.55078006\",\n \"0.55026466\",\n \"0.5502081\",\n \"0.5498984\",\n \"0.5495542\",\n \"0.54951835\",\n \"0.54901755\",\n \"0.54765743\",\n \"0.54765743\",\n \"0.54765743\",\n \"0.5474415\",\n \"0.547349\",\n \"0.54724646\",\n \"0.5471787\",\n \"0.54705167\",\n \"0.54653597\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.55592"},"document_rank":{"kind":"string","value":"65"}}},{"rowIdx":80297,"cells":{"query":{"kind":"string","value":"Text containing the terms and conditions."},"document":{"kind":"string","value":"def terms(self):\n return sa.Column(sa.UnicodeText(), nullable=True)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def terms_and_conditions(request):\n\treturn render(request, 'tailored/terms_and_conditions.html', {})","def __str__(self):\n value = []\n for term in self.terms:\n value += [term.termname]\n return '<formula: %s>' % ' + '.join(value)","def __str__(self):\n value = []\n for term in self.terms:\n value += [term.termname]\n return '<formula: %s>' % ' + '.join(value)","def get_description(self):\n text = \"is a student's t distribution; characterised by its degrees of freedom, which here is\"+str(self.dofs)+\".\"\n return text","def syntax_text():","def get_text(self):\n text_complet = \"\"\n rez_dict = self.__results\n for i in range(0, len(rez_dict[\"text\"])):\n text = rez_dict[\"text\"][i]\n conf = int(rez_dict[\"conf\"][i])\n if conf > self.__min_confidence:\n text_complet += text + \" \"\n return text_complet","def logic_program_form(self):\r\n return '% ASP{f} Translation of System Description ' + self.name + '\\n\\n'","def logic_program_form(self):\r\n return '% -------------------------------------\\n' +\\\r\n '% Theory ' + self.name + '\\n' +\\\r\n '% -------------------------------------\\n\\n' +\\\r\n GENERAL_AXIOMS","def text(self) -> str:","def text(cfg, phase, high=6):\n short = cfg[\"fake\"].sentence(\n nb_words=high, variable_nb_words=True, ext_word_list=None\n )\n return \"{} {}\\n\\n{}\".format(\" \".join(cfg[phase]), short, blurb(cfg))","def format_text(self):\n\n return \"{}{}{}\".format(self.get_text(),\n Message.format_performers(self.get_performers()),\n Message.format_keywords(self.get_keywords())).strip()","def format_requisites(text, requisites):\n traits_text = ''\n allergens_text = ''\n\n req_map = {'trait': {'mhealthy': 'healthy'},\n 'allergens': {'sesame-seed': 'sesame seeds',\n 'tree-nuts': 'tree nuts',\n 'wheat_barley_rye': 'wheat or barley or rye'}}\n\n #If traits specified, extract into a string\n for i, trait in enumerate(requisites['trait']):\n if traits_text:\n traits_text += ', '\n traits_text += req_map['trait'].get(trait, trait)\n traits_text = format_plural(traits_text.rstrip(', '))\n\n #If allergens specified, extract into a string\n for i, allergen in enumerate(requisites['allergens']):\n if allergens_text:\n allergens_text += ', '\n allergens_text += req_map['allergens'].get(allergen, allergen)\n allergens_text = format_plural(allergens_text.rstrip(', '))\n allergens_text = allergens_text.replace('and', 'or')\n\n #Requisite-specific language\n if allergens_text:\n allergens_text = ' without ' + allergens_text\n if traits_text:\n traits_text = ' that is ' + traits_text\n\n #Return combined string\n if (allergens_text or traits_text) and 'Sorry, that is not available' in text:\n traits_text = traits_text.replace(' that is ', '')\n text = text.replace('Sorry, ', 'Sorry, ' + traits_text + ' ')\n text = text.replace('that is not available', '[meal]')\n return text + allergens_text + ' is not available'\n else:\n return text + traits_text + allergens_text","def to_string(self):\n\n # Get the header of the formula and the body separately\n header = f\"p cnf {self.nvars} {self.nclauses}\"\n body = \"\\n\".join(map(clause_to_string,\n self.base_clauses + self.aux_clauses))\n\n # Return the header and the body combined\n return header + \"\\n\" + body","def terms(self) -> pulumi.Output[Optional[str]]:\n return pulumi.get(self, \"terms\")","def description_text(self, P=None):\n\n if not P:\n P = self.parameters.values_to_dict()\n\n text = \"Calculated with {hamiltonian}, converged to \"\n # Convergence\n if P[\"convergence\"] == \"normal\":\n text += \"the 'normal' level of 1.0e-04 kcal/mol.\"\n elif P[\"convergence\"] == \"precise\":\n text += \"the 'precise' level of 1.0e-06 kcal/mol.\"\n elif P[\"convergence\"] == \"relative\":\n text += \"a factor of {relative} times the normal criterion.\"\n elif P[\"convergence\"] == \"absolute\":\n text += \"converged to {absolute}.\"\n\n if self.parameters[\"uhf\"].is_expr:\n text += (\n \" Whether to use spin-unrestricted SCF (UHF) for closed-shell molecules\"\n \"will be determined by '{uhf}'.\"\n )\n elif self.parameters[\"uhf\"].get():\n text += \" The SCF will be spin-unrestricted (UHF) for all molecules.\"\n else:\n text += (\n \" The SCF will be restricted for closed-shell molecules (RHF) and \"\n \"spin-unrestricted (UHF) for all others.\"\n )\n\n # MOZYME localized molecular orbitals.\n if P[\"MOZYME\"] == \"always\":\n text += (\n \"\\n\\nThe SCF will be solved using localized molecular orbitals \"\n \"(MOZYME), which is faster than the traditional method for larger \"\n \"systems.\"\n )\n used_mozyme = True\n elif P[\"MOZYME\"] == \"for larger systems\":\n text += (\n \"\\n\\nThe SCF will be solved using localized molecular orbitals \"\n \"(MOZYME) for systems with {nMOZYME} atoms or more. This method is \"\n \"faster than the traditional method for larger systems.\"\n )\n used_mozyme = True\n else:\n used_mozyme = False\n\n if used_mozyme:\n follow_up = P[\"MOZYME follow-up\"]\n if \"exact\" in follow_up:\n text += (\n \" The energy given by MOZYME slowly accumulates error due to the \"\n \"increasing non-orthogonality of the localized orbitals after \"\n \"many iterations. A single point energy using the traditional \"\n \"method will be run to get the correct energy.\"\n )\n elif \"new\" in follow_up:\n text += (\n \" The energy given by MOZYME slowly accumulates error due to the \"\n \"increasing non-orthogonality of the localized orbitals after \"\n \"many iterations. A single point energy using fresh localized \"\n \"orbitals will be run to get the correct energy.\"\n )\n elif follow_up == \"none\":\n text += (\n \" The energy given by MOZYME slowly accumulates error due to the \"\n \"increasing non-orthogonality of the localized orbitals after \"\n \"many iterations. No follow-up calculation will be done, so be \"\n \"careful with the final energies produced.\"\n )\n used_mozyme = False\n else:\n logger.error(f\"Don't recognize the MOZYME follow-up: '{follow_up}'\")\n\n # Handle COSMO\n if self.parameters[\"COSMO\"].is_expr:\n text += (\n \"\\n\\n'{COSMO}' will determine whether to use the COSMO solvation \"\n \"model. If it is used the parameters will be \"\n )\n elif self.parameters[\"COSMO\"].get():\n text += \"\\n\\nThe COSMO solvation model will be used with \"\n\n if self.parameters[\"COSMO\"].is_expr or self.parameters[\"COSMO\"].get():\n text += (\n \"dielectric constant = {eps}, solvent radius = {rsolve}, \"\n \"{nspa} grid points per atom, and a cutoff of {disex}.\"\n )\n\n # And bond orders\n if P[\"bond orders\"] == \"yes\":\n text += \"\\n\\nThe bond orders will be calculated.\"\n elif P[\"bond orders\"] == \"yes, and apply to structure\":\n text += (\n \"\\n\\nThe bond orders will be calculated and used to set the bonding \"\n \"for the structure.\"\n )\n\n return self.header + \"\\n\" + __(text, **P, indent=4 * \" \").__str__()","def logic_program_form(self):\n return '% -------------------------------------\\n' + GENERAL_AXIOMS","def logic_program_form(self):\n return '% Axioms\\n\\n'","def raw_text(self):\n\t\t\n\t\t #eliminating more headers\n\t\traw_text = re.sub(r\".*OPERATIONS O[PF].*\",r\"\",self.doc)\n\t\traw_text = re.sub(r\"Page \\d+\",r\"\",raw_text)\n\t\traw_text = re.sub(r\".*B[lL]OCK.*\",r\"\",raw_text)\n\t\traw_text = re.sub(r\".*WEST GULF.*\",r\"\",raw_text)\n\t\traw_text = re.sub(r\".*NAVAL FORCES ON.*\",r\"\",raw_text)\n\t\traw_text = re.sub(r\"\\s\",r\" \", raw_text) #eliminating tabs etc. \t \t \n\t\treturn raw_text","def render_formula_context(context, words):\n result = []\n started, ended = False, False\n for word in words:\n is_formula = (\n word.sentence_unique == context.sentence_unique and\n context.start <= word.idx <= context.end\n )\n if is_formula and not started:\n result.append('<span class=\"f-page-formula\">')\n started = True\n elif not is_formula and started and not ended:\n result.append('</span>')\n ended = True\n result.append(word.token.word_form)\n return \" \".join(result)","def logic_program_form(self):\n #TODO\n # determine step variable\n a_set = set()\n step = self.determineStepVariable()\n s = ''\n # assemble head\n s = s + self.assembleHead(a_set, step)\n # occ\n self.assembleOCC(a_set, step)\n # body\n s = s + self.assembleBody(a_set, step)\n return s","def get_text(self):\n inp = \" \"\n if self.link_id:\n inp += \"LINK \" + self.link_id\n inp += self.status + ' '\n if self.node_id:\n inp += \"NODE \" + self.node_id + ' '\n if self.value:\n inp += self.control_type.name + ' ' + str(self.value) + ' '\n if self.time:\n inp += self.time + ' '\n if self.clock_time:\n inp += self.clock_time + ' '\n # TODO: research correct formatting of time, clock_time options\n return inp","def logic_program_form(self):\r\n #TODO\r\n # determine step variable\r\n a_set = set()\r\n step = self.determineStepVariable()\r\n s = ''\r\n # assemble head\r\n s = s + self.assembleHead(a_set, step)\r\n # occ\r\n self.assembleOCC(a_set, step)\r\n # body\r\n s = s + self.assembleBody(a_set, step)\r\n return s","def prepareTextCondition(self, conditionData):\n if 'function' not in conditionData['data']:\n return 'Condition'\n \n # extract name\n funcName = conditionData['data']['function']\n\n funcArgType = \"%s\" % conditionData['data']['obj'][0]['selected-type']\n funcArg = \"%s\" % conditionData['data']['obj'][0]['value']\n\n leftVal = \"%s: %s\" % (funcArgType, funcArg)\n\n funcArgType = \"%s\" % conditionData['data']['obj'][1]['selected-type']\n if isinstance( conditionData['data']['obj'][1]['value'], dict):\n condVal = \"%s\" % conditionData['data']['obj'][1]['value']['operator']\n else:\n condVal = 'Undefined'\n\n funcArgType = \"%s\" % conditionData['data']['obj'][2]['selected-type']\n funcArg = \"%s\" % conditionData['data']['obj'][2]['value']\n if funcArgType == 'none':\n rightVal = 'None'\n else:\n rightVal = \"%s: %s\" % (funcArgType, funcArg)\n\n if condVal == 'Undefined':\n textItem = '%s\\n%s' % (funcName.title(), condVal)\n else:\n textItem = \"%s\\n%s\\n%s\" % (leftVal, condVal, rightVal)\n return textItem","def _create_formatted_string(self):\n string = NALSyntax.StatementSyntax.Start.value + \\\n self.get_subject_term().get_formatted_string()\n\n string += \" \" + self.get_copula_string() + \" \"\n\n string += self.get_predicate_term().get_formatted_string() + \\\n NALSyntax.StatementSyntax.End.value\n\n return string","def getText():","def getText():","def getText():","def getText():","def getText():","def __str__(self):\n astr = ' variables:\\t[ '\n for var in self.variables:\n astr += str(var) + ', '\n astr = astr[:-2] + ' ]\\n assumptions :\\t[ '\n for assumption in self.assumptions.cnf:\n astr += assumption.formula + ', '\n astr = astr[:-2] + ' ]\\n guarantees :\\t[ '\n for guarantee in self.guarantees.cnf:\n astr += guarantee.formula + ', '\n # astr = astr[:-2] + ' ]\\n guarantees_unsat :\\t[ '\n # for guarantee in self.guarantees.cnf:\n # astr += guarantee.unsaturated + ', '\n return astr[:-2] + ' ]\\n'","def BuildHeaderString (text):\r\n\r\n return t.BuildHeaderString (text)","def __str__(self):\n \n string = \"{}: {} ({}) - {}\".format(self.code, self.title, self.credit, self._term_name())\n return string","def get_parse_filter_text(conversation: Conversation):\n parse_op = gen_parse_op_text(conversation)\n if len(parse_op) > 0:\n intro_text = f\"For the data with <b>{parse_op}</b>,\"\n else:\n intro_text = \"For <b>all</b> the instances in the data,\"\n return intro_text","def __str__(self):\n return f'{self.text}: {self.chs}, correct answer: {self.solution}'","def getTextWithHeaders():","def __str__(self):\n\n return \"%s:\\n%s\" % (self.name, self.top_terms_tuples(25))","def _printable(self) -> str:\n \n if self.type_of_second_operand == self.TYPE_REF_ID:\n operand_type = \"RefID\"\n else:\n operand_type = \"Value\"\n\n # parenthesis to concatenate the string over multiple lines\n return (\n \"CQC IF header. RefID=\" + str(self.first_operand)\n + \" | Operator=\" + str(self.operator)\n + \" | \" + operand_type + \"=\" + str(self.second_operand)\n + \" | Second_operand_type=\" + operand_type\n + \" | Body_length=\" + str(self.length)\n )","def terms(request):\n return render(request, 'terms.html')","def get_EULA_summary(self, e):\n text = e.get_text() # EULA clauses separated by newlines.\n summary = self.summarizer(text, min_length=10, max_length=10 + min(140, len(text) // 3))\n return summary[0]['summary_text'].replace(' .', '.').lstrip()","def getConstantSentenceForms(self):","def __repr__(self): \n raw = self.body.split()\n i = 0\n for words in raw:\n if i%15 == 0:\n raw.insert(i, \"\\n\")\n i = i + 1\n raw.append(\"\\n Different Centuries meet System\\n\")\n return ' '.join(raw)","def getOutput(self):\n text = \"\"\n text += \"*\"*self.getLevel() + \" \"\n if self.isTODO():\n text += \"TODO \"\n if self.isDONE():\n text += \"DONE \"\n text += self.getTitle()\n return text","def logic_program_form(self):\r\n s = ''\r\n return s","def __repr__(self):\n\n return \"<Terms term=%s>\" % (self.word)","def logic_program_form(self):\n #TODO\n # determine step variable\n a_set = set()\n step = self.determineStepVariable()\n s = ''\n # assemble head\n s = s + self.assembleHead(a_set, step)\n # body\n s = s + self.assembleBody(a_set, step)\n return s","def text_report(self):\n\n word_count = self.word_count()\n\n print(\"\\nThere are {} words in the text.\".format(word_count))\n mean, median, mode = self.average_word_length()\n\n print(\"\\nMean, median and mode word length is {}, {}, {}.\".format(mean, median, mode))\n\n if word_count < 10:\n print(\"\\nLongest words:\")\n else:\n print(\"\\n10 longest words:\")\n for s in self.longest_words():\n print(s)\n\n print(\"\\nMost common words:\")\n for s in self.common_words():\n print(\"{} x {}\".format(s[1], s[0]))\n\n longest_grams = []\n\n # find n_longest n-grams\n n_longest = 10\n # strongly doubt that there will be n-grams longer than 50\n for i in range(min(50, word_count), 1, -1):\n if len(longest_grams) >= n_longest:\n break\n grams = self.find_ngrams(i)\n grams_list = sorted(grams, key=grams.get, reverse=True)\n\n for g in grams_list:\n if grams[g] > 4:\n # do not want to include n-grams which are substrings of longer n-grams\n substring = False\n for s in longest_grams:\n if g in s[1]:\n substring = True\n break\n if not substring:\n longest_grams.append([grams[g], g])\n\n print(\"\\nLongest n-grams:\")\n for g in longest_grams:\n print(\"{} x {}\".format(g[0], g[1]))\n print('\\n')","def _compute_fulltext(self):\n return ''","def get_text(self):","def criteria_display(self, obj):\n return markdownify(obj.criteria)","def fallback_text(self):\n text = \"\"\n text += \"bad keyword {}\" + \"\\n\"\n text += \"retry\" + \"\\n\"\n text += \"\\n\"\n text += \"available functions\" + \"\\n\"\n\n for keyword in self.keywords:\n text += f'{keyword}\\n'\n\n return text","def expand_contractions(text):\r\n text = re.sub(\r\n r\"(\\b)([Aa]re|[Cc]ould|[Dd]id|[Dd]oes|[Dd]o|[Hh]ad|[Hh]as|[Hh]ave|[Ii]s|[Mm]ight|[Mm]ust|[Ss]hould|[Ww]ere|[Ww]ould)n't\",\r\n r\"\\1\\2 not\", text)\r\n text = re.sub(r\"(\\b)([Hh]e|[Ii]|[Ss]he|[Tt]hey|[Ww]e|[Ww]hat|[Ww]ho|[Yy]ou)'ll\", r\"\\1\\2 will\", text)\r\n text = re.sub(r\"(\\b)([Tt]hey|[Ww]e|[Ww]hat|[Ww]ho|[Yy]ou)'re\", r\"\\1\\2 are\", text)\r\n text = re.sub(r\"(\\b)([Ii]|[Ss]hould|[Tt]hey|[Ww]e|[Ww]hat|[Ww]ho|[Ww]ould|[Yy]ou)'ve\", r\"\\1\\2 have\", text)\r\n\r\n text = re.sub(r\"(\\b)([Cc]a)n't\", r\"\\1\\2n not\", text)\r\n text = re.sub(r\"(\\b)([Ii])'m\", r\"\\1\\2 am\", text)\r\n text = re.sub(r\"(\\b)([Ll]et)'s\", r\"\\1\\2 us\", text)\r\n text = re.sub(r\"(\\b)([Ww])on't\", r\"\\1\\2ill not\", text)\r\n text = re.sub(r\"(\\b)([Ss])han't\", r\"\\1\\2hall not\", text)\r\n text = re.sub(r\"(\\b)([Yy])(?:'all|a'll)\", r\"\\1\\2ou all\", text)\r\n\r\n return text","def create_report(self):\n text_string = \"\\n\"\n text_string += \"Donor Name | Total Given | Num Gifts |\\\n Average Gift\\n\\\n ------------------------------------------------------------------\\n\"\n for donor in sorted(self.donors, key=Donor.sort_key, reverse=True):\n text_string += f\"{donor.name:<26} $ {donor.total_donations:>11.2f}\\\n {donor.number_of_donations:>10} $ {donor.average_gift:>11.2f}\\n\"\n\n return text_string","def qs_license():\r\n paragraph = document.add_paragraph('')\r\n document.add_heading('License', level=1)\r\n lic_metric = ['lef', 'serial', 'name', 'organization', 'product', 'numberOfCores', 'isExpired', 'expiredReason', 'isBlacklisted', 'isInvalid']\r\n qs_lic = get_qlik_sense.get_license()\r\n num_of_metric = len(qs_lic)\r\n table = document.add_table(rows=num_of_metric+1, cols=2)\r\n table.style = 'Grid Table 1 Light Accent 1'\r\n row = table.rows[0]\r\n row.cells[0].text = 'details'\r\n\r\n for metric in range(len(qs_lic)):\r\n row = table.rows[metric+1]\r\n row.cells[0].text = str(lic_metric[metric])\r\n row.cells[1].text = str(qs_lic[metric][0])\r\n document.add_page_break()","def to_text(self):\n res = []\n for production in self._productions:\n res.append(str(production.head) + \" -> \" +\n \" \".join([x.to_text() for x in production.body]))\n return \"\\n\".join(res) + \"\\n\"","def obtain_text():\n pass","def _get_requirement_text(node):\n if isinstance(node, tree.Name):\n # This happens when the users write a constant variable\n return node.name # pragma: no cover\n\n if isinstance(node, tree.String):\n # The most common occurrence - people just write the requirement as a string\n #\n # Remove the surrounding \"\"s of the string\n #\n return node.value.strip(\"'\").strip('\"')\n\n return \"\"","def __get_search_content(self):\n words = [\",\".join(self.__get_property_from_all_views(\"resource_id\")),\n \",\".join(self.__get_property_from_all_views(\"text\"))]\n return \"\\n\".join(words)","def make_extra_questions_txt(self):\n raise NotImplementedError","def logic_program_form(self):\n #TODO\n # determine step variable\n a_set = set()\n step = self.determineStepVariable()\n # occ\n s = self.assembleOCC(a_set, step)\n # body\n s = s + self.assembleBody(a_set, step)\n return s","def text(self):\n\t\treturn ' '.join([self.write_components[x] for x in self.write_components])","def text_of_quotation(exp):\n return cadr(exp)","def _latex_(self):\n old = s = \"\\\\begin{verbatim}\\\\end{verbatim}\"\n new = \"\"\n s = \"\\\\begin{verbatim}\\\\end{verbatim}\"\n s += \"Element of \" + self._space._latex_().replace(old, new) + \" With principal part \"\n WR = self._space.multiplier()\n # If we have more than one non-zero element in the principal part we have to\n # add a + between terms\n sp = \"\"\n for (b, m) in self._principal_part:\n a = self._principal_part[(b, m)]\n if a != 0:\n x = QQ(m + WR.Qv[WR.D.index(b)])\n if a != 1:\n if a > 0 and len(sp) > 0:\n ast = \"+\" + str(a)\n else:\n ast = str(a)\n sp = sp + ast + \"q^{\" + str(x) + \"}\"\n else:\n sp = sp + \"q^{\" + str(x) + \"}\"\n s = s + sp + \"$.\"\n return s","def show_licence(namespace):\n print(dedent(GSEA.legal_disclaimer))","def terms(self) -> Tuple[Term, ...]:\n ...","def getText(self):\n return(' '.join(map(lambda x:x.text,self.getNested())))","def get_text(self):\n return self.rule_id + '\\t' + self.rule_text","def _text(self, data):\n if len(data) == 0:\n return \"\\n\"\n rval = []\n for key in self.outer:\n if data.has_key(key):\n rval.append(\"%s: %s\" % (key, data[key]))\n if data.has_key('accounts'):\n rval.append(\"Accounts:\")\n for account in data['accounts']:\n tabs = \"\\t\"\n for kv in self.inner:\n if account.has_key(kv[0]):\n rval.append(\"%s%s: %s\" % (tabs, kv[1], account[kv[0]]))\n tabs = \"\\t\\t\"\n else:\n for key, val in data.iteritems():\n rval.append(\"%s = %s\" % (key, val))\n return \"\\n\".join(rval)","def text(self) -> str:\n text = []\n\n if self.min is not None:\n text.append(str(self.min))\n if self.include_min:\n text.append(\"<=\")\n else:\n text.append(\"<\")\n\n if self.min is not None or self.max is not None:\n text.append(\"value\")\n\n if self.max is not None:\n if self.include_max:\n text.append(\"<=\")\n else:\n text.append(\"<\")\n text.append(str(self.max))\n\n if self.step is not None:\n if self.min is not None or self.max is not None:\n text.append(\"and\")\n text.extend([\"value %\", str(self.step), \"==\"])\n if self.min is None:\n text.append(\"0\")\n else:\n text.append(str(self.min % self.step))\n\n return \" \".join(text)","def report_text(self):\n # type: () -> Optional[AnyStr]\n return f\"\\n{self.gen_report(as_dict=False)}\"","def text(self):\n text = ''\n for run in self.runs:\n text += run.text\n return text","def GenerateACLString(self):\n target_string = ''\n app_id = 100 # variable in ACL sentences.\n\n for terms in self.silverpeak_terms:\n for term in terms:\n for unit in term.GenerateUnitList():\n if term.term.precedence:\n for precedence in term.term.precedence:\n target_string += self._GenerateACLLine(app_id, term,\n unit, precedence)\n app_id += 100\n else:\n target_string += self._GenerateACLLine(app_id, term, unit)\n app_id += 100\n # finalize the target string\n target_string = self._FinalizeString(target_string, self.pre_string,\n self.fixed_content)\n return target_string","def __str__(self):\n\n return 'IF {0} THEN {1}'.format(', '.join([str(fv) for fv in self.fvals]),\n str(self.label))","def result(target_text):\n\n display_text(target_text)\n readability(target_text)","def __str__(self):\n\t\treturn f'{self.body} - quote of {self.author}'","def __repr__(self):\n st = '\\nProof(syntax=\\\"' + self.syntax + '\\\", formula_list=[\\n'\n for l in self.proof[:-1]:\n st += str(l) + ',\\n'\n return st + str(self.proof[-1]) + '])'","def getTerms(text, tolist=True):\n mywords = [\"https\", \"youtube\", \"@youtub\", \"co\", \"youtub\"]\n stemming = PorterStemmer()\n stops = set(stopwords.words(\"english\"))\n # Transform in lowercase\n text = text.lower()\n # delete urls and Via @ (for exameple via @youtube makes a lot of noise):\n text = re.sub(r'http\\S+', '', text)\n text = re.sub(r'via @\\S+', '', text)\n #Tokenize the text to get a list of terms\n text = text.split() \n # eliminate the stopwords \n text = [token for token in text if token not in stopwords.words('english')]\n # stem words\n text = [stemming.stem(token) for token in text]\n # remove noise words found after visual qualification\n text = [token for token in text if token not in mywords]\n if not tolist:\n text = ' '.join(text)\n return text","def export(self):\n metadata = {\n 'user': self.operator,\n 'technique': ' | '.join(self.techniques),\n }\n return self.text, metadata","def get_text(self):\n return ''.join(self.result)","def getComboTerms(tuples):\t\t\t\n\t\t\t#return \"[{0}]\".format('; '.join([\"({0})\".format(','.join([text[indices[0]:indices[1]], str(indices[0])])) for indices in tuples]))\n\t\t\treturn \"{0}\".format('; '.join((\"{0}\".format(text[indices[0]:indices[1]]) for indices in tuples)))","def logic_program_form(self):\r\n return '% -------------------------------------\\n' +\\\r\n '% Structure ' + self.name + '\\n' +\\\r\n '% -------------------------------------\\n\\n'","def get_string(self, check=True):\n\n if check:\n self.check()\n\n # generate the string\n s = []\n for qsection, qsec_parms in Q_PARAMETERS.iteritems():\n if not qsection in self.parameters:\n continue\n s.append(\"[%s]\" % qsection)\n if \"group_contribution\" in qsection or \"restraints\" in qsection:\n s.extend(self.parameters[qsection])\n elif \"lambda\" in qsection:\n s.append(self.parameters[qsection])\n else:\n for key,value in qsec_parms.iteritems():\n if key in self.parameters[qsection]:\n s.append(\"%-20s %30s\" % (key,self.parameters[qsection][key]))\n\n s.append(\"\")\n return \"\\n\".join(s)","def create_analysis(self):\n text = self.input_main.get(\"1.0\", \"end-1c\")\n if not text:\n return \"\"\n if self.ignore_case_value.get():\n text = text.lower()\n\n char_map = calc.char_mapping(text)\n unique_chars = len(char_map)\n entropy = calc.entropy(text)\n metric_entropy = calc.metric_entropy(text)\n optimal = calc.optimal_bits(text)\n\n info = \"\"\"Length: {}\nUnique chars: {}\nEntropy: {}\nMetric entropy: {}\nOptimal bit usage: {}\"\"\".format(\n len(text),\n unique_chars,\n entropy,\n metric_entropy,\n optimal\n )\n\n table_head = \" Char | Probability | Bits | Occurrences \"\n table_body = \"\\n\".join(\n [\n \" {:<4} | {:>11.7f} | {:>11.7f} | {:>11}\".format(\n char,\n prob, calc.prob_to_info(prob),\n text.count(char)\n )\n for char, prob in char_map\n ]\n )\n table = \"\\n\".join([table_head, table_body])\n\n return \"\\n\\n\".join([info, table])","def get_text(downgrade_titles=False):","def terms(self):\n return self._terms","def textfrombodies(self) -> str:\n type_priority = [\"plain\", \"html\", \"other\"] # TODO: Make configurable\n\n for texttype in type_priority:\n if texttype == \"plain\" and texttype in self.textbodies:\n \"\"\"Text is plain, so it can be used verbatim\"\"\"\n return self.textbodies[texttype]\n if texttype == \"html\" and texttype in self.textbodies:\n \"\"\"HTML text. Convert to markup with html2text and remove extra spaces\"\"\"\n text = html2text.html2text(self.textbodies[texttype])\n # Remove every second newline which is added to distinguish between paragraphs in Markdown, but makes\n # the jira ticket hard to read.\n return re.sub(\"(\\n.*?)\\n\", \"\\g<1>\", text)\n if texttype == \"other\" and len(self.textbodies):\n # If no other text is found, return the first available body if any.\n return self.textbodies[list(self.textbodies.keys())[0]]\n return \"The email contained no text bodies.\"","def _get_terms(self):\n return self.__terms","def _get_terms(self):\n return self.__terms","def _get_terms(self):\n return self.__terms","def _get_terms(self):\n return self.__terms","def _get_terms(self):\n return self.__terms","def _get_terms(self):\n return self.__terms","def _get_terms(self):\n return self.__terms","def _get_terms(self):\n return self.__terms","def _get_terms(self):\n return self.__terms","def inspect_text(self, page_text, terms):\n\n # convert all text to lower case to\n # increase likelihood of match\n page_text_lower = page_text.lower()\n page_text_lower = page_text_lower.replace('\\r', '').replace('\\n', '')\n\n payload = [\n # populate with match dicts\n ]\n\n for term in terms:\n sentences = [sentence + '.' for sentence in page_text_lower.split('.') if term in sentence]\n if len(sentences) > 0:\n logger.info('found \"{0}\" x{1}'.format(term, len(sentences)))\n for sentence in sentences:\n payload.append({\n 'term': term,\n 'sentence': sentence\n })\n\n return payload","def get_donor_list_text(self):\n text_string = \"\\nCurrent donors are:\\n\"\n for donor in self.donor_names:\n text_string += f\"{donor}\\n\"\n return text_string","def logic_program_form(self):\r\n #TODO\r\n return ''","def info():\n return r\"\"\"Tseng, Lin-Yu, and Chun Chen. \"Multiple trajectory search for unconstrained/constrained multi-objective optimization.\" Evolutionary Computation, 2009. CEC'09. IEEE Congress on. IEEE, 2009.\"\"\"","def receipt_text(self, **kw):\n return self._text(self._receipt_template, **kw)","def text(self):\n return \"\\n\".join(self.raw_text)","def get_assessment_terms(self):\n return # osid.repository.AssetQueryInspector"],"string":"[\n \"def terms_and_conditions(request):\\n\\treturn render(request, 'tailored/terms_and_conditions.html', {})\",\n \"def __str__(self):\\n value = []\\n for term in self.terms:\\n value += [term.termname]\\n return '<formula: %s>' % ' + '.join(value)\",\n \"def __str__(self):\\n value = []\\n for term in self.terms:\\n value += [term.termname]\\n return '<formula: %s>' % ' + '.join(value)\",\n \"def get_description(self):\\n text = \\\"is a student's t distribution; characterised by its degrees of freedom, which here is\\\"+str(self.dofs)+\\\".\\\"\\n return text\",\n \"def syntax_text():\",\n \"def get_text(self):\\n text_complet = \\\"\\\"\\n rez_dict = self.__results\\n for i in range(0, len(rez_dict[\\\"text\\\"])):\\n text = rez_dict[\\\"text\\\"][i]\\n conf = int(rez_dict[\\\"conf\\\"][i])\\n if conf > self.__min_confidence:\\n text_complet += text + \\\" \\\"\\n return text_complet\",\n \"def logic_program_form(self):\\r\\n return '% ASP{f} Translation of System Description ' + self.name + '\\\\n\\\\n'\",\n \"def logic_program_form(self):\\r\\n return '% -------------------------------------\\\\n' +\\\\\\r\\n '% Theory ' + self.name + '\\\\n' +\\\\\\r\\n '% -------------------------------------\\\\n\\\\n' +\\\\\\r\\n GENERAL_AXIOMS\",\n \"def text(self) -> str:\",\n \"def text(cfg, phase, high=6):\\n short = cfg[\\\"fake\\\"].sentence(\\n nb_words=high, variable_nb_words=True, ext_word_list=None\\n )\\n return \\\"{} {}\\\\n\\\\n{}\\\".format(\\\" \\\".join(cfg[phase]), short, blurb(cfg))\",\n \"def format_text(self):\\n\\n return \\\"{}{}{}\\\".format(self.get_text(),\\n Message.format_performers(self.get_performers()),\\n Message.format_keywords(self.get_keywords())).strip()\",\n \"def format_requisites(text, requisites):\\n traits_text = ''\\n allergens_text = ''\\n\\n req_map = {'trait': {'mhealthy': 'healthy'},\\n 'allergens': {'sesame-seed': 'sesame seeds',\\n 'tree-nuts': 'tree nuts',\\n 'wheat_barley_rye': 'wheat or barley or rye'}}\\n\\n #If traits specified, extract into a string\\n for i, trait in enumerate(requisites['trait']):\\n if traits_text:\\n traits_text += ', '\\n traits_text += req_map['trait'].get(trait, trait)\\n traits_text = format_plural(traits_text.rstrip(', '))\\n\\n #If allergens specified, extract into a string\\n for i, allergen in enumerate(requisites['allergens']):\\n if allergens_text:\\n allergens_text += ', '\\n allergens_text += req_map['allergens'].get(allergen, allergen)\\n allergens_text = format_plural(allergens_text.rstrip(', '))\\n allergens_text = allergens_text.replace('and', 'or')\\n\\n #Requisite-specific language\\n if allergens_text:\\n allergens_text = ' without ' + allergens_text\\n if traits_text:\\n traits_text = ' that is ' + traits_text\\n\\n #Return combined string\\n if (allergens_text or traits_text) and 'Sorry, that is not available' in text:\\n traits_text = traits_text.replace(' that is ', '')\\n text = text.replace('Sorry, ', 'Sorry, ' + traits_text + ' ')\\n text = text.replace('that is not available', '[meal]')\\n return text + allergens_text + ' is not available'\\n else:\\n return text + traits_text + allergens_text\",\n \"def to_string(self):\\n\\n # Get the header of the formula and the body separately\\n header = f\\\"p cnf {self.nvars} {self.nclauses}\\\"\\n body = \\\"\\\\n\\\".join(map(clause_to_string,\\n self.base_clauses + self.aux_clauses))\\n\\n # Return the header and the body combined\\n return header + \\\"\\\\n\\\" + body\",\n \"def terms(self) -> pulumi.Output[Optional[str]]:\\n return pulumi.get(self, \\\"terms\\\")\",\n \"def description_text(self, P=None):\\n\\n if not P:\\n P = self.parameters.values_to_dict()\\n\\n text = \\\"Calculated with {hamiltonian}, converged to \\\"\\n # Convergence\\n if P[\\\"convergence\\\"] == \\\"normal\\\":\\n text += \\\"the 'normal' level of 1.0e-04 kcal/mol.\\\"\\n elif P[\\\"convergence\\\"] == \\\"precise\\\":\\n text += \\\"the 'precise' level of 1.0e-06 kcal/mol.\\\"\\n elif P[\\\"convergence\\\"] == \\\"relative\\\":\\n text += \\\"a factor of {relative} times the normal criterion.\\\"\\n elif P[\\\"convergence\\\"] == \\\"absolute\\\":\\n text += \\\"converged to {absolute}.\\\"\\n\\n if self.parameters[\\\"uhf\\\"].is_expr:\\n text += (\\n \\\" Whether to use spin-unrestricted SCF (UHF) for closed-shell molecules\\\"\\n \\\"will be determined by '{uhf}'.\\\"\\n )\\n elif self.parameters[\\\"uhf\\\"].get():\\n text += \\\" The SCF will be spin-unrestricted (UHF) for all molecules.\\\"\\n else:\\n text += (\\n \\\" The SCF will be restricted for closed-shell molecules (RHF) and \\\"\\n \\\"spin-unrestricted (UHF) for all others.\\\"\\n )\\n\\n # MOZYME localized molecular orbitals.\\n if P[\\\"MOZYME\\\"] == \\\"always\\\":\\n text += (\\n \\\"\\\\n\\\\nThe SCF will be solved using localized molecular orbitals \\\"\\n \\\"(MOZYME), which is faster than the traditional method for larger \\\"\\n \\\"systems.\\\"\\n )\\n used_mozyme = True\\n elif P[\\\"MOZYME\\\"] == \\\"for larger systems\\\":\\n text += (\\n \\\"\\\\n\\\\nThe SCF will be solved using localized molecular orbitals \\\"\\n \\\"(MOZYME) for systems with {nMOZYME} atoms or more. This method is \\\"\\n \\\"faster than the traditional method for larger systems.\\\"\\n )\\n used_mozyme = True\\n else:\\n used_mozyme = False\\n\\n if used_mozyme:\\n follow_up = P[\\\"MOZYME follow-up\\\"]\\n if \\\"exact\\\" in follow_up:\\n text += (\\n \\\" The energy given by MOZYME slowly accumulates error due to the \\\"\\n \\\"increasing non-orthogonality of the localized orbitals after \\\"\\n \\\"many iterations. A single point energy using the traditional \\\"\\n \\\"method will be run to get the correct energy.\\\"\\n )\\n elif \\\"new\\\" in follow_up:\\n text += (\\n \\\" The energy given by MOZYME slowly accumulates error due to the \\\"\\n \\\"increasing non-orthogonality of the localized orbitals after \\\"\\n \\\"many iterations. A single point energy using fresh localized \\\"\\n \\\"orbitals will be run to get the correct energy.\\\"\\n )\\n elif follow_up == \\\"none\\\":\\n text += (\\n \\\" The energy given by MOZYME slowly accumulates error due to the \\\"\\n \\\"increasing non-orthogonality of the localized orbitals after \\\"\\n \\\"many iterations. No follow-up calculation will be done, so be \\\"\\n \\\"careful with the final energies produced.\\\"\\n )\\n used_mozyme = False\\n else:\\n logger.error(f\\\"Don't recognize the MOZYME follow-up: '{follow_up}'\\\")\\n\\n # Handle COSMO\\n if self.parameters[\\\"COSMO\\\"].is_expr:\\n text += (\\n \\\"\\\\n\\\\n'{COSMO}' will determine whether to use the COSMO solvation \\\"\\n \\\"model. If it is used the parameters will be \\\"\\n )\\n elif self.parameters[\\\"COSMO\\\"].get():\\n text += \\\"\\\\n\\\\nThe COSMO solvation model will be used with \\\"\\n\\n if self.parameters[\\\"COSMO\\\"].is_expr or self.parameters[\\\"COSMO\\\"].get():\\n text += (\\n \\\"dielectric constant = {eps}, solvent radius = {rsolve}, \\\"\\n \\\"{nspa} grid points per atom, and a cutoff of {disex}.\\\"\\n )\\n\\n # And bond orders\\n if P[\\\"bond orders\\\"] == \\\"yes\\\":\\n text += \\\"\\\\n\\\\nThe bond orders will be calculated.\\\"\\n elif P[\\\"bond orders\\\"] == \\\"yes, and apply to structure\\\":\\n text += (\\n \\\"\\\\n\\\\nThe bond orders will be calculated and used to set the bonding \\\"\\n \\\"for the structure.\\\"\\n )\\n\\n return self.header + \\\"\\\\n\\\" + __(text, **P, indent=4 * \\\" \\\").__str__()\",\n \"def logic_program_form(self):\\n return '% -------------------------------------\\\\n' + GENERAL_AXIOMS\",\n \"def logic_program_form(self):\\n return '% Axioms\\\\n\\\\n'\",\n \"def raw_text(self):\\n\\t\\t\\n\\t\\t #eliminating more headers\\n\\t\\traw_text = re.sub(r\\\".*OPERATIONS O[PF].*\\\",r\\\"\\\",self.doc)\\n\\t\\traw_text = re.sub(r\\\"Page \\\\d+\\\",r\\\"\\\",raw_text)\\n\\t\\traw_text = re.sub(r\\\".*B[lL]OCK.*\\\",r\\\"\\\",raw_text)\\n\\t\\traw_text = re.sub(r\\\".*WEST GULF.*\\\",r\\\"\\\",raw_text)\\n\\t\\traw_text = re.sub(r\\\".*NAVAL FORCES ON.*\\\",r\\\"\\\",raw_text)\\n\\t\\traw_text = re.sub(r\\\"\\\\s\\\",r\\\" \\\", raw_text) #eliminating tabs etc. \\t \\t \\n\\t\\treturn raw_text\",\n \"def render_formula_context(context, words):\\n result = []\\n started, ended = False, False\\n for word in words:\\n is_formula = (\\n word.sentence_unique == context.sentence_unique and\\n context.start <= word.idx <= context.end\\n )\\n if is_formula and not started:\\n result.append('<span class=\\\"f-page-formula\\\">')\\n started = True\\n elif not is_formula and started and not ended:\\n result.append('</span>')\\n ended = True\\n result.append(word.token.word_form)\\n return \\\" \\\".join(result)\",\n \"def logic_program_form(self):\\n #TODO\\n # determine step variable\\n a_set = set()\\n step = self.determineStepVariable()\\n s = ''\\n # assemble head\\n s = s + self.assembleHead(a_set, step)\\n # occ\\n self.assembleOCC(a_set, step)\\n # body\\n s = s + self.assembleBody(a_set, step)\\n return s\",\n \"def get_text(self):\\n inp = \\\" \\\"\\n if self.link_id:\\n inp += \\\"LINK \\\" + self.link_id\\n inp += self.status + ' '\\n if self.node_id:\\n inp += \\\"NODE \\\" + self.node_id + ' '\\n if self.value:\\n inp += self.control_type.name + ' ' + str(self.value) + ' '\\n if self.time:\\n inp += self.time + ' '\\n if self.clock_time:\\n inp += self.clock_time + ' '\\n # TODO: research correct formatting of time, clock_time options\\n return inp\",\n \"def logic_program_form(self):\\r\\n #TODO\\r\\n # determine step variable\\r\\n a_set = set()\\r\\n step = self.determineStepVariable()\\r\\n s = ''\\r\\n # assemble head\\r\\n s = s + self.assembleHead(a_set, step)\\r\\n # occ\\r\\n self.assembleOCC(a_set, step)\\r\\n # body\\r\\n s = s + self.assembleBody(a_set, step)\\r\\n return s\",\n \"def prepareTextCondition(self, conditionData):\\n if 'function' not in conditionData['data']:\\n return 'Condition'\\n \\n # extract name\\n funcName = conditionData['data']['function']\\n\\n funcArgType = \\\"%s\\\" % conditionData['data']['obj'][0]['selected-type']\\n funcArg = \\\"%s\\\" % conditionData['data']['obj'][0]['value']\\n\\n leftVal = \\\"%s: %s\\\" % (funcArgType, funcArg)\\n\\n funcArgType = \\\"%s\\\" % conditionData['data']['obj'][1]['selected-type']\\n if isinstance( conditionData['data']['obj'][1]['value'], dict):\\n condVal = \\\"%s\\\" % conditionData['data']['obj'][1]['value']['operator']\\n else:\\n condVal = 'Undefined'\\n\\n funcArgType = \\\"%s\\\" % conditionData['data']['obj'][2]['selected-type']\\n funcArg = \\\"%s\\\" % conditionData['data']['obj'][2]['value']\\n if funcArgType == 'none':\\n rightVal = 'None'\\n else:\\n rightVal = \\\"%s: %s\\\" % (funcArgType, funcArg)\\n\\n if condVal == 'Undefined':\\n textItem = '%s\\\\n%s' % (funcName.title(), condVal)\\n else:\\n textItem = \\\"%s\\\\n%s\\\\n%s\\\" % (leftVal, condVal, rightVal)\\n return textItem\",\n \"def _create_formatted_string(self):\\n string = NALSyntax.StatementSyntax.Start.value + \\\\\\n self.get_subject_term().get_formatted_string()\\n\\n string += \\\" \\\" + self.get_copula_string() + \\\" \\\"\\n\\n string += self.get_predicate_term().get_formatted_string() + \\\\\\n NALSyntax.StatementSyntax.End.value\\n\\n return string\",\n \"def getText():\",\n \"def getText():\",\n \"def getText():\",\n \"def getText():\",\n \"def getText():\",\n \"def __str__(self):\\n astr = ' variables:\\\\t[ '\\n for var in self.variables:\\n astr += str(var) + ', '\\n astr = astr[:-2] + ' ]\\\\n assumptions :\\\\t[ '\\n for assumption in self.assumptions.cnf:\\n astr += assumption.formula + ', '\\n astr = astr[:-2] + ' ]\\\\n guarantees :\\\\t[ '\\n for guarantee in self.guarantees.cnf:\\n astr += guarantee.formula + ', '\\n # astr = astr[:-2] + ' ]\\\\n guarantees_unsat :\\\\t[ '\\n # for guarantee in self.guarantees.cnf:\\n # astr += guarantee.unsaturated + ', '\\n return astr[:-2] + ' ]\\\\n'\",\n \"def BuildHeaderString (text):\\r\\n\\r\\n return t.BuildHeaderString (text)\",\n \"def __str__(self):\\n \\n string = \\\"{}: {} ({}) - {}\\\".format(self.code, self.title, self.credit, self._term_name())\\n return string\",\n \"def get_parse_filter_text(conversation: Conversation):\\n parse_op = gen_parse_op_text(conversation)\\n if len(parse_op) > 0:\\n intro_text = f\\\"For the data with <b>{parse_op}</b>,\\\"\\n else:\\n intro_text = \\\"For <b>all</b> the instances in the data,\\\"\\n return intro_text\",\n \"def __str__(self):\\n return f'{self.text}: {self.chs}, correct answer: {self.solution}'\",\n \"def getTextWithHeaders():\",\n \"def __str__(self):\\n\\n return \\\"%s:\\\\n%s\\\" % (self.name, self.top_terms_tuples(25))\",\n \"def _printable(self) -> str:\\n \\n if self.type_of_second_operand == self.TYPE_REF_ID:\\n operand_type = \\\"RefID\\\"\\n else:\\n operand_type = \\\"Value\\\"\\n\\n # parenthesis to concatenate the string over multiple lines\\n return (\\n \\\"CQC IF header. RefID=\\\" + str(self.first_operand)\\n + \\\" | Operator=\\\" + str(self.operator)\\n + \\\" | \\\" + operand_type + \\\"=\\\" + str(self.second_operand)\\n + \\\" | Second_operand_type=\\\" + operand_type\\n + \\\" | Body_length=\\\" + str(self.length)\\n )\",\n \"def terms(request):\\n return render(request, 'terms.html')\",\n \"def get_EULA_summary(self, e):\\n text = e.get_text() # EULA clauses separated by newlines.\\n summary = self.summarizer(text, min_length=10, max_length=10 + min(140, len(text) // 3))\\n return summary[0]['summary_text'].replace(' .', '.').lstrip()\",\n \"def getConstantSentenceForms(self):\",\n \"def __repr__(self): \\n raw = self.body.split()\\n i = 0\\n for words in raw:\\n if i%15 == 0:\\n raw.insert(i, \\\"\\\\n\\\")\\n i = i + 1\\n raw.append(\\\"\\\\n Different Centuries meet System\\\\n\\\")\\n return ' '.join(raw)\",\n \"def getOutput(self):\\n text = \\\"\\\"\\n text += \\\"*\\\"*self.getLevel() + \\\" \\\"\\n if self.isTODO():\\n text += \\\"TODO \\\"\\n if self.isDONE():\\n text += \\\"DONE \\\"\\n text += self.getTitle()\\n return text\",\n \"def logic_program_form(self):\\r\\n s = ''\\r\\n return s\",\n \"def __repr__(self):\\n\\n return \\\"<Terms term=%s>\\\" % (self.word)\",\n \"def logic_program_form(self):\\n #TODO\\n # determine step variable\\n a_set = set()\\n step = self.determineStepVariable()\\n s = ''\\n # assemble head\\n s = s + self.assembleHead(a_set, step)\\n # body\\n s = s + self.assembleBody(a_set, step)\\n return s\",\n \"def text_report(self):\\n\\n word_count = self.word_count()\\n\\n print(\\\"\\\\nThere are {} words in the text.\\\".format(word_count))\\n mean, median, mode = self.average_word_length()\\n\\n print(\\\"\\\\nMean, median and mode word length is {}, {}, {}.\\\".format(mean, median, mode))\\n\\n if word_count < 10:\\n print(\\\"\\\\nLongest words:\\\")\\n else:\\n print(\\\"\\\\n10 longest words:\\\")\\n for s in self.longest_words():\\n print(s)\\n\\n print(\\\"\\\\nMost common words:\\\")\\n for s in self.common_words():\\n print(\\\"{} x {}\\\".format(s[1], s[0]))\\n\\n longest_grams = []\\n\\n # find n_longest n-grams\\n n_longest = 10\\n # strongly doubt that there will be n-grams longer than 50\\n for i in range(min(50, word_count), 1, -1):\\n if len(longest_grams) >= n_longest:\\n break\\n grams = self.find_ngrams(i)\\n grams_list = sorted(grams, key=grams.get, reverse=True)\\n\\n for g in grams_list:\\n if grams[g] > 4:\\n # do not want to include n-grams which are substrings of longer n-grams\\n substring = False\\n for s in longest_grams:\\n if g in s[1]:\\n substring = True\\n break\\n if not substring:\\n longest_grams.append([grams[g], g])\\n\\n print(\\\"\\\\nLongest n-grams:\\\")\\n for g in longest_grams:\\n print(\\\"{} x {}\\\".format(g[0], g[1]))\\n print('\\\\n')\",\n \"def _compute_fulltext(self):\\n return ''\",\n \"def get_text(self):\",\n \"def criteria_display(self, obj):\\n return markdownify(obj.criteria)\",\n \"def fallback_text(self):\\n text = \\\"\\\"\\n text += \\\"bad keyword {}\\\" + \\\"\\\\n\\\"\\n text += \\\"retry\\\" + \\\"\\\\n\\\"\\n text += \\\"\\\\n\\\"\\n text += \\\"available functions\\\" + \\\"\\\\n\\\"\\n\\n for keyword in self.keywords:\\n text += f'{keyword}\\\\n'\\n\\n return text\",\n \"def expand_contractions(text):\\r\\n text = re.sub(\\r\\n r\\\"(\\\\b)([Aa]re|[Cc]ould|[Dd]id|[Dd]oes|[Dd]o|[Hh]ad|[Hh]as|[Hh]ave|[Ii]s|[Mm]ight|[Mm]ust|[Ss]hould|[Ww]ere|[Ww]ould)n't\\\",\\r\\n r\\\"\\\\1\\\\2 not\\\", text)\\r\\n text = re.sub(r\\\"(\\\\b)([Hh]e|[Ii]|[Ss]he|[Tt]hey|[Ww]e|[Ww]hat|[Ww]ho|[Yy]ou)'ll\\\", r\\\"\\\\1\\\\2 will\\\", text)\\r\\n text = re.sub(r\\\"(\\\\b)([Tt]hey|[Ww]e|[Ww]hat|[Ww]ho|[Yy]ou)'re\\\", r\\\"\\\\1\\\\2 are\\\", text)\\r\\n text = re.sub(r\\\"(\\\\b)([Ii]|[Ss]hould|[Tt]hey|[Ww]e|[Ww]hat|[Ww]ho|[Ww]ould|[Yy]ou)'ve\\\", r\\\"\\\\1\\\\2 have\\\", text)\\r\\n\\r\\n text = re.sub(r\\\"(\\\\b)([Cc]a)n't\\\", r\\\"\\\\1\\\\2n not\\\", text)\\r\\n text = re.sub(r\\\"(\\\\b)([Ii])'m\\\", r\\\"\\\\1\\\\2 am\\\", text)\\r\\n text = re.sub(r\\\"(\\\\b)([Ll]et)'s\\\", r\\\"\\\\1\\\\2 us\\\", text)\\r\\n text = re.sub(r\\\"(\\\\b)([Ww])on't\\\", r\\\"\\\\1\\\\2ill not\\\", text)\\r\\n text = re.sub(r\\\"(\\\\b)([Ss])han't\\\", r\\\"\\\\1\\\\2hall not\\\", text)\\r\\n text = re.sub(r\\\"(\\\\b)([Yy])(?:'all|a'll)\\\", r\\\"\\\\1\\\\2ou all\\\", text)\\r\\n\\r\\n return text\",\n \"def create_report(self):\\n text_string = \\\"\\\\n\\\"\\n text_string += \\\"Donor Name | Total Given | Num Gifts |\\\\\\n Average Gift\\\\n\\\\\\n ------------------------------------------------------------------\\\\n\\\"\\n for donor in sorted(self.donors, key=Donor.sort_key, reverse=True):\\n text_string += f\\\"{donor.name:<26} $ {donor.total_donations:>11.2f}\\\\\\n {donor.number_of_donations:>10} $ {donor.average_gift:>11.2f}\\\\n\\\"\\n\\n return text_string\",\n \"def qs_license():\\r\\n paragraph = document.add_paragraph('')\\r\\n document.add_heading('License', level=1)\\r\\n lic_metric = ['lef', 'serial', 'name', 'organization', 'product', 'numberOfCores', 'isExpired', 'expiredReason', 'isBlacklisted', 'isInvalid']\\r\\n qs_lic = get_qlik_sense.get_license()\\r\\n num_of_metric = len(qs_lic)\\r\\n table = document.add_table(rows=num_of_metric+1, cols=2)\\r\\n table.style = 'Grid Table 1 Light Accent 1'\\r\\n row = table.rows[0]\\r\\n row.cells[0].text = 'details'\\r\\n\\r\\n for metric in range(len(qs_lic)):\\r\\n row = table.rows[metric+1]\\r\\n row.cells[0].text = str(lic_metric[metric])\\r\\n row.cells[1].text = str(qs_lic[metric][0])\\r\\n document.add_page_break()\",\n \"def to_text(self):\\n res = []\\n for production in self._productions:\\n res.append(str(production.head) + \\\" -> \\\" +\\n \\\" \\\".join([x.to_text() for x in production.body]))\\n return \\\"\\\\n\\\".join(res) + \\\"\\\\n\\\"\",\n \"def obtain_text():\\n pass\",\n \"def _get_requirement_text(node):\\n if isinstance(node, tree.Name):\\n # This happens when the users write a constant variable\\n return node.name # pragma: no cover\\n\\n if isinstance(node, tree.String):\\n # The most common occurrence - people just write the requirement as a string\\n #\\n # Remove the surrounding \\\"\\\"s of the string\\n #\\n return node.value.strip(\\\"'\\\").strip('\\\"')\\n\\n return \\\"\\\"\",\n \"def __get_search_content(self):\\n words = [\\\",\\\".join(self.__get_property_from_all_views(\\\"resource_id\\\")),\\n \\\",\\\".join(self.__get_property_from_all_views(\\\"text\\\"))]\\n return \\\"\\\\n\\\".join(words)\",\n \"def make_extra_questions_txt(self):\\n raise NotImplementedError\",\n \"def logic_program_form(self):\\n #TODO\\n # determine step variable\\n a_set = set()\\n step = self.determineStepVariable()\\n # occ\\n s = self.assembleOCC(a_set, step)\\n # body\\n s = s + self.assembleBody(a_set, step)\\n return s\",\n \"def text(self):\\n\\t\\treturn ' '.join([self.write_components[x] for x in self.write_components])\",\n \"def text_of_quotation(exp):\\n return cadr(exp)\",\n \"def _latex_(self):\\n old = s = \\\"\\\\\\\\begin{verbatim}\\\\\\\\end{verbatim}\\\"\\n new = \\\"\\\"\\n s = \\\"\\\\\\\\begin{verbatim}\\\\\\\\end{verbatim}\\\"\\n s += \\\"Element of \\\" + self._space._latex_().replace(old, new) + \\\" With principal part \\\"\\n WR = self._space.multiplier()\\n # If we have more than one non-zero element in the principal part we have to\\n # add a + between terms\\n sp = \\\"\\\"\\n for (b, m) in self._principal_part:\\n a = self._principal_part[(b, m)]\\n if a != 0:\\n x = QQ(m + WR.Qv[WR.D.index(b)])\\n if a != 1:\\n if a > 0 and len(sp) > 0:\\n ast = \\\"+\\\" + str(a)\\n else:\\n ast = str(a)\\n sp = sp + ast + \\\"q^{\\\" + str(x) + \\\"}\\\"\\n else:\\n sp = sp + \\\"q^{\\\" + str(x) + \\\"}\\\"\\n s = s + sp + \\\"$.\\\"\\n return s\",\n \"def show_licence(namespace):\\n print(dedent(GSEA.legal_disclaimer))\",\n \"def terms(self) -> Tuple[Term, ...]:\\n ...\",\n \"def getText(self):\\n return(' '.join(map(lambda x:x.text,self.getNested())))\",\n \"def get_text(self):\\n return self.rule_id + '\\\\t' + self.rule_text\",\n \"def _text(self, data):\\n if len(data) == 0:\\n return \\\"\\\\n\\\"\\n rval = []\\n for key in self.outer:\\n if data.has_key(key):\\n rval.append(\\\"%s: %s\\\" % (key, data[key]))\\n if data.has_key('accounts'):\\n rval.append(\\\"Accounts:\\\")\\n for account in data['accounts']:\\n tabs = \\\"\\\\t\\\"\\n for kv in self.inner:\\n if account.has_key(kv[0]):\\n rval.append(\\\"%s%s: %s\\\" % (tabs, kv[1], account[kv[0]]))\\n tabs = \\\"\\\\t\\\\t\\\"\\n else:\\n for key, val in data.iteritems():\\n rval.append(\\\"%s = %s\\\" % (key, val))\\n return \\\"\\\\n\\\".join(rval)\",\n \"def text(self) -> str:\\n text = []\\n\\n if self.min is not None:\\n text.append(str(self.min))\\n if self.include_min:\\n text.append(\\\"<=\\\")\\n else:\\n text.append(\\\"<\\\")\\n\\n if self.min is not None or self.max is not None:\\n text.append(\\\"value\\\")\\n\\n if self.max is not None:\\n if self.include_max:\\n text.append(\\\"<=\\\")\\n else:\\n text.append(\\\"<\\\")\\n text.append(str(self.max))\\n\\n if self.step is not None:\\n if self.min is not None or self.max is not None:\\n text.append(\\\"and\\\")\\n text.extend([\\\"value %\\\", str(self.step), \\\"==\\\"])\\n if self.min is None:\\n text.append(\\\"0\\\")\\n else:\\n text.append(str(self.min % self.step))\\n\\n return \\\" \\\".join(text)\",\n \"def report_text(self):\\n # type: () -> Optional[AnyStr]\\n return f\\\"\\\\n{self.gen_report(as_dict=False)}\\\"\",\n \"def text(self):\\n text = ''\\n for run in self.runs:\\n text += run.text\\n return text\",\n \"def GenerateACLString(self):\\n target_string = ''\\n app_id = 100 # variable in ACL sentences.\\n\\n for terms in self.silverpeak_terms:\\n for term in terms:\\n for unit in term.GenerateUnitList():\\n if term.term.precedence:\\n for precedence in term.term.precedence:\\n target_string += self._GenerateACLLine(app_id, term,\\n unit, precedence)\\n app_id += 100\\n else:\\n target_string += self._GenerateACLLine(app_id, term, unit)\\n app_id += 100\\n # finalize the target string\\n target_string = self._FinalizeString(target_string, self.pre_string,\\n self.fixed_content)\\n return target_string\",\n \"def __str__(self):\\n\\n return 'IF {0} THEN {1}'.format(', '.join([str(fv) for fv in self.fvals]),\\n str(self.label))\",\n \"def result(target_text):\\n\\n display_text(target_text)\\n readability(target_text)\",\n \"def __str__(self):\\n\\t\\treturn f'{self.body} - quote of {self.author}'\",\n \"def __repr__(self):\\n st = '\\\\nProof(syntax=\\\\\\\"' + self.syntax + '\\\\\\\", formula_list=[\\\\n'\\n for l in self.proof[:-1]:\\n st += str(l) + ',\\\\n'\\n return st + str(self.proof[-1]) + '])'\",\n \"def getTerms(text, tolist=True):\\n mywords = [\\\"https\\\", \\\"youtube\\\", \\\"@youtub\\\", \\\"co\\\", \\\"youtub\\\"]\\n stemming = PorterStemmer()\\n stops = set(stopwords.words(\\\"english\\\"))\\n # Transform in lowercase\\n text = text.lower()\\n # delete urls and Via @ (for exameple via @youtube makes a lot of noise):\\n text = re.sub(r'http\\\\S+', '', text)\\n text = re.sub(r'via @\\\\S+', '', text)\\n #Tokenize the text to get a list of terms\\n text = text.split() \\n # eliminate the stopwords \\n text = [token for token in text if token not in stopwords.words('english')]\\n # stem words\\n text = [stemming.stem(token) for token in text]\\n # remove noise words found after visual qualification\\n text = [token for token in text if token not in mywords]\\n if not tolist:\\n text = ' '.join(text)\\n return text\",\n \"def export(self):\\n metadata = {\\n 'user': self.operator,\\n 'technique': ' | '.join(self.techniques),\\n }\\n return self.text, metadata\",\n \"def get_text(self):\\n return ''.join(self.result)\",\n \"def getComboTerms(tuples):\\t\\t\\t\\n\\t\\t\\t#return \\\"[{0}]\\\".format('; '.join([\\\"({0})\\\".format(','.join([text[indices[0]:indices[1]], str(indices[0])])) for indices in tuples]))\\n\\t\\t\\treturn \\\"{0}\\\".format('; '.join((\\\"{0}\\\".format(text[indices[0]:indices[1]]) for indices in tuples)))\",\n \"def logic_program_form(self):\\r\\n return '% -------------------------------------\\\\n' +\\\\\\r\\n '% Structure ' + self.name + '\\\\n' +\\\\\\r\\n '% -------------------------------------\\\\n\\\\n'\",\n \"def get_string(self, check=True):\\n\\n if check:\\n self.check()\\n\\n # generate the string\\n s = []\\n for qsection, qsec_parms in Q_PARAMETERS.iteritems():\\n if not qsection in self.parameters:\\n continue\\n s.append(\\\"[%s]\\\" % qsection)\\n if \\\"group_contribution\\\" in qsection or \\\"restraints\\\" in qsection:\\n s.extend(self.parameters[qsection])\\n elif \\\"lambda\\\" in qsection:\\n s.append(self.parameters[qsection])\\n else:\\n for key,value in qsec_parms.iteritems():\\n if key in self.parameters[qsection]:\\n s.append(\\\"%-20s %30s\\\" % (key,self.parameters[qsection][key]))\\n\\n s.append(\\\"\\\")\\n return \\\"\\\\n\\\".join(s)\",\n \"def create_analysis(self):\\n text = self.input_main.get(\\\"1.0\\\", \\\"end-1c\\\")\\n if not text:\\n return \\\"\\\"\\n if self.ignore_case_value.get():\\n text = text.lower()\\n\\n char_map = calc.char_mapping(text)\\n unique_chars = len(char_map)\\n entropy = calc.entropy(text)\\n metric_entropy = calc.metric_entropy(text)\\n optimal = calc.optimal_bits(text)\\n\\n info = \\\"\\\"\\\"Length: {}\\nUnique chars: {}\\nEntropy: {}\\nMetric entropy: {}\\nOptimal bit usage: {}\\\"\\\"\\\".format(\\n len(text),\\n unique_chars,\\n entropy,\\n metric_entropy,\\n optimal\\n )\\n\\n table_head = \\\" Char | Probability | Bits | Occurrences \\\"\\n table_body = \\\"\\\\n\\\".join(\\n [\\n \\\" {:<4} | {:>11.7f} | {:>11.7f} | {:>11}\\\".format(\\n char,\\n prob, calc.prob_to_info(prob),\\n text.count(char)\\n )\\n for char, prob in char_map\\n ]\\n )\\n table = \\\"\\\\n\\\".join([table_head, table_body])\\n\\n return \\\"\\\\n\\\\n\\\".join([info, table])\",\n \"def get_text(downgrade_titles=False):\",\n \"def terms(self):\\n return self._terms\",\n \"def textfrombodies(self) -> str:\\n type_priority = [\\\"plain\\\", \\\"html\\\", \\\"other\\\"] # TODO: Make configurable\\n\\n for texttype in type_priority:\\n if texttype == \\\"plain\\\" and texttype in self.textbodies:\\n \\\"\\\"\\\"Text is plain, so it can be used verbatim\\\"\\\"\\\"\\n return self.textbodies[texttype]\\n if texttype == \\\"html\\\" and texttype in self.textbodies:\\n \\\"\\\"\\\"HTML text. Convert to markup with html2text and remove extra spaces\\\"\\\"\\\"\\n text = html2text.html2text(self.textbodies[texttype])\\n # Remove every second newline which is added to distinguish between paragraphs in Markdown, but makes\\n # the jira ticket hard to read.\\n return re.sub(\\\"(\\\\n.*?)\\\\n\\\", \\\"\\\\g<1>\\\", text)\\n if texttype == \\\"other\\\" and len(self.textbodies):\\n # If no other text is found, return the first available body if any.\\n return self.textbodies[list(self.textbodies.keys())[0]]\\n return \\\"The email contained no text bodies.\\\"\",\n \"def _get_terms(self):\\n return self.__terms\",\n \"def _get_terms(self):\\n return self.__terms\",\n \"def _get_terms(self):\\n return self.__terms\",\n \"def _get_terms(self):\\n return self.__terms\",\n \"def _get_terms(self):\\n return self.__terms\",\n \"def _get_terms(self):\\n return self.__terms\",\n \"def _get_terms(self):\\n return self.__terms\",\n \"def _get_terms(self):\\n return self.__terms\",\n \"def _get_terms(self):\\n return self.__terms\",\n \"def inspect_text(self, page_text, terms):\\n\\n # convert all text to lower case to\\n # increase likelihood of match\\n page_text_lower = page_text.lower()\\n page_text_lower = page_text_lower.replace('\\\\r', '').replace('\\\\n', '')\\n\\n payload = [\\n # populate with match dicts\\n ]\\n\\n for term in terms:\\n sentences = [sentence + '.' for sentence in page_text_lower.split('.') if term in sentence]\\n if len(sentences) > 0:\\n logger.info('found \\\"{0}\\\" x{1}'.format(term, len(sentences)))\\n for sentence in sentences:\\n payload.append({\\n 'term': term,\\n 'sentence': sentence\\n })\\n\\n return payload\",\n \"def get_donor_list_text(self):\\n text_string = \\\"\\\\nCurrent donors are:\\\\n\\\"\\n for donor in self.donor_names:\\n text_string += f\\\"{donor}\\\\n\\\"\\n return text_string\",\n \"def logic_program_form(self):\\r\\n #TODO\\r\\n return ''\",\n \"def info():\\n return r\\\"\\\"\\\"Tseng, Lin-Yu, and Chun Chen. \\\"Multiple trajectory search for unconstrained/constrained multi-objective optimization.\\\" Evolutionary Computation, 2009. CEC'09. IEEE Congress on. IEEE, 2009.\\\"\\\"\\\"\",\n \"def receipt_text(self, **kw):\\n return self._text(self._receipt_template, **kw)\",\n \"def text(self):\\n return \\\"\\\\n\\\".join(self.raw_text)\",\n \"def get_assessment_terms(self):\\n return # osid.repository.AssetQueryInspector\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7217661","0.644716","0.644716","0.60568434","0.59968853","0.5941543","0.59272987","0.58720255","0.58531255","0.58456415","0.58353406","0.58314884","0.57985574","0.5666815","0.5553111","0.5552348","0.5544842","0.55418533","0.5538942","0.549686","0.5492341","0.5486449","0.54860353","0.5455678","0.5425869","0.5425869","0.5425869","0.5425869","0.5425869","0.5405671","0.5401485","0.54010516","0.53993136","0.53932935","0.5383979","0.5379047","0.5346521","0.53372","0.5333306","0.5287988","0.526896","0.52659374","0.5257846","0.525564","0.5229987","0.5224244","0.5209628","0.5203095","0.51923335","0.5186394","0.51823306","0.51812977","0.51778203","0.5173439","0.5169518","0.51681554","0.51668316","0.51577955","0.5151479","0.5132425","0.51206976","0.5120275","0.51196915","0.51132447","0.5105633","0.5093768","0.5090619","0.5089948","0.5089083","0.50864786","0.5075405","0.5065083","0.5063283","0.5062304","0.5060262","0.50541157","0.50523704","0.50519395","0.5049088","0.50394785","0.5035335","0.50213885","0.50194603","0.5016857","0.50166404","0.5012807","0.5012807","0.5012807","0.5012807","0.5012807","0.5012807","0.5012807","0.5012807","0.5012807","0.5011261","0.50048405","0.4991663","0.49852276","0.49832055","0.49817964","0.4977318"],"string":"[\n \"0.7217661\",\n \"0.644716\",\n \"0.644716\",\n \"0.60568434\",\n \"0.59968853\",\n \"0.5941543\",\n \"0.59272987\",\n \"0.58720255\",\n \"0.58531255\",\n \"0.58456415\",\n \"0.58353406\",\n \"0.58314884\",\n \"0.57985574\",\n \"0.5666815\",\n \"0.5553111\",\n \"0.5552348\",\n \"0.5544842\",\n \"0.55418533\",\n \"0.5538942\",\n \"0.549686\",\n \"0.5492341\",\n \"0.5486449\",\n \"0.54860353\",\n \"0.5455678\",\n \"0.5425869\",\n \"0.5425869\",\n \"0.5425869\",\n \"0.5425869\",\n \"0.5425869\",\n \"0.5405671\",\n \"0.5401485\",\n \"0.54010516\",\n \"0.53993136\",\n \"0.53932935\",\n \"0.5383979\",\n \"0.5379047\",\n \"0.5346521\",\n \"0.53372\",\n \"0.5333306\",\n \"0.5287988\",\n \"0.526896\",\n \"0.52659374\",\n \"0.5257846\",\n \"0.525564\",\n \"0.5229987\",\n \"0.5224244\",\n \"0.5209628\",\n \"0.5203095\",\n \"0.51923335\",\n \"0.5186394\",\n \"0.51823306\",\n \"0.51812977\",\n \"0.51778203\",\n \"0.5173439\",\n \"0.5169518\",\n \"0.51681554\",\n \"0.51668316\",\n \"0.51577955\",\n \"0.5151479\",\n \"0.5132425\",\n \"0.51206976\",\n \"0.5120275\",\n \"0.51196915\",\n \"0.51132447\",\n \"0.5105633\",\n \"0.5093768\",\n \"0.5090619\",\n \"0.5089948\",\n \"0.5089083\",\n \"0.50864786\",\n \"0.5075405\",\n \"0.5065083\",\n \"0.5063283\",\n \"0.5062304\",\n \"0.5060262\",\n \"0.50541157\",\n \"0.50523704\",\n \"0.50519395\",\n \"0.5049088\",\n \"0.50394785\",\n \"0.5035335\",\n \"0.50213885\",\n \"0.50194603\",\n \"0.5016857\",\n \"0.50166404\",\n \"0.5012807\",\n \"0.5012807\",\n \"0.5012807\",\n \"0.5012807\",\n \"0.5012807\",\n \"0.5012807\",\n \"0.5012807\",\n \"0.5012807\",\n \"0.5012807\",\n \"0.5011261\",\n \"0.50048405\",\n \"0.4991663\",\n \"0.49852276\",\n \"0.49832055\",\n \"0.49817964\",\n \"0.4977318\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80298,"cells":{"query":{"kind":"string","value":"Sorting priority weight of the group for resolving conflicting permissions."},"document":{"kind":"string","value":"def priority(self):\n # type: () -> GroupPriority\n if self._priority is not None:\n return self._priority\n if self.group_name == get_constant(\"MAGPIE_ANONYMOUS_GROUP\"):\n self._priority = -1 # lowest of all for *special* public group\n elif self.group_name == get_constant(\"MAGPIE_ADMIN_GROUP\"):\n self._priority = math.inf # everything will be lower than admins\n else:\n self._priority = 0 # nothing can be lower/equal to anonymous, equal for any *generic* group\n return self._priority"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _grokker_sort_key(args):\n grokker, name, obj = args\n return priority.bind().get(grokker)","def getPriority(self):","def priority(self):\n pass # pragma: no cover","def priority(self):\n pass # pragma: no cover","def _sort(self, groups):\n return sorted(groups, key=lambda group: (group.name.lower(), group.pubid))","def resort(self):\n self.items.sort(key=lambda node: node.path_weight, reverse=True)","def __cmp__(self,o):\n\t\treturn cmp(self.weight,o.weight)","def priority(name):\n try:\n manager = Actions()\n priority = Priority[name]\n ordered_tasks = manager.order_by_priority(priority)\n click.echo(\"Ordered by priority:\" + click.style(name, bg='red', fg='white'))\n click.echo()\n console_utils.format_print_ordered(ordered_tasks)\n except IndexError as e:\n click.echo(\"IndexError: \"+e)\n except Exception as e:\n click.echo(e)","def set_optimization_priority(self):\n\n if len(self.groups) == 0 and len(self.servers) == 0:\n return\n\n if self.resource.CPU_avail > 0:\n app_cpu_weight = float(self.total_CPU) / float(self.resource.CPU_avail)\n else:\n if self.total_CPU > 0:\n app_cpu_weight = 1.0\n else:\n app_cpu_weight = 0.0\n\n if self.resource.mem_avail > 0:\n app_mem_weight = float(self.total_mem) / float(self.resource.mem_avail)\n else:\n if self.total_mem > 0:\n app_mem_weight = 1.0\n else:\n app_mem_weight = 0.0\n\n if self.resource.local_disk_avail > 0:\n app_local_vol_weight = float(self.total_local_vol) / float(self.resource.local_disk_avail)\n else:\n if self.total_local_vol > 0:\n app_local_vol_weight = 1.0\n else:\n app_local_vol_weight = 0.0\n\n opt = [(\"cpu\", app_cpu_weight),\n (\"mem\", app_mem_weight),\n (\"lvol\", app_local_vol_weight)]\n\n self.optimization_priority = sorted(opt, key=lambda resource: resource[1], reverse=True)","def sort_weight(self):\n self._elements = list(\n _[-1] for _ in sorted((e.weight, e.value, e) for e in self)\n )","def _reorder_collected(self, data):\n priority = {\n 'post': 1,\n 'get': 2,\n 'put': 2,\n 'patch': 2,\n 'head': 2,\n 'options': 2,\n 'delete': 3,\n }\n data = sorted(\n data,\n key=lambda x: priority.get(getattr(x, 'name', ''), 4))\n return data","def sort(self):\n self.tasks = sorted(self.tasks, key=lambda k: k.priority, reverse=True)","def test_priority(self, inventoryloader):\n inventoryloader.set_group_priority('glance_api',-1)\n inventoryloader.add_group('glance_api',{'vars': {'management_bridge':'br_woot'}})\n assert 'br_woot' == inventoryloader.groups['glance_api'].vars.get('management_bridge')","def _sorting_feature_weights(feature_weights):\n feature_weights.sort(key=lambda x:abs(x[1]['weight']), reverse=True)\n return feature_weights","def getPriorityList(self):","def ordered(cls, package=None):\n extensions = cls.all(package)\n # Extract signatures and weights from `priority`.\n signatures = {}\n weights = {}\n for extension in extensions:\n priority = extension.priority\n if priority:\n if not isinstance(priority, list):\n priority = [priority]\n for signature_or_weight in priority:\n if isinstance(signature_or_weight, (int, float)):\n weights[extension] = signature_or_weight\n else:\n signatures[signature_or_weight] = extension\n # Generate a partial order relationship from weights.\n order = {}\n for extension in extensions:\n order[extension] = []\n weight = weights.get(extension, None)\n if weight is not None:\n order[extension] = [other for other in extensions\n if other in weights and\n weights[other] < weight]\n # Add `after` and `before` conditions.\n for extension in extensions:\n for others in (extension.after, extension.before):\n if not others:\n continue\n for other in (others if isinstance(others, list) else [others]):\n if isinstance(other, str):\n other = signatures.get(other)\n if other in extensions:\n if others is extension.after:\n order[extension].append(other)\n else:\n order[other].append(extension)\n # Enforce `precedence` conditions.\n packages = get_packages()\n for key in cls.precedence_map:\n interface, module = key\n if module in packages.modules and issubclass(interface, cls):\n for precedence in cls.precedence_map[key]:\n previous = None\n for extension in precedence:\n if isinstance(extension, str):\n extension = signatures.get(extension)\n if extension in extensions:\n if previous is not None:\n order[extension].append(previous)\n previous = extension\n # Sort the extensions.\n return toposort(extensions, order)","def sorted_gnames():\n return sorted(group_names.keys())","def _update_priority(self, task, prio, worker):\n task.priority = prio = max(prio, task.priority)\n for dep in task.deps or []:\n t = self._state.get_task(dep)\n if t is not None and prio > t.priority:\n self._update_priority(t, prio, worker)","def set_order_weight(self):\n\n for child in self.all_children():\n for rule in self.options['ordering']:\n if child.lineage_test(rule):\n child.order_weight = rule['order']","def set_order_weight(self):\n\n for child in self.all_children():\n for rule in self.options['ordering']:\n if child.lineage_test(rule):\n child.order_weight = rule['order']","def job_priority_key(self, job):\n if not self._stats.total_usage:\n fairshare = 1\n else:\n user = job.user\n effective = user.cpu_clock_used / self._stats.total_usage\n #shares_norm = user.shares # already normalized\n fairshare = 2.0 ** -(effective / user.shares)\n prio = int(fairshare * 100000) # higher value -> higher priority\n # TODO if needed change the constant to a configuration setting\n # TODO and add more components to the priority value\n return (-prio, job.submit, job.ID)","def get_ordered_group_keys(self):\r\n def number_of_emptys(key):\r\n if key == \"<none>\":\r\n return len(self.conflicting_keys)\r\n return key.count(\"<none>\")\r\n\r\n if self.ordering is not None:\r\n return self.ordering\r\n # The correct order is from least exclusives to most exclusives - a target can only depend on\r\n # other targets with fewer exclusives than itself.\r\n keys_by_empties = [ [] for l in range(len(self.key_to_targets)) ]\r\n # Flag to indicate whether there are any groups without any exclusives.\r\n no_exclusives = False\r\n for k in self.key_to_targets:\r\n if k == \"<none>\":\r\n no_exclusives = True\r\n else:\r\n keys_by_empties[number_of_emptys(k)].append(k)\r\n result = [ ]\r\n for i in range(len(keys_by_empties)):\r\n for j in range(len(keys_by_empties[i])):\r\n result.append(keys_by_empties[i][j])\r\n if no_exclusives:\r\n result.append(\"<none>\")\r\n result.reverse()\r\n self.ordering = result\r\n return self.ordering","def test_priority_order_error_bad_priority(self):\n test_name = sys._getframe().f_code.co_name\n rv, output = self._execute('priority remove bad_priority')\n self.assertEqual(2, rv)\n self.assertEqual(self.expected_results[test_name], output)","def _get_fabric_priority(self):\n return self.__fabric_priority","def _get_fabric_priority(self):\n return self.__fabric_priority","def _get_fabric_priority(self):\n return self.__fabric_priority","def _get_fabric_priority(self):\n return self.__fabric_priority","def _get_fabric_priority(self):\n return self.__fabric_priority","def _get_fabric_priority(self):\n return self.__fabric_priority","def increase_priority(self):\n if self._priority > 0:\n self._priority -= 1","def sorting(list_object): # Takes in a ListItem object and returns the\r\n # priority value - from w3schools.com\r\n return list_object.priority","def sort_priors(self):\n return","def sort_group():\n _id = request.form['_id']\n old_index = request.form['old_index']\n new_index = request.form['new_index']\n data, code, message = FIELD_SERVICE.sort_group(_id, old_index, new_index)\n return __result(data, code, message)","def sort_groups(x, group_order):\n for i, g in enumerate(group_order):\n if g == x:\n return i + 1","def _sort_segments_by_weight(self, l_segments):\n if len(l_segments) < 2:\n return l_segments\n\n l_segments_weights = sorted(\n [(i, self._calc_weight_of_segment(t_segment[0])) for i, t_segment in enumerate(l_segments)],\n key=lambda x: x[1], reverse=True)\n\n l_segments_sorted = [l_segments[i] for i, _ in l_segments_weights]\n return l_segments_sorted","def __cmp__(self, other):\n if self.weight > other.weight:\n return 1\n elif self.weight < other.weight:\n return -1\n else:\n return 0","def effective_priority (self):\n return self.priority if self.match.is_wildcarded else (1<<16) + 1","def sort(self):\r\n\t\tif ScoreOpt.isGroupVassals():\r\n\t\t\tself._playerScores.sort(lambda x, y: cmp(x.sortKey(), y.sortKey()))\r\n\t\t\tself._playerScores.reverse()\r\n\t\tmaxPlayers = ScoreOpt.getMaxPlayers()\r\n\t\tif maxPlayers > 0 and len(self._playerScores) > maxPlayers:\r\n\t\t\tself._playerScores = self._playerScores[len(self._playerScores) - maxPlayers:]","def get_sort_priority(self):\n return self.__sorting_priority","def get_priority(self):\n priority_value = (self.__priority if Priority.IMPORTANCE_RANKING == PriorityRanking.DESCENDING else Priority.MAX_PRIORITY-self.__priority)\n return 2 * priority_value","def _get_priority(self):\n return self.__priority","def _get_priority(self):\n return self.__priority","def _get_priority(self):\n return self.__priority","def _get_priority(self):\n return self.__priority","def _rgroup_sort(r):\n if r[0] == \"R\": return (\"R\", int(r[1:]))\n return (r, None)","def hook_priority(self) -> int:","def turn_priority(self):\n raise NotImplementedError(\"turn_priority() was not implemented in a subclass of TurnListItem.\")","def rank_higher():\n blueprints = current_app._blueprint_order\n our_index = None\n security_index = None\n\n for index, bp in enumerate(blueprints):\n if bp.name == \"security\":\n security_index = index\n if bp.name == \"invenio_config_tugraz\":\n our_index = index\n\n if (security_index is not None) and (our_index > security_index):\n temp = blueprints[security_index]\n blueprints[security_index] = blueprints[our_index]\n blueprints[our_index] = temp","def sort_key(self):\n ...","def part_build_order(self):\n priority = []\n for geo_item in self.build_order:\n if geo_item in self.parts:\n priority += [geo_item]\n return priority","def thread_priority(self):\n return _spacegrant_swig.G3RUH_descramble_sptr_thread_priority(self)","def reorder( self ):\n self.sorted.sort(self.compareFunction)","def getPriority(self):\n return self.priority","def sort_pkglist(pkgs):\n # It doesn't matter that ['4.9','4.10'] would be sorted to ['4.10','4.9'],\n # so long as the sorting is consistent.\n try:\n for key in pkgs:\n # Passing the pkglist to set() also removes duplicate version\n # numbers (if present).\n pkgs[key] = sorted(set(pkgs[key]))\n except AttributeError as exc:\n log.exception(exc)","def set_normal_priority(self, cr, uid, ids, context=None):\n return self.set_priority(cr, uid, ids, '3')","def preference_ordering(self) -> None:\n for i in self._destinations:\n self._destinations[i] = sorted(self._destinations[i])","def assign_priorities_and_dp(self):\r\n taskset_copy = copy(self.taskset)\r\n tasks = taskset_copy.sorted_by_crit()","def sort_facility(self):\n self.entries.sort(key=lambda x: x.severity)\n self.entries.sort(key=lambda x: x.facility)","def priority(self):\n return self._pri","def dag_topology_sort(self):\n mlist = []\n mod_wrapper = self.mod_wrapper.copy()\n while mod_wrapper:\n temp_list = []\n for mod, wrapper in mod_wrapper.items():\n if wrapper.is_root_mod():\n temp_list.append(mod)\n wrapper.remove_self_from_bindings()\n\n for mod in temp_list:\n mod_wrapper.pop(mod, None)\n\n mlist += temp_list\n\n mod_wrapper_sort = {}\n for mod, i in zip(mlist, range(len(mlist))):\n self.mod_wrapper[mod].set_idx_name(i)\n mod_wrapper_sort[mod] = self.mod_wrapper[mod]\n\n self.mod_wrapper = mod_wrapper_sort","def sort():\n return -1","def setPriority(self, p):\n self.priority = p","def _set_group_weight(self, _group):\n\n if self.resource.CPU_avail > 0:\n _group.vCPU_weight = float(_group.vCPUs) / float(self.resource.CPU_avail)\n else:\n if _group.vCPUs > 0:\n _group.vCPU_weight = 1.0\n else:\n _group.vCPU_weight = 0.0\n\n if self.resource.mem_avail > 0:\n _group.mem_weight = float(_group.mem) / float(self.resource.mem_avail)\n else:\n if _group.mem > 0:\n _group.mem_weight = 1.0\n else:\n _group.mem_weight = 0.0\n\n if self.resource.local_disk_avail > 0:\n _group.local_volume_weight = float(_group.local_volume_size) / float(self.resource.local_disk_avail)\n else:\n if _group.local_volume_size > 0:\n _group.local_volume_weight = 1.0\n else:\n _group.local_volume_weight = 0.0\n\n for _, sg in _group.subgroups.items():\n if isinstance(sg, Group):\n self._set_group_weight(sg)","def automorphism_group_order(self):\n if self.q == 2:\n return sage.all.factorial(self.L.size()) * (1 + int(self.variant.is_bipartite()))\n elif self.variant.is_bipartite():\n return (self.L.size() - 1) * self.d * self.L.size() * (self.K.size() - 1) * 2\n elif self.variant.is_minus() or self.p == 2:\n return (self.L.size() - 1) * self.d * self.L.size()\n else:\n return (self.L.size() - 1) * self.d","def thread_priority(self):\n return _spacegrant_swig.general_burster_2_sptr_thread_priority(self)","def _total_priority(self):\n return self.nodes[0]","def order(self):\n pairs = [(w['source'][0], w['target'][0]) for w in self.wires]\n return processing_order(len(self.modules), pairs)","def dmc_order(self):\n return sorted(self.lookup_table, key=lambda clr: int(clr.id) if clr.id.isdigit() else 0)","def thread_priority(self):\n return _spacegrant_swig.invert_bit_sptr_thread_priority(self)","def decrease_priority(self):\n self._priority += 1","def priority(self):\n return self._priority","def priority(self):\n return self._priority","def priority(self):\n return self._priority","def sort_with_beam(self, pattern_arr):\n\n def _cmp(x, y):\n \"\"\"Cmp function to sort pattern.\"\"\"\n if x[1].count > y[1].count:\n return CmpRelation.GREATER\n if x[1].count < y[1].count:\n return CmpRelation.LESS\n if x[1].ptn_length < y[1].ptn_length:\n return CmpRelation.GREATER\n if x[1].ptn_length > y[1].ptn_length:\n return CmpRelation.LESS\n return CmpRelation.EQUAL\n\n pattern_arr = sorted(pattern_arr.items(), key=functools.cmp_to_key(_cmp),\n reverse=True)\n if len(pattern_arr) > self.beam_width:\n pattern_arr = pattern_arr[:self.beam_width]\n return OrderedDict(pattern_arr)","def _SetCompoundPriorities(self):\n priority = self._GetMaxCommonPriority()\n for c in self.reactants:\n c.compound.SetSpeciesGroupPriority(priority)","def _sort_compounds(self):\n self.sorted_molecules = sorted(self.values(), key=operator.attrgetter('criterion'))","def _sorted_groups(self):\n positional_title = 'positional arguments'\n optional_title = 'optional arguments'\n groups = sorted(self._action_groups, key=lambda x: x.title.lower())\n for group in groups:\n if group.title == positional_title:\n yield group\n break\n for group in groups:\n if group.title == optional_title:\n yield group\n break\n for group in groups:\n if group.title not in [positional_title, optional_title]:\n yield group","def thread_priority(self):\n return _TestA_swig.cleanslate_sptr_thread_priority(self)","def sortby(self):\n ...","def sort_protein_group(pgroup, sortfunctions, sortfunc_index):\n pgroup_out = []\n subgroups = sortfunctions[sortfunc_index](pgroup)\n sortfunc_index += 1\n for subgroup in subgroups:\n if len(subgroup) > 1 and sortfunc_index < len(sortfunctions):\n pgroup_out.extend(sort_protein_group(subgroup,\n sortfunctions,\n sortfunc_index))\n else:\n pgroup_out.extend(subgroup)\n return pgroup_out","def sort(self): \n \n for i in range(0,len(self.tasks)):\n if len(self.tasks[i].build_block_belong) == 3:\n self.tree.add_element(self.tasks[i].build_block_belong,i)","def test_priority_remove_error_bad_priority(self):\n test_name = sys._getframe().f_code.co_name\n rv, output = self._execute('priority remove bad_priority')\n self.assertEqual(2, rv)\n self.assertEqual(self.expected_results[test_name], output)","def test_runner_uses_priority(monkeypatch, runner, example_tasks):\n order = []\n\n def _run(self, input_files):\n print(f'running task {self.name} with priority {self.priority}')\n order.append(self.priority)\n return [f'{self.name}_test.nc']\n\n monkeypatch.setattr(BaseTask, '_run', _run)\n monkeypatch.setattr(esmvalcore._task, 'Pool', ThreadPool)\n\n runner(example_tasks)\n print(order)\n assert len(order) == 12\n assert order == sorted(order)","def priority(node):\n return node.priority","def __cmp__(self, other) :\n if self.strength > other.strength:\n return 1;\n elif self.strength == other.strength :\n if self.rank > other.rank :\n return 1;\n elif self.rank == other.rank :\n return 1 if self.kickers > other.kickers else -1 if self.kickers < other.kickers else 0;\n return -1;","def priority(self) -> int:\n return pulumi.get(self, \"priority\")","def sorter(Plugin):\n return Plugin.order","def keysort(predicate_name, predicates_rules):\n if predicate_name in predicates_rules:\n if \"priority\" in predicates_rules[predicate_name]:\n return predicates_rules[predicate_name][\"priority\"]\n else:\n return 10\n else:\n return 10","def medium_priority(self):\n\n return self.filter(priority='2')","def sorting(recommendation: List[Tuple[str, int]]) -> None:\n \n for tup in range(len(recommendation)):\n score = recommendation[tup][1]\n alpha = recommendation[tup][0]\n for j in range(tup + 1, len(recommendation)):\n if recommendation[j][1] > score or \\\n (recommendation[j][1] == score and recommendation[j][0] < alpha):\n recommendation[j], recommendation[tup] = recommendation[tup], \\\n recommendation[j]","def get_priority(self):\n return False","def test_priority_change_error_bad_priority(self):\n test_name = sys._getframe().f_code.co_name\n rv, output = self._execute('priority change bad_priority changed_name')\n self.assertEqual(2, rv)\n self.assertEqual(self.expected_results[test_name], output)","def test_priority_order_up_ok(self):\n test_name = sys._getframe().f_code.co_name\n self._execute('priority order critical up')\n rv, output = self._execute('priority list')\n self.assertEqual(0, rv)\n self.assertEqual(self.expected_results[test_name], output)","def sortChoices(self):\n self.formatList.sort()","def _update_ordering(self):\n self._descendants = sorted(self.unordered_descendants(), key=lambda node: node.ord)\n for (new_ord, node) in enumerate(self._descendants, 1):\n node.ord = new_ord","def get_priority(self) -> str:\n if self.health >= 75 and self.food >= 75 and self.water >= 75:\n if min(self.food, self.water) == self.food:\n return 'food'\n else:\n return 'water'\n else:\n if self.food >= 75 and self.water >= 75:\n return 'monster'\n else:\n return 'food'","def check_order(racers):\n racers_orderd = sorted(racers, key=lambda x: (x.group, x.time))\n a = 1\n b = 1\n for r in racers_orderd:\n if r.group == \"ALL\":\n r.rank = str(a)\n a += 1\n else:\n r.rank = str(b)\n b += 1\n return racers_orderd","def _prioritify(line_of_css, css_props_text_as_list):\n sorted_css_properties, groups_by_alphabetic_order = css_props_text_as_list\n priority_integer, group_integer = 9999, 0\n for css_property in sorted_css_properties:\n if css_property.lower() == line_of_css.split(\":\")[0].lower().strip():\n priority_integer = sorted_css_properties.index(css_property)\n group_integer = groups_by_alphabetic_order[priority_integer]\n break\n return (priority_integer, group_integer)","def role_reorder_valid_roles_sort_key(item):\n return item[1]","def test_priority_order_down_ok(self):\n test_name = sys._getframe().f_code.co_name\n self._execute('priority order blocker down')\n rv, output = self._execute('priority list')\n self.assertEqual(0, rv)\n self.assertEqual(self.expected_results[test_name], output)"],"string":"[\n \"def _grokker_sort_key(args):\\n grokker, name, obj = args\\n return priority.bind().get(grokker)\",\n \"def getPriority(self):\",\n \"def priority(self):\\n pass # pragma: no cover\",\n \"def priority(self):\\n pass # pragma: no cover\",\n \"def _sort(self, groups):\\n return sorted(groups, key=lambda group: (group.name.lower(), group.pubid))\",\n \"def resort(self):\\n self.items.sort(key=lambda node: node.path_weight, reverse=True)\",\n \"def __cmp__(self,o):\\n\\t\\treturn cmp(self.weight,o.weight)\",\n \"def priority(name):\\n try:\\n manager = Actions()\\n priority = Priority[name]\\n ordered_tasks = manager.order_by_priority(priority)\\n click.echo(\\\"Ordered by priority:\\\" + click.style(name, bg='red', fg='white'))\\n click.echo()\\n console_utils.format_print_ordered(ordered_tasks)\\n except IndexError as e:\\n click.echo(\\\"IndexError: \\\"+e)\\n except Exception as e:\\n click.echo(e)\",\n \"def set_optimization_priority(self):\\n\\n if len(self.groups) == 0 and len(self.servers) == 0:\\n return\\n\\n if self.resource.CPU_avail > 0:\\n app_cpu_weight = float(self.total_CPU) / float(self.resource.CPU_avail)\\n else:\\n if self.total_CPU > 0:\\n app_cpu_weight = 1.0\\n else:\\n app_cpu_weight = 0.0\\n\\n if self.resource.mem_avail > 0:\\n app_mem_weight = float(self.total_mem) / float(self.resource.mem_avail)\\n else:\\n if self.total_mem > 0:\\n app_mem_weight = 1.0\\n else:\\n app_mem_weight = 0.0\\n\\n if self.resource.local_disk_avail > 0:\\n app_local_vol_weight = float(self.total_local_vol) / float(self.resource.local_disk_avail)\\n else:\\n if self.total_local_vol > 0:\\n app_local_vol_weight = 1.0\\n else:\\n app_local_vol_weight = 0.0\\n\\n opt = [(\\\"cpu\\\", app_cpu_weight),\\n (\\\"mem\\\", app_mem_weight),\\n (\\\"lvol\\\", app_local_vol_weight)]\\n\\n self.optimization_priority = sorted(opt, key=lambda resource: resource[1], reverse=True)\",\n \"def sort_weight(self):\\n self._elements = list(\\n _[-1] for _ in sorted((e.weight, e.value, e) for e in self)\\n )\",\n \"def _reorder_collected(self, data):\\n priority = {\\n 'post': 1,\\n 'get': 2,\\n 'put': 2,\\n 'patch': 2,\\n 'head': 2,\\n 'options': 2,\\n 'delete': 3,\\n }\\n data = sorted(\\n data,\\n key=lambda x: priority.get(getattr(x, 'name', ''), 4))\\n return data\",\n \"def sort(self):\\n self.tasks = sorted(self.tasks, key=lambda k: k.priority, reverse=True)\",\n \"def test_priority(self, inventoryloader):\\n inventoryloader.set_group_priority('glance_api',-1)\\n inventoryloader.add_group('glance_api',{'vars': {'management_bridge':'br_woot'}})\\n assert 'br_woot' == inventoryloader.groups['glance_api'].vars.get('management_bridge')\",\n \"def _sorting_feature_weights(feature_weights):\\n feature_weights.sort(key=lambda x:abs(x[1]['weight']), reverse=True)\\n return feature_weights\",\n \"def getPriorityList(self):\",\n \"def ordered(cls, package=None):\\n extensions = cls.all(package)\\n # Extract signatures and weights from `priority`.\\n signatures = {}\\n weights = {}\\n for extension in extensions:\\n priority = extension.priority\\n if priority:\\n if not isinstance(priority, list):\\n priority = [priority]\\n for signature_or_weight in priority:\\n if isinstance(signature_or_weight, (int, float)):\\n weights[extension] = signature_or_weight\\n else:\\n signatures[signature_or_weight] = extension\\n # Generate a partial order relationship from weights.\\n order = {}\\n for extension in extensions:\\n order[extension] = []\\n weight = weights.get(extension, None)\\n if weight is not None:\\n order[extension] = [other for other in extensions\\n if other in weights and\\n weights[other] < weight]\\n # Add `after` and `before` conditions.\\n for extension in extensions:\\n for others in (extension.after, extension.before):\\n if not others:\\n continue\\n for other in (others if isinstance(others, list) else [others]):\\n if isinstance(other, str):\\n other = signatures.get(other)\\n if other in extensions:\\n if others is extension.after:\\n order[extension].append(other)\\n else:\\n order[other].append(extension)\\n # Enforce `precedence` conditions.\\n packages = get_packages()\\n for key in cls.precedence_map:\\n interface, module = key\\n if module in packages.modules and issubclass(interface, cls):\\n for precedence in cls.precedence_map[key]:\\n previous = None\\n for extension in precedence:\\n if isinstance(extension, str):\\n extension = signatures.get(extension)\\n if extension in extensions:\\n if previous is not None:\\n order[extension].append(previous)\\n previous = extension\\n # Sort the extensions.\\n return toposort(extensions, order)\",\n \"def sorted_gnames():\\n return sorted(group_names.keys())\",\n \"def _update_priority(self, task, prio, worker):\\n task.priority = prio = max(prio, task.priority)\\n for dep in task.deps or []:\\n t = self._state.get_task(dep)\\n if t is not None and prio > t.priority:\\n self._update_priority(t, prio, worker)\",\n \"def set_order_weight(self):\\n\\n for child in self.all_children():\\n for rule in self.options['ordering']:\\n if child.lineage_test(rule):\\n child.order_weight = rule['order']\",\n \"def set_order_weight(self):\\n\\n for child in self.all_children():\\n for rule in self.options['ordering']:\\n if child.lineage_test(rule):\\n child.order_weight = rule['order']\",\n \"def job_priority_key(self, job):\\n if not self._stats.total_usage:\\n fairshare = 1\\n else:\\n user = job.user\\n effective = user.cpu_clock_used / self._stats.total_usage\\n #shares_norm = user.shares # already normalized\\n fairshare = 2.0 ** -(effective / user.shares)\\n prio = int(fairshare * 100000) # higher value -> higher priority\\n # TODO if needed change the constant to a configuration setting\\n # TODO and add more components to the priority value\\n return (-prio, job.submit, job.ID)\",\n \"def get_ordered_group_keys(self):\\r\\n def number_of_emptys(key):\\r\\n if key == \\\"<none>\\\":\\r\\n return len(self.conflicting_keys)\\r\\n return key.count(\\\"<none>\\\")\\r\\n\\r\\n if self.ordering is not None:\\r\\n return self.ordering\\r\\n # The correct order is from least exclusives to most exclusives - a target can only depend on\\r\\n # other targets with fewer exclusives than itself.\\r\\n keys_by_empties = [ [] for l in range(len(self.key_to_targets)) ]\\r\\n # Flag to indicate whether there are any groups without any exclusives.\\r\\n no_exclusives = False\\r\\n for k in self.key_to_targets:\\r\\n if k == \\\"<none>\\\":\\r\\n no_exclusives = True\\r\\n else:\\r\\n keys_by_empties[number_of_emptys(k)].append(k)\\r\\n result = [ ]\\r\\n for i in range(len(keys_by_empties)):\\r\\n for j in range(len(keys_by_empties[i])):\\r\\n result.append(keys_by_empties[i][j])\\r\\n if no_exclusives:\\r\\n result.append(\\\"<none>\\\")\\r\\n result.reverse()\\r\\n self.ordering = result\\r\\n return self.ordering\",\n \"def test_priority_order_error_bad_priority(self):\\n test_name = sys._getframe().f_code.co_name\\n rv, output = self._execute('priority remove bad_priority')\\n self.assertEqual(2, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def _get_fabric_priority(self):\\n return self.__fabric_priority\",\n \"def _get_fabric_priority(self):\\n return self.__fabric_priority\",\n \"def _get_fabric_priority(self):\\n return self.__fabric_priority\",\n \"def _get_fabric_priority(self):\\n return self.__fabric_priority\",\n \"def _get_fabric_priority(self):\\n return self.__fabric_priority\",\n \"def _get_fabric_priority(self):\\n return self.__fabric_priority\",\n \"def increase_priority(self):\\n if self._priority > 0:\\n self._priority -= 1\",\n \"def sorting(list_object): # Takes in a ListItem object and returns the\\r\\n # priority value - from w3schools.com\\r\\n return list_object.priority\",\n \"def sort_priors(self):\\n return\",\n \"def sort_group():\\n _id = request.form['_id']\\n old_index = request.form['old_index']\\n new_index = request.form['new_index']\\n data, code, message = FIELD_SERVICE.sort_group(_id, old_index, new_index)\\n return __result(data, code, message)\",\n \"def sort_groups(x, group_order):\\n for i, g in enumerate(group_order):\\n if g == x:\\n return i + 1\",\n \"def _sort_segments_by_weight(self, l_segments):\\n if len(l_segments) < 2:\\n return l_segments\\n\\n l_segments_weights = sorted(\\n [(i, self._calc_weight_of_segment(t_segment[0])) for i, t_segment in enumerate(l_segments)],\\n key=lambda x: x[1], reverse=True)\\n\\n l_segments_sorted = [l_segments[i] for i, _ in l_segments_weights]\\n return l_segments_sorted\",\n \"def __cmp__(self, other):\\n if self.weight > other.weight:\\n return 1\\n elif self.weight < other.weight:\\n return -1\\n else:\\n return 0\",\n \"def effective_priority (self):\\n return self.priority if self.match.is_wildcarded else (1<<16) + 1\",\n \"def sort(self):\\r\\n\\t\\tif ScoreOpt.isGroupVassals():\\r\\n\\t\\t\\tself._playerScores.sort(lambda x, y: cmp(x.sortKey(), y.sortKey()))\\r\\n\\t\\t\\tself._playerScores.reverse()\\r\\n\\t\\tmaxPlayers = ScoreOpt.getMaxPlayers()\\r\\n\\t\\tif maxPlayers > 0 and len(self._playerScores) > maxPlayers:\\r\\n\\t\\t\\tself._playerScores = self._playerScores[len(self._playerScores) - maxPlayers:]\",\n \"def get_sort_priority(self):\\n return self.__sorting_priority\",\n \"def get_priority(self):\\n priority_value = (self.__priority if Priority.IMPORTANCE_RANKING == PriorityRanking.DESCENDING else Priority.MAX_PRIORITY-self.__priority)\\n return 2 * priority_value\",\n \"def _get_priority(self):\\n return self.__priority\",\n \"def _get_priority(self):\\n return self.__priority\",\n \"def _get_priority(self):\\n return self.__priority\",\n \"def _get_priority(self):\\n return self.__priority\",\n \"def _rgroup_sort(r):\\n if r[0] == \\\"R\\\": return (\\\"R\\\", int(r[1:]))\\n return (r, None)\",\n \"def hook_priority(self) -> int:\",\n \"def turn_priority(self):\\n raise NotImplementedError(\\\"turn_priority() was not implemented in a subclass of TurnListItem.\\\")\",\n \"def rank_higher():\\n blueprints = current_app._blueprint_order\\n our_index = None\\n security_index = None\\n\\n for index, bp in enumerate(blueprints):\\n if bp.name == \\\"security\\\":\\n security_index = index\\n if bp.name == \\\"invenio_config_tugraz\\\":\\n our_index = index\\n\\n if (security_index is not None) and (our_index > security_index):\\n temp = blueprints[security_index]\\n blueprints[security_index] = blueprints[our_index]\\n blueprints[our_index] = temp\",\n \"def sort_key(self):\\n ...\",\n \"def part_build_order(self):\\n priority = []\\n for geo_item in self.build_order:\\n if geo_item in self.parts:\\n priority += [geo_item]\\n return priority\",\n \"def thread_priority(self):\\n return _spacegrant_swig.G3RUH_descramble_sptr_thread_priority(self)\",\n \"def reorder( self ):\\n self.sorted.sort(self.compareFunction)\",\n \"def getPriority(self):\\n return self.priority\",\n \"def sort_pkglist(pkgs):\\n # It doesn't matter that ['4.9','4.10'] would be sorted to ['4.10','4.9'],\\n # so long as the sorting is consistent.\\n try:\\n for key in pkgs:\\n # Passing the pkglist to set() also removes duplicate version\\n # numbers (if present).\\n pkgs[key] = sorted(set(pkgs[key]))\\n except AttributeError as exc:\\n log.exception(exc)\",\n \"def set_normal_priority(self, cr, uid, ids, context=None):\\n return self.set_priority(cr, uid, ids, '3')\",\n \"def preference_ordering(self) -> None:\\n for i in self._destinations:\\n self._destinations[i] = sorted(self._destinations[i])\",\n \"def assign_priorities_and_dp(self):\\r\\n taskset_copy = copy(self.taskset)\\r\\n tasks = taskset_copy.sorted_by_crit()\",\n \"def sort_facility(self):\\n self.entries.sort(key=lambda x: x.severity)\\n self.entries.sort(key=lambda x: x.facility)\",\n \"def priority(self):\\n return self._pri\",\n \"def dag_topology_sort(self):\\n mlist = []\\n mod_wrapper = self.mod_wrapper.copy()\\n while mod_wrapper:\\n temp_list = []\\n for mod, wrapper in mod_wrapper.items():\\n if wrapper.is_root_mod():\\n temp_list.append(mod)\\n wrapper.remove_self_from_bindings()\\n\\n for mod in temp_list:\\n mod_wrapper.pop(mod, None)\\n\\n mlist += temp_list\\n\\n mod_wrapper_sort = {}\\n for mod, i in zip(mlist, range(len(mlist))):\\n self.mod_wrapper[mod].set_idx_name(i)\\n mod_wrapper_sort[mod] = self.mod_wrapper[mod]\\n\\n self.mod_wrapper = mod_wrapper_sort\",\n \"def sort():\\n return -1\",\n \"def setPriority(self, p):\\n self.priority = p\",\n \"def _set_group_weight(self, _group):\\n\\n if self.resource.CPU_avail > 0:\\n _group.vCPU_weight = float(_group.vCPUs) / float(self.resource.CPU_avail)\\n else:\\n if _group.vCPUs > 0:\\n _group.vCPU_weight = 1.0\\n else:\\n _group.vCPU_weight = 0.0\\n\\n if self.resource.mem_avail > 0:\\n _group.mem_weight = float(_group.mem) / float(self.resource.mem_avail)\\n else:\\n if _group.mem > 0:\\n _group.mem_weight = 1.0\\n else:\\n _group.mem_weight = 0.0\\n\\n if self.resource.local_disk_avail > 0:\\n _group.local_volume_weight = float(_group.local_volume_size) / float(self.resource.local_disk_avail)\\n else:\\n if _group.local_volume_size > 0:\\n _group.local_volume_weight = 1.0\\n else:\\n _group.local_volume_weight = 0.0\\n\\n for _, sg in _group.subgroups.items():\\n if isinstance(sg, Group):\\n self._set_group_weight(sg)\",\n \"def automorphism_group_order(self):\\n if self.q == 2:\\n return sage.all.factorial(self.L.size()) * (1 + int(self.variant.is_bipartite()))\\n elif self.variant.is_bipartite():\\n return (self.L.size() - 1) * self.d * self.L.size() * (self.K.size() - 1) * 2\\n elif self.variant.is_minus() or self.p == 2:\\n return (self.L.size() - 1) * self.d * self.L.size()\\n else:\\n return (self.L.size() - 1) * self.d\",\n \"def thread_priority(self):\\n return _spacegrant_swig.general_burster_2_sptr_thread_priority(self)\",\n \"def _total_priority(self):\\n return self.nodes[0]\",\n \"def order(self):\\n pairs = [(w['source'][0], w['target'][0]) for w in self.wires]\\n return processing_order(len(self.modules), pairs)\",\n \"def dmc_order(self):\\n return sorted(self.lookup_table, key=lambda clr: int(clr.id) if clr.id.isdigit() else 0)\",\n \"def thread_priority(self):\\n return _spacegrant_swig.invert_bit_sptr_thread_priority(self)\",\n \"def decrease_priority(self):\\n self._priority += 1\",\n \"def priority(self):\\n return self._priority\",\n \"def priority(self):\\n return self._priority\",\n \"def priority(self):\\n return self._priority\",\n \"def sort_with_beam(self, pattern_arr):\\n\\n def _cmp(x, y):\\n \\\"\\\"\\\"Cmp function to sort pattern.\\\"\\\"\\\"\\n if x[1].count > y[1].count:\\n return CmpRelation.GREATER\\n if x[1].count < y[1].count:\\n return CmpRelation.LESS\\n if x[1].ptn_length < y[1].ptn_length:\\n return CmpRelation.GREATER\\n if x[1].ptn_length > y[1].ptn_length:\\n return CmpRelation.LESS\\n return CmpRelation.EQUAL\\n\\n pattern_arr = sorted(pattern_arr.items(), key=functools.cmp_to_key(_cmp),\\n reverse=True)\\n if len(pattern_arr) > self.beam_width:\\n pattern_arr = pattern_arr[:self.beam_width]\\n return OrderedDict(pattern_arr)\",\n \"def _SetCompoundPriorities(self):\\n priority = self._GetMaxCommonPriority()\\n for c in self.reactants:\\n c.compound.SetSpeciesGroupPriority(priority)\",\n \"def _sort_compounds(self):\\n self.sorted_molecules = sorted(self.values(), key=operator.attrgetter('criterion'))\",\n \"def _sorted_groups(self):\\n positional_title = 'positional arguments'\\n optional_title = 'optional arguments'\\n groups = sorted(self._action_groups, key=lambda x: x.title.lower())\\n for group in groups:\\n if group.title == positional_title:\\n yield group\\n break\\n for group in groups:\\n if group.title == optional_title:\\n yield group\\n break\\n for group in groups:\\n if group.title not in [positional_title, optional_title]:\\n yield group\",\n \"def thread_priority(self):\\n return _TestA_swig.cleanslate_sptr_thread_priority(self)\",\n \"def sortby(self):\\n ...\",\n \"def sort_protein_group(pgroup, sortfunctions, sortfunc_index):\\n pgroup_out = []\\n subgroups = sortfunctions[sortfunc_index](pgroup)\\n sortfunc_index += 1\\n for subgroup in subgroups:\\n if len(subgroup) > 1 and sortfunc_index < len(sortfunctions):\\n pgroup_out.extend(sort_protein_group(subgroup,\\n sortfunctions,\\n sortfunc_index))\\n else:\\n pgroup_out.extend(subgroup)\\n return pgroup_out\",\n \"def sort(self): \\n \\n for i in range(0,len(self.tasks)):\\n if len(self.tasks[i].build_block_belong) == 3:\\n self.tree.add_element(self.tasks[i].build_block_belong,i)\",\n \"def test_priority_remove_error_bad_priority(self):\\n test_name = sys._getframe().f_code.co_name\\n rv, output = self._execute('priority remove bad_priority')\\n self.assertEqual(2, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def test_runner_uses_priority(monkeypatch, runner, example_tasks):\\n order = []\\n\\n def _run(self, input_files):\\n print(f'running task {self.name} with priority {self.priority}')\\n order.append(self.priority)\\n return [f'{self.name}_test.nc']\\n\\n monkeypatch.setattr(BaseTask, '_run', _run)\\n monkeypatch.setattr(esmvalcore._task, 'Pool', ThreadPool)\\n\\n runner(example_tasks)\\n print(order)\\n assert len(order) == 12\\n assert order == sorted(order)\",\n \"def priority(node):\\n return node.priority\",\n \"def __cmp__(self, other) :\\n if self.strength > other.strength:\\n return 1;\\n elif self.strength == other.strength :\\n if self.rank > other.rank :\\n return 1;\\n elif self.rank == other.rank :\\n return 1 if self.kickers > other.kickers else -1 if self.kickers < other.kickers else 0;\\n return -1;\",\n \"def priority(self) -> int:\\n return pulumi.get(self, \\\"priority\\\")\",\n \"def sorter(Plugin):\\n return Plugin.order\",\n \"def keysort(predicate_name, predicates_rules):\\n if predicate_name in predicates_rules:\\n if \\\"priority\\\" in predicates_rules[predicate_name]:\\n return predicates_rules[predicate_name][\\\"priority\\\"]\\n else:\\n return 10\\n else:\\n return 10\",\n \"def medium_priority(self):\\n\\n return self.filter(priority='2')\",\n \"def sorting(recommendation: List[Tuple[str, int]]) -> None:\\n \\n for tup in range(len(recommendation)):\\n score = recommendation[tup][1]\\n alpha = recommendation[tup][0]\\n for j in range(tup + 1, len(recommendation)):\\n if recommendation[j][1] > score or \\\\\\n (recommendation[j][1] == score and recommendation[j][0] < alpha):\\n recommendation[j], recommendation[tup] = recommendation[tup], \\\\\\n recommendation[j]\",\n \"def get_priority(self):\\n return False\",\n \"def test_priority_change_error_bad_priority(self):\\n test_name = sys._getframe().f_code.co_name\\n rv, output = self._execute('priority change bad_priority changed_name')\\n self.assertEqual(2, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def test_priority_order_up_ok(self):\\n test_name = sys._getframe().f_code.co_name\\n self._execute('priority order critical up')\\n rv, output = self._execute('priority list')\\n self.assertEqual(0, rv)\\n self.assertEqual(self.expected_results[test_name], output)\",\n \"def sortChoices(self):\\n self.formatList.sort()\",\n \"def _update_ordering(self):\\n self._descendants = sorted(self.unordered_descendants(), key=lambda node: node.ord)\\n for (new_ord, node) in enumerate(self._descendants, 1):\\n node.ord = new_ord\",\n \"def get_priority(self) -> str:\\n if self.health >= 75 and self.food >= 75 and self.water >= 75:\\n if min(self.food, self.water) == self.food:\\n return 'food'\\n else:\\n return 'water'\\n else:\\n if self.food >= 75 and self.water >= 75:\\n return 'monster'\\n else:\\n return 'food'\",\n \"def check_order(racers):\\n racers_orderd = sorted(racers, key=lambda x: (x.group, x.time))\\n a = 1\\n b = 1\\n for r in racers_orderd:\\n if r.group == \\\"ALL\\\":\\n r.rank = str(a)\\n a += 1\\n else:\\n r.rank = str(b)\\n b += 1\\n return racers_orderd\",\n \"def _prioritify(line_of_css, css_props_text_as_list):\\n sorted_css_properties, groups_by_alphabetic_order = css_props_text_as_list\\n priority_integer, group_integer = 9999, 0\\n for css_property in sorted_css_properties:\\n if css_property.lower() == line_of_css.split(\\\":\\\")[0].lower().strip():\\n priority_integer = sorted_css_properties.index(css_property)\\n group_integer = groups_by_alphabetic_order[priority_integer]\\n break\\n return (priority_integer, group_integer)\",\n \"def role_reorder_valid_roles_sort_key(item):\\n return item[1]\",\n \"def test_priority_order_down_ok(self):\\n test_name = sys._getframe().f_code.co_name\\n self._execute('priority order blocker down')\\n rv, output = self._execute('priority list')\\n self.assertEqual(0, rv)\\n self.assertEqual(self.expected_results[test_name], output)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6338274","0.62321174","0.61597615","0.61597615","0.61081684","0.597041","0.58988225","0.587243","0.5862533","0.5848476","0.58239365","0.5780499","0.5731992","0.5679707","0.5672135","0.564723","0.55861855","0.55627245","0.5561452","0.5561452","0.5561066","0.55590045","0.55518645","0.55460817","0.55460817","0.55460817","0.55460817","0.55460817","0.55460817","0.5536194","0.55053705","0.5497217","0.5482956","0.5476519","0.5468861","0.54555166","0.54436636","0.54122525","0.540639","0.53965425","0.53902775","0.53902775","0.53902775","0.53902775","0.5360254","0.53449416","0.5340486","0.5331678","0.5321567","0.5305636","0.5297894","0.52975","0.5296489","0.52888894","0.5275467","0.5228938","0.52102304","0.52071756","0.52011865","0.5194559","0.518809","0.5183156","0.5181432","0.51720697","0.5170165","0.51637435","0.51475775","0.51468325","0.5136679","0.5124882","0.5121825","0.5121825","0.5121825","0.5117338","0.5116186","0.5111068","0.51099163","0.5107899","0.50888455","0.5086588","0.5058948","0.50505","0.5039724","0.5032702","0.5031445","0.50243694","0.50178355","0.50175","0.5016531","0.50073135","0.50058156","0.49985915","0.49962822","0.49961448","0.49933028","0.49923524","0.49857768","0.4982389","0.4976832","0.49711195"],"string":"[\n \"0.6338274\",\n \"0.62321174\",\n \"0.61597615\",\n \"0.61597615\",\n \"0.61081684\",\n \"0.597041\",\n \"0.58988225\",\n \"0.587243\",\n \"0.5862533\",\n \"0.5848476\",\n \"0.58239365\",\n \"0.5780499\",\n \"0.5731992\",\n \"0.5679707\",\n \"0.5672135\",\n \"0.564723\",\n \"0.55861855\",\n \"0.55627245\",\n \"0.5561452\",\n \"0.5561452\",\n \"0.5561066\",\n \"0.55590045\",\n \"0.55518645\",\n \"0.55460817\",\n \"0.55460817\",\n \"0.55460817\",\n \"0.55460817\",\n \"0.55460817\",\n \"0.55460817\",\n \"0.5536194\",\n \"0.55053705\",\n \"0.5497217\",\n \"0.5482956\",\n \"0.5476519\",\n \"0.5468861\",\n \"0.54555166\",\n \"0.54436636\",\n \"0.54122525\",\n \"0.540639\",\n \"0.53965425\",\n \"0.53902775\",\n \"0.53902775\",\n \"0.53902775\",\n \"0.53902775\",\n \"0.5360254\",\n \"0.53449416\",\n \"0.5340486\",\n \"0.5331678\",\n \"0.5321567\",\n \"0.5305636\",\n \"0.5297894\",\n \"0.52975\",\n \"0.5296489\",\n \"0.52888894\",\n \"0.5275467\",\n \"0.5228938\",\n \"0.52102304\",\n \"0.52071756\",\n \"0.52011865\",\n \"0.5194559\",\n \"0.518809\",\n \"0.5183156\",\n \"0.5181432\",\n \"0.51720697\",\n \"0.5170165\",\n \"0.51637435\",\n \"0.51475775\",\n \"0.51468325\",\n \"0.5136679\",\n \"0.5124882\",\n \"0.5121825\",\n \"0.5121825\",\n \"0.5121825\",\n \"0.5117338\",\n \"0.5116186\",\n \"0.5111068\",\n \"0.51099163\",\n \"0.5107899\",\n \"0.50888455\",\n \"0.5086588\",\n \"0.5058948\",\n \"0.50505\",\n \"0.5039724\",\n \"0.5032702\",\n \"0.5031445\",\n \"0.50243694\",\n \"0.50178355\",\n \"0.50175\",\n \"0.5016531\",\n \"0.50073135\",\n \"0.50058156\",\n \"0.49985915\",\n \"0.49962822\",\n \"0.49961448\",\n \"0.49933028\",\n \"0.49923524\",\n \"0.49857768\",\n \"0.4982389\",\n \"0.4976832\",\n \"0.49711195\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6633872"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80299,"cells":{"query":{"kind":"string","value":"Returns all supported representation values that can be mapped to a valid status."},"document":{"kind":"string","value":"def allowed(cls):\n # type: () -> List[Str]\n names = cls.names()\n allowed = names\n allowed.extend([name.lower() for name in names])\n return allowed"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def valid_statuses(self):\n return [\n \"dish_maintenance\",\n \"dish_ok\",\n \"RF_maintenance\",\n \"RF_ok\",\n \"digital_maintenance\",\n \"digital_ok\",\n \"calibration_maintenance\",\n \"calibration_ok\",\n \"calibration_triage\",\n ]","def getStatusValues(self):\n return []","def status_enum(self):\n return self.valid_statuses()","def available_statuses(self):\n return self.pipeline.get(self.status, ())","def available_statuses(self):\n return self.pipeline.get(self.status, ())","def all_status_strings(cls):\n return [info[1] for info in cls._STATUS_INFO]","def get_all_status():\n return \"\"","def status() -> Dict[str, Any]:","def availableValues(self):\n return [x.name for x in self._field.enum_type.values]","def old_statuses(self):\n return [\"passed_checks\", \"needs_checking\", \"known_bad\", \"not_connected\"]","async def get_status(self) -> dict[str, Any]:\n\n def check_int(s):\n if s[0] in (\"-\", \"+\"):\n return s[1:].isdigit()\n return s.isdigit()\n\n cmd = await self.send_command(\"STATUS\", timeout=1)\n if not cmd.succeeded():\n raise ArchonError(f\"Command finished with status {cmd.status.name!r}\")\n\n keywords = str(cmd.replies[0].reply).split()\n status = {\n key.lower(): int(value) if check_int(value) else float(value)\n for (key, value) in map(lambda k: k.split(\"=\"), keywords)\n }\n\n return status","def read_all_status_characters(self):\n return self.STATUS_CHARACTERS","def get_status():\n return ('off', 'off')","def valid() -> List[str]:\n return [\n AssignmentState.CREATED,\n AssignmentState.LAUNCHED,\n AssignmentState.ASSIGNED,\n AssignmentState.COMPLETED,\n AssignmentState.ACCEPTED,\n AssignmentState.MIXED,\n AssignmentState.REJECTED,\n AssignmentState.SOFT_REJECTED,\n AssignmentState.EXPIRED,\n ]","def all_statuses(cls):\n return list(cls.pipeline.keys())","def all_statuses(cls):\n return list(cls.pipeline.keys())","def status(self):\n return {\n 'hawkular_services': self._hawkular.status(),\n 'alerts': self.alert.status(),\n 'inventory': self.inventory.status(),\n 'metrics': self.metric.status()\n }","def get_all(self) -> List[Status]:\n return self.__mapper.map_all(\n self.__repository.get_all(),\n Status\n )","def _get_status(self):\n\t\tstatus_list = []\n\t\tfor hand in self.player_hand:\n\t\t\tif hand.value > 21:\n\t\t\t\tstatus_list.append('lost')\n\t\t\telif hand.value == 21 \\\n\t\t\t\t\tand len(hand.cards) == 2 \\\n\t\t\t\t\tand not(self.dealer_hand[0].value == 21 and len(self.dealer_hand[0].cards) == 2):\n\t\t\t\tstatus_list.append('blackjack')\n\t\t\telif self.dealer_hand[0].value > 21:\n\t\t\t\tstatus_list.append('won')\n\t\t\telif hand.value > self.dealer_hand[0].value:\n\t\t\t\tstatus_list.append('won')\n\t\t\telif hand.value == self.dealer_hand[0].value:\n\t\t\t\tstatus_list.append('push')\n\t\t\telse:\n\t\t\t\tstatus_list.append('lost')\n\t\treturn status_list","def get_status(pos, neg, names):\n status = {}\n for i in names:\n #print str(i) +'\\n'+ str(pos) +'\\n'+ str(neg)+'\\n'+'\\n'\n if i in pos:\n status[i] = \"1\"\n elif i in neg:\n status[i] = \"0\"\n else:\n status[i] = \"NA\"\n return status","def status():\n statuses = get_all_statuses()\n return json.dumps(statuses, indent=4)","def _quality_status_type():\n return {\n 'name' : 'quality_status_type',\n 'is_open' : False,\n 'doc' : None,\n 'members' : [\n ('reported', None),\n ('confirmed', None),\n ('partially_resolved', None),\n ('resolved', None),\n ],\n }","def get_statuses(self):\n return self.statuses","def status(self):\n r = requests.get('/'.join([self.base_url, self.ENDPOINT_STATUS]))\n return r.json()","def enums(self):\n return self._enums","def valid_values(self):\n\n return self._get_value(self.valid_values_provider)","def _getCurrentComponentStatus(self):\n resOverall = self.sysAdminClient.getOverallStatus()\n if not resOverall['OK']:\n return resOverall\n currentStatus = {'Down': set(), 'Run': set(), 'All': set()}\n informationDict = resOverall['Value']\n for systemsDict in informationDict.values():\n for system, instancesDict in systemsDict.items():\n for instanceName, instanceInfoDict in instancesDict.items():\n identifier = '%s__%s' % (system, instanceName)\n runitStatus = instanceInfoDict.get('RunitStatus')\n if runitStatus in ('Run', 'Down'):\n currentStatus[runitStatus].add(identifier)\n\n currentStatus['All'] = currentStatus['Run'] | currentStatus['Down']\n return S_OK(currentStatus)","def get_status(self):\n return [not colors.same_color(color, colors.to_rgba(\"none\"))\n for color in self._checks.get_facecolors()]","def _get_info(self):\n\n info = {}\n if self.field is not None and self.field.check_not_in_enum is not None:\n info.update(not_in_enum=self.field.check_not_in_enum.options(),\n not_in_enum_lookup=self.field.check_not_in_enum.to_dict())\n\n elif self.invalid_values_provider is not None and \\\n not callable(self.invalid_values_provider):\n info.update(not_in_enum=dict_utils.create_options(self.invalid_values),\n not_in_enum_lookup=dict_utils.create_dict(self.invalid_values))\n\n base_info = super()._get_info()\n if base_info:\n info.update(base_info)\n\n return info","def _getDefaultComponentStatus(self):\n host = socket.gethostname()\n defaultStatus = {'Down': set(), 'Run': set(), 'All': set()}\n resRunning = gConfig.getOptionsDict(os.path.join('/Registry/Hosts/', host, 'Running'))\n resStopped = gConfig.getOptionsDict(os.path.join('/Registry/Hosts/', host, 'Stopped'))\n if not resRunning['OK']:\n return resRunning\n if not resStopped['OK']:\n return resStopped\n defaultStatus['Run'] = set(resRunning['Value'].keys())\n defaultStatus['Down'] = set(resStopped['Value'].keys())\n defaultStatus['All'] = defaultStatus['Run'] | defaultStatus['Down']\n\n if defaultStatus['Run'].intersection(defaultStatus['Down']):\n self.logError(\"Overlap in configuration\", str(defaultStatus['Run'].intersection(defaultStatus['Down'])))\n return S_ERROR(\"Bad host configuration\")\n\n return S_OK(defaultStatus)","def translate_from_rpc(rpc_enum_value):\n return {\n 0: StatusText.StatusType.INFO,\n 1: StatusText.StatusType.WARNING,\n 2: StatusText.StatusType.CRITICAL,\n }.get(rpc_enum_value, None)","def get_book_statuses() -> list:\n return data.get_book_statuses()","def status(self):\n status = {\n 'driver':self.driver.status,\n 'arduino':self.arduino.status,\n 'sensors':[]}\n\n for name, sensor in self.sensors.items():\n sensor_status = sensor.status\n sensor_status['name'] = name\n status['sensors'].append(sensor_status)\n\n return status","def get_status_data():\n\n return dict(\n celery=_get_celery_status(),\n users=_get_users_stats(),\n daemons=_get_daemons_status(),\n settings=_get_settings(),\n files=_get_files_status(),\n languages=_get_languages_status(),\n sets=_get_sets_status(),\n )","def status(self):\n\n # --- get 0 padded string representation of status register\n response = self.send_lens_cmd(['90', 'B9', '00'], fast_mode=True)\n state_str = bin(int('0x' + response['MISO'][2], 16))\n state_str = state_str[2:]\n for p in range(8 - len(state_str)):\n state_str = '0' + state_str\n\n self._status = dict(AF_switch=bool(int(state_str[0])),\n F_move=bool(int(state_str[5])),\n F_acc=bool(int(state_str[2])),\n FD_endStop=bool(int(state_str[3])),\n status_byte=state_str)\n\n return self._status","def get_status(self):\n request_format = \"{oscillating:01d} {initialising:01d} {initialised:01d} {width:03d} \" \\\n \"{offset:+04d} {speed:02d} {acceleration:03d} {cycles:05d} {backlash:03d}\"\n status_string = request_format.format(\n oscillating=int(self.device.is_oscillating()),\n initialising=int(self.device.is_initialising()),\n initialised=int(self.device.has_been_initialised()),\n width=int(self.device.get_window_width()),\n offset=int(self.device.get_offset()),\n speed=int(self.device.get_speed()),\n acceleration=int(self.device.get_acceleration()),\n cycles=int(self.device.get_complete_cycles()),\n backlash=int(self.device.get_backlash())\n )\n return status_string","def status(self) -> dict[str, str] | None:\n return self._status","def status(self):\n return STATUS[self.fields['status']]","def get_grading_status_list(self, *args, **kwargs):\r\n return {\r\n \"version\": 1,\r\n \"problem_list\": [\r\n {\r\n \"problem_name\": \"Test1\",\r\n \"grader_type\": \"IN\",\r\n \"eta_available\": True,\r\n \"state\": \"Finished\",\r\n \"eta\": 259200,\r\n \"location\": \"i4x://edX/open_ended/combinedopenended/SampleQuestion1Attempt\"\r\n },\r\n {\r\n \"problem_name\": \"Test2\",\r\n \"grader_type\": \"NA\",\r\n \"eta_available\": True,\r\n \"state\": \"Waiting to be Graded\",\r\n \"eta\": 259200,\r\n \"location\": \"i4x://edX/open_ended/combinedopenended/SampleQuestion\"\r\n },\r\n {\r\n \"problem_name\": \"Test3\",\r\n \"grader_type\": \"PE\",\r\n \"eta_available\": True,\r\n \"state\": \"Waiting to be Graded\",\r\n \"eta\": 259200,\r\n \"location\": \"i4x://edX/open_ended/combinedopenended/SampleQuestion454\"\r\n },\r\n ],\r\n \"success\": True\r\n }","def get_response_serializers(self):\n manual_responses = self.overrides.get('responses', None) or {}\n manual_responses = OrderedDict((str(sc), resp) for sc, resp in manual_responses.items())\n\n responses = {}\n if not any(is_success(int(sc)) for sc in manual_responses if sc != 'default'):\n responses = self.get_default_responses()\n\n responses.update((str(sc), resp) for sc, resp in manual_responses.items())\n return responses","def status_feedback(self):\n return {\n TAG_ADDRESS: self.address,\n ATTR_STATUS: self._status,\n ATTR_INIT: self._init,\n ATTR_PRECISION: self._prec,\n ATTR_TS: self._last_edited,\n ATTR_LAST_CHANGED: self._last_changed,\n ATTR_LAST_UPDATE: self._last_update,\n }","def status_get(): # noqa: E501\n db = get_db()\n return [{'id': sample, 'status': db['samples'][sample]['status']} for sample in db['samples'].keys()]","def __iter__(self):\n return iter(self._enums)","def get_status(self):\n return dict(CAMPAIGN_STATUS_CHOICES).get(self.status, \"N/A\")","def handle_enum(enum_annotations: Any) -> list:\n result = []\n for attribute in list(enum_annotations):\n result.append(attribute.value)\n return result","def statuses(self):\n big = BigCommerceAPI()\n response = big.get('orderstatuses')\n return response.text","def award_status_populator():\n award_status_list = funding_data[\"Project Status:\"].unique()\n return [{'label': i, 'value': i} for i in award_status_list]","def getStatus():","def fallback_status_codes(self) -> pulumi.Output[Optional[Sequence[str]]]:\n return pulumi.get(self, \"fallback_status_codes\")","def get_sorted_equipment_status(self):\n\n equipment_fields = [\n \"gas_burner_primus\",\n \"axe\",\n \"hammer\",\n \"saw\",\n \"saw_blade\",\n \"saw_bench\",\n \"spade\",\n \"kerosene_lamp\",\n \"detergent\",\n \"dishware\",\n \"cookware\",\n \"cabin_book\",\n \"candle_holders\",\n \"fire_blanket\",\n \"fire_extinguisher\",\n ]\n\n equipment_status = {\"0\": [], \"1\": [], \"2\": []}\n\n for field_name in equipment_fields:\n value = getattr(self, field_name, None)\n equipment_status[str(value)].append(field_name)\n\n return equipment_status","def get_resource_state():\n output = [f'{\"S. No.\":6}\\t{\"Resource\":50}\\t{\"Health State\":12}\\t{\"Reason\":100}\\n']\n\n for index, resource in enumerate(HEALTH_AGGREGATOR.resource_state):\n output.append(\n f'{index + 1:<6}\\t{resource:<50}\\t'\n f'{\"Healthy\" if HEALTH_AGGREGATOR.resource_state[resource][\"is_healthy\"] else \"Unhealthy\":<12}\\t'\n f'{HEALTH_AGGREGATOR.resource_state[resource][\"reason\"]:<100}\\n'\n )\n\n return Response('\\n'.join(output), 200, mimetype='text/plain')","def formats(self):\n logger.debug(\"Get formats\")\n return self._raw_api.formats.get()","def get_status(self):\n r = requests.get(self.base_url + '/status')\n return r.json()","async def device_status(self, value):\n if value is None:\n return\n \n binvalue = str(bin(value))\n binarr = binvalue[::-1]\n binarr = binarr[:len(DEVICE_STATUS)]\n return_value = []\n for x in range(len(DEVICE_STATUS)):\n if binarr[len(binarr) - 1 - x] == \"1\":\n return_value.append(DEVICE_STATUS[x])\n\n return return_value","def getAllStatus(self) -> DataFrame:\n return self.writer.getAllStatus()","def status_list(maj_status, min_status, status_type=C.GSS_C_GSS_CODE, mech_type=C.GSS_C_NO_OID):\n from .oids import OID\n\n statuses = []\n message_context = ffi.new('OM_uint32[1]')\n minor_status = ffi.new('OM_uint32[1]')\n\n if isinstance(mech_type, OID):\n mech_type = ffi.addressof(mech_type._oid) # OID._oid is type \"struct gss_OID_desc\"\n elif mech_type == C.GSS_C_NO_OID:\n mech_type = ffi.cast('gss_OID', C.GSS_C_NO_OID)\n elif not isinstance(mech_type, ffi.CData) or ffi.typeof(mech_type) != ffi.typeof('gss_OID'):\n raise TypeError(\n \"Expected mech_type to be a gssapi.oids.OID or gss_OID, got {0}\".format(type(mech_type))\n )\n\n while True:\n status_buf = ffi.new('gss_buffer_desc[1]')\n\n try:\n retval = C.gss_display_status(\n minor_status,\n maj_status,\n status_type,\n mech_type,\n message_context,\n status_buf\n )\n if retval == C.GSS_S_COMPLETE:\n statuses.append(\"({0}) {1}.\".format(\n maj_status,\n _buf_to_str(status_buf[0]).decode(\"utf-8\", errors=\"replace\")\n ))\n elif retval == C.GSS_S_BAD_MECH:\n statuses.append(\"Unsupported mechanism type passed to GSSException\")\n break\n elif retval == C.GSS_S_BAD_STATUS:\n statuses.append(\"Unrecognized status value passed to GSSException\")\n break\n finally:\n C.gss_release_buffer(minor_status, status_buf)\n\n if message_context[0] == 0:\n break\n\n if min_status:\n minor_status_msgs = status_list(min_status, 0, C.GSS_C_MECH_CODE, mech_type)\n if minor_status_msgs:\n statuses.append(\"Minor code:\")\n statuses.extend(minor_status_msgs)\n return statuses","def _get_errortypes_params(error_types):\n return {et: \"1\" for et in error_types}","def getStatus():\n return json.dumps({'camera': Camera.status(), 'rover': rover.status()}), 200","def _GetStatusFromOp(op):\n for prop in op.response.additionalProperties:\n if prop.key == 'status':\n return prop.value.string_value\n return 'UNKNOWN'","def getInfoOnStatus(self):\n raise NotImplementedError();","def status(self) -> str:\n return self._search_in_description(REGEXP_ATTR_STATUS)","def _get_status(self, context, object_list=None):\n status = self.request.GET.get(\"status\", \"\").upper()\n\n if object_list is not None:\n return self._get_object_list(\n object_list, status != \"\" and JobStatus.is_member(status), status=status\n )\n\n options = list(map(lambda s: (s.name, s.value), JobStatus))\n\n return {\n **context,\n \"status_options\": sorted(options, key=lambda x: x[0]),\n \"status\": status,\n }","def test__validate_status__0():\n for input_value, expected_output in (\n (ScheduledEventStatus.active, ScheduledEventStatus.active),\n (ScheduledEventStatus.active.value, ScheduledEventStatus.active)\n ):\n output = validate_status(input_value)\n vampytest.assert_is(output, expected_output)","def status_info(self):\n def subdevice_filter(info):\n return bool(info['kind'] & Kind.normal)\n\n return ophydobj_info(self, subdevice_filter=subdevice_filter)","async def fetch_status(self, params={}):\n #\n # [1] # operative\n # [0] # maintenance\n #\n response = await self.publicGetPlatformStatus(params)\n statusRaw = self.safe_string(response, 0)\n return {\n 'status': self.safe_string({'0': 'maintenance', '1': 'ok'}, statusRaw, statusRaw),\n 'updated': None,\n 'eta': None,\n 'url': None,\n 'info': response,\n }","def get_container_statuses(self):\n return {c['id']: c['state'] for c in self.get_containers()}","def _get_info(self):\n\n info = {}\n if self.field is not None and self.field.check_in_enum is not None:\n info.update(in_enum=self.field.check_in_enum.options(),\n in_enum_lookup=self.field.check_in_enum.to_dict())\n\n elif self.valid_values_provider is not None and \\\n not callable(self.valid_values_provider):\n info.update(in_enum=dict_utils.create_options(self.valid_values),\n in_enum_lookup=dict_utils.create_dict(self.valid_values))\n\n base_info = super()._get_info()\n if base_info:\n info.update(base_info)\n\n return info","def states(self) -> Type[Any]:\n return []","def tpn_valid_values(self):\n return self.get_valid_values_map()","def get_labels():\n return {\"contradiction\": 0, \"neutral\": 1, \"entailment\": 2}","def status(self):\n return status_dict[self._get_property_(self.STATUS).upper()]","def statuses(self):\n return self._get_paged(\"statuses\")","def formats(self):\n return self._map.keys()","def as_base_types(self) -> Dict[Text, Any]:\n running_phase_state = None\n if self.running_phase_state:\n running_phase_state = self.running_phase_state.as_base_types()\n return {\n 'status': data.convert_to_base_types(self._status),\n 'test_record': self.test_record.as_base_types(),\n 'plugs': self.plug_manager.as_base_types(),\n 'running_phase_state': running_phase_state,\n }","def json_statuslist():\n statuses = Status.query.all()\n out = {'statuses': []}\n for status in statuses:\n out['statuses'].append(status.value)\n\n return jsonify(out)","def _filter_resources_by_status(self, resources: [], statuses: []):\n all_resources = []\n for resource in resources:\n if statuses:\n status = ResourceModel.Status.from_string(resource.status)\n if status in statuses:\n all_resources.append(resource)\n else:\n all_resources.append(resource)\n return all_resources","def _cls_repr(self):\n prefixes = []\n for name, invert in ( ('enable', False), ('disable', True) ):\n states = self._getEnabled(nondefault=False,\n invert=invert)\n if len(states):\n prefixes.append(\"%s_states=%s\" % (name, str(states)))\n return prefixes","def check_status(self) -> Mapping[str, bool]:\n ups_stat = {}\n for name in self.ups_names:\n ups_stat[name] = self.check_ups(name)\n return ups_stat","def getValidations(self):\n return self.objectValues('InstrumentValidation')","def status(self):\n if isinstance(self.attrs['State'], dict):\n return self.attrs['State']['Status']\n return self.attrs['State']","def _serialize_event_status(event, messages):\n if event.status == MessagingEvent.STATUS_COMPLETED:\n if event.xforms_session_id:\n return event.xforms_session.status_slug\n if any(message[\"status\"] == SMS.STATUS_ERROR for message in messages):\n return SMS.STATUS_ERROR # mark event status as 'error' if any messages errored\n return MessagingEvent.STATUS_SLUGS.get(event.status, 'unknown')","def device_state_attributes(self):\n tmp = self._boiler.__dict__.items()\n return {'status': {k: v for k, v in tmp if k in GH_STATE_ATTRS}}","def _serialize(self, data: Any) -> Dict[Any, Any]:\n\n return {field: value.value if isinstance(value, Enum) else value for field, value in data}","def value_items(self):\n if self._parent:\n return [ WARP_MODE_NAMES[x] for x in self._parent.available_warp_modes ]\n return ()","def valid_unit() -> List[str]:\n return [\n AssignmentState.CREATED,\n AssignmentState.LAUNCHED,\n AssignmentState.ASSIGNED,\n AssignmentState.COMPLETED,\n AssignmentState.ACCEPTED,\n AssignmentState.REJECTED,\n AssignmentState.SOFT_REJECTED,\n AssignmentState.EXPIRED,\n ]","def status_determine():\n b_status = False\n b_statusInput = True\n b_statusAnalyze = True\n b_statusOutput = True\n nonlocal dret_inputSet\n nonlocal dret_analyze\n nonlocal dret_outputSet\n nonlocal fn_inputReadCallback\n nonlocal fn_analysisCallback\n nonlocal fn_outputWriteCallback\n\n if fn_inputReadCallback:\n if 'status' in dret_inputSet.keys():\n b_statusInput = dret_inputSet['status']\n if fn_analysisCallback:\n if 'status' in dret_analyze.keys():\n b_statusAnalyze = dret_analyze['status']\n if fn_outputWriteCallback:\n if 'status' in dret_outputSet.keys():\n b_statusOutput = dret_outputSet['status']\n\n b_status = b_statusInput and b_statusAnalyze and b_statusOutput\n return {\n 'status': b_status\n }","def enum(self):\r\n raise NotImplementedError","def applicable_job_statuses(self):\n return self._applicable_job_statuses","def get_response_serializers(self):\n responses = OrderedDict({\n '400': 'Invalid arguments',\n '401': 'Not authenticated',\n '403': \"You don't have access to do this operation on this company\",\n 'error': ErrorSerializer,\n })\n\n responses.update(super().get_response_serializers())\n\n return responses","def build_expected_system_labels_response(self):\n labels = [\n {\n \"key\": \"name\",\n \"value\": \"appName\"\n },\n {\n \"key\": \"boolean_value\",\n \"value\": \"False\"\n },\n {\n \"key\": \"list_name\",\n \"value\": \"a\"\n },\n {\n \"key\": \"list_name\",\n \"value\": \"b\"\n },\n {\n \"key\": \"list_name\",\n \"value\": \"c\"\n }\n ]\n return labels","def get_status(self):\n return [l1.get_visible() for (l1, l2) in self.lines]","def rights_status(self):\n return {uri: dict(name=name,\n open_access=(uri in RightsStatus.OPEN_ACCESS),\n allows_derivatives=(uri in RightsStatus.ALLOWS_DERIVATIVES))\n for uri, name in list(RightsStatus.NAMES.items())}","def fallback_status_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"fallback_status_codes\")","def fallback_status_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\n return pulumi.get(self, \"fallback_status_codes\")","def value_specs(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:\n return pulumi.get(self, \"value_specs\")","def badges(self):\n for test_type, status_getter in [('image', image_status_msg), ('hash', hash_status_msg)]:\n status = getattr(self, f'{test_type}_status')\n if (\n (status == 'missing') or\n (self.status == 'failed' and status == 'match') or\n (self.status == 'passed' and status == 'diff')\n ): # Only show if different to overall status\n yield {'status': status, 'svg': test_type, 'tooltip': status_getter(status)}","def _get_field_enum_info(cls):\n return {}","def health_check_codes(self) -> Sequence[str]:\n return pulumi.get(self, \"health_check_codes\")","def state_info_specs(self):\n return list()","def status_json():\n status_map = {key : service.current() for key, service in SERVICES.items()}\n return jsonify({\n \"statuses\": [{\"key\": key, \"status\": item[0], \"health\": str(item[1])} for key, item in status_map.items()]\n })","def test_validation_get_valid_formats(self):\n self.assertIsInstance(api.validation.fetch_formats(), dict)"],"string":"[\n \"def valid_statuses(self):\\n return [\\n \\\"dish_maintenance\\\",\\n \\\"dish_ok\\\",\\n \\\"RF_maintenance\\\",\\n \\\"RF_ok\\\",\\n \\\"digital_maintenance\\\",\\n \\\"digital_ok\\\",\\n \\\"calibration_maintenance\\\",\\n \\\"calibration_ok\\\",\\n \\\"calibration_triage\\\",\\n ]\",\n \"def getStatusValues(self):\\n return []\",\n \"def status_enum(self):\\n return self.valid_statuses()\",\n \"def available_statuses(self):\\n return self.pipeline.get(self.status, ())\",\n \"def available_statuses(self):\\n return self.pipeline.get(self.status, ())\",\n \"def all_status_strings(cls):\\n return [info[1] for info in cls._STATUS_INFO]\",\n \"def get_all_status():\\n return \\\"\\\"\",\n \"def status() -> Dict[str, Any]:\",\n \"def availableValues(self):\\n return [x.name for x in self._field.enum_type.values]\",\n \"def old_statuses(self):\\n return [\\\"passed_checks\\\", \\\"needs_checking\\\", \\\"known_bad\\\", \\\"not_connected\\\"]\",\n \"async def get_status(self) -> dict[str, Any]:\\n\\n def check_int(s):\\n if s[0] in (\\\"-\\\", \\\"+\\\"):\\n return s[1:].isdigit()\\n return s.isdigit()\\n\\n cmd = await self.send_command(\\\"STATUS\\\", timeout=1)\\n if not cmd.succeeded():\\n raise ArchonError(f\\\"Command finished with status {cmd.status.name!r}\\\")\\n\\n keywords = str(cmd.replies[0].reply).split()\\n status = {\\n key.lower(): int(value) if check_int(value) else float(value)\\n for (key, value) in map(lambda k: k.split(\\\"=\\\"), keywords)\\n }\\n\\n return status\",\n \"def read_all_status_characters(self):\\n return self.STATUS_CHARACTERS\",\n \"def get_status():\\n return ('off', 'off')\",\n \"def valid() -> List[str]:\\n return [\\n AssignmentState.CREATED,\\n AssignmentState.LAUNCHED,\\n AssignmentState.ASSIGNED,\\n AssignmentState.COMPLETED,\\n AssignmentState.ACCEPTED,\\n AssignmentState.MIXED,\\n AssignmentState.REJECTED,\\n AssignmentState.SOFT_REJECTED,\\n AssignmentState.EXPIRED,\\n ]\",\n \"def all_statuses(cls):\\n return list(cls.pipeline.keys())\",\n \"def all_statuses(cls):\\n return list(cls.pipeline.keys())\",\n \"def status(self):\\n return {\\n 'hawkular_services': self._hawkular.status(),\\n 'alerts': self.alert.status(),\\n 'inventory': self.inventory.status(),\\n 'metrics': self.metric.status()\\n }\",\n \"def get_all(self) -> List[Status]:\\n return self.__mapper.map_all(\\n self.__repository.get_all(),\\n Status\\n )\",\n \"def _get_status(self):\\n\\t\\tstatus_list = []\\n\\t\\tfor hand in self.player_hand:\\n\\t\\t\\tif hand.value > 21:\\n\\t\\t\\t\\tstatus_list.append('lost')\\n\\t\\t\\telif hand.value == 21 \\\\\\n\\t\\t\\t\\t\\tand len(hand.cards) == 2 \\\\\\n\\t\\t\\t\\t\\tand not(self.dealer_hand[0].value == 21 and len(self.dealer_hand[0].cards) == 2):\\n\\t\\t\\t\\tstatus_list.append('blackjack')\\n\\t\\t\\telif self.dealer_hand[0].value > 21:\\n\\t\\t\\t\\tstatus_list.append('won')\\n\\t\\t\\telif hand.value > self.dealer_hand[0].value:\\n\\t\\t\\t\\tstatus_list.append('won')\\n\\t\\t\\telif hand.value == self.dealer_hand[0].value:\\n\\t\\t\\t\\tstatus_list.append('push')\\n\\t\\t\\telse:\\n\\t\\t\\t\\tstatus_list.append('lost')\\n\\t\\treturn status_list\",\n \"def get_status(pos, neg, names):\\n status = {}\\n for i in names:\\n #print str(i) +'\\\\n'+ str(pos) +'\\\\n'+ str(neg)+'\\\\n'+'\\\\n'\\n if i in pos:\\n status[i] = \\\"1\\\"\\n elif i in neg:\\n status[i] = \\\"0\\\"\\n else:\\n status[i] = \\\"NA\\\"\\n return status\",\n \"def status():\\n statuses = get_all_statuses()\\n return json.dumps(statuses, indent=4)\",\n \"def _quality_status_type():\\n return {\\n 'name' : 'quality_status_type',\\n 'is_open' : False,\\n 'doc' : None,\\n 'members' : [\\n ('reported', None),\\n ('confirmed', None),\\n ('partially_resolved', None),\\n ('resolved', None),\\n ],\\n }\",\n \"def get_statuses(self):\\n return self.statuses\",\n \"def status(self):\\n r = requests.get('/'.join([self.base_url, self.ENDPOINT_STATUS]))\\n return r.json()\",\n \"def enums(self):\\n return self._enums\",\n \"def valid_values(self):\\n\\n return self._get_value(self.valid_values_provider)\",\n \"def _getCurrentComponentStatus(self):\\n resOverall = self.sysAdminClient.getOverallStatus()\\n if not resOverall['OK']:\\n return resOverall\\n currentStatus = {'Down': set(), 'Run': set(), 'All': set()}\\n informationDict = resOverall['Value']\\n for systemsDict in informationDict.values():\\n for system, instancesDict in systemsDict.items():\\n for instanceName, instanceInfoDict in instancesDict.items():\\n identifier = '%s__%s' % (system, instanceName)\\n runitStatus = instanceInfoDict.get('RunitStatus')\\n if runitStatus in ('Run', 'Down'):\\n currentStatus[runitStatus].add(identifier)\\n\\n currentStatus['All'] = currentStatus['Run'] | currentStatus['Down']\\n return S_OK(currentStatus)\",\n \"def get_status(self):\\n return [not colors.same_color(color, colors.to_rgba(\\\"none\\\"))\\n for color in self._checks.get_facecolors()]\",\n \"def _get_info(self):\\n\\n info = {}\\n if self.field is not None and self.field.check_not_in_enum is not None:\\n info.update(not_in_enum=self.field.check_not_in_enum.options(),\\n not_in_enum_lookup=self.field.check_not_in_enum.to_dict())\\n\\n elif self.invalid_values_provider is not None and \\\\\\n not callable(self.invalid_values_provider):\\n info.update(not_in_enum=dict_utils.create_options(self.invalid_values),\\n not_in_enum_lookup=dict_utils.create_dict(self.invalid_values))\\n\\n base_info = super()._get_info()\\n if base_info:\\n info.update(base_info)\\n\\n return info\",\n \"def _getDefaultComponentStatus(self):\\n host = socket.gethostname()\\n defaultStatus = {'Down': set(), 'Run': set(), 'All': set()}\\n resRunning = gConfig.getOptionsDict(os.path.join('/Registry/Hosts/', host, 'Running'))\\n resStopped = gConfig.getOptionsDict(os.path.join('/Registry/Hosts/', host, 'Stopped'))\\n if not resRunning['OK']:\\n return resRunning\\n if not resStopped['OK']:\\n return resStopped\\n defaultStatus['Run'] = set(resRunning['Value'].keys())\\n defaultStatus['Down'] = set(resStopped['Value'].keys())\\n defaultStatus['All'] = defaultStatus['Run'] | defaultStatus['Down']\\n\\n if defaultStatus['Run'].intersection(defaultStatus['Down']):\\n self.logError(\\\"Overlap in configuration\\\", str(defaultStatus['Run'].intersection(defaultStatus['Down'])))\\n return S_ERROR(\\\"Bad host configuration\\\")\\n\\n return S_OK(defaultStatus)\",\n \"def translate_from_rpc(rpc_enum_value):\\n return {\\n 0: StatusText.StatusType.INFO,\\n 1: StatusText.StatusType.WARNING,\\n 2: StatusText.StatusType.CRITICAL,\\n }.get(rpc_enum_value, None)\",\n \"def get_book_statuses() -> list:\\n return data.get_book_statuses()\",\n \"def status(self):\\n status = {\\n 'driver':self.driver.status,\\n 'arduino':self.arduino.status,\\n 'sensors':[]}\\n\\n for name, sensor in self.sensors.items():\\n sensor_status = sensor.status\\n sensor_status['name'] = name\\n status['sensors'].append(sensor_status)\\n\\n return status\",\n \"def get_status_data():\\n\\n return dict(\\n celery=_get_celery_status(),\\n users=_get_users_stats(),\\n daemons=_get_daemons_status(),\\n settings=_get_settings(),\\n files=_get_files_status(),\\n languages=_get_languages_status(),\\n sets=_get_sets_status(),\\n )\",\n \"def status(self):\\n\\n # --- get 0 padded string representation of status register\\n response = self.send_lens_cmd(['90', 'B9', '00'], fast_mode=True)\\n state_str = bin(int('0x' + response['MISO'][2], 16))\\n state_str = state_str[2:]\\n for p in range(8 - len(state_str)):\\n state_str = '0' + state_str\\n\\n self._status = dict(AF_switch=bool(int(state_str[0])),\\n F_move=bool(int(state_str[5])),\\n F_acc=bool(int(state_str[2])),\\n FD_endStop=bool(int(state_str[3])),\\n status_byte=state_str)\\n\\n return self._status\",\n \"def get_status(self):\\n request_format = \\\"{oscillating:01d} {initialising:01d} {initialised:01d} {width:03d} \\\" \\\\\\n \\\"{offset:+04d} {speed:02d} {acceleration:03d} {cycles:05d} {backlash:03d}\\\"\\n status_string = request_format.format(\\n oscillating=int(self.device.is_oscillating()),\\n initialising=int(self.device.is_initialising()),\\n initialised=int(self.device.has_been_initialised()),\\n width=int(self.device.get_window_width()),\\n offset=int(self.device.get_offset()),\\n speed=int(self.device.get_speed()),\\n acceleration=int(self.device.get_acceleration()),\\n cycles=int(self.device.get_complete_cycles()),\\n backlash=int(self.device.get_backlash())\\n )\\n return status_string\",\n \"def status(self) -> dict[str, str] | None:\\n return self._status\",\n \"def status(self):\\n return STATUS[self.fields['status']]\",\n \"def get_grading_status_list(self, *args, **kwargs):\\r\\n return {\\r\\n \\\"version\\\": 1,\\r\\n \\\"problem_list\\\": [\\r\\n {\\r\\n \\\"problem_name\\\": \\\"Test1\\\",\\r\\n \\\"grader_type\\\": \\\"IN\\\",\\r\\n \\\"eta_available\\\": True,\\r\\n \\\"state\\\": \\\"Finished\\\",\\r\\n \\\"eta\\\": 259200,\\r\\n \\\"location\\\": \\\"i4x://edX/open_ended/combinedopenended/SampleQuestion1Attempt\\\"\\r\\n },\\r\\n {\\r\\n \\\"problem_name\\\": \\\"Test2\\\",\\r\\n \\\"grader_type\\\": \\\"NA\\\",\\r\\n \\\"eta_available\\\": True,\\r\\n \\\"state\\\": \\\"Waiting to be Graded\\\",\\r\\n \\\"eta\\\": 259200,\\r\\n \\\"location\\\": \\\"i4x://edX/open_ended/combinedopenended/SampleQuestion\\\"\\r\\n },\\r\\n {\\r\\n \\\"problem_name\\\": \\\"Test3\\\",\\r\\n \\\"grader_type\\\": \\\"PE\\\",\\r\\n \\\"eta_available\\\": True,\\r\\n \\\"state\\\": \\\"Waiting to be Graded\\\",\\r\\n \\\"eta\\\": 259200,\\r\\n \\\"location\\\": \\\"i4x://edX/open_ended/combinedopenended/SampleQuestion454\\\"\\r\\n },\\r\\n ],\\r\\n \\\"success\\\": True\\r\\n }\",\n \"def get_response_serializers(self):\\n manual_responses = self.overrides.get('responses', None) or {}\\n manual_responses = OrderedDict((str(sc), resp) for sc, resp in manual_responses.items())\\n\\n responses = {}\\n if not any(is_success(int(sc)) for sc in manual_responses if sc != 'default'):\\n responses = self.get_default_responses()\\n\\n responses.update((str(sc), resp) for sc, resp in manual_responses.items())\\n return responses\",\n \"def status_feedback(self):\\n return {\\n TAG_ADDRESS: self.address,\\n ATTR_STATUS: self._status,\\n ATTR_INIT: self._init,\\n ATTR_PRECISION: self._prec,\\n ATTR_TS: self._last_edited,\\n ATTR_LAST_CHANGED: self._last_changed,\\n ATTR_LAST_UPDATE: self._last_update,\\n }\",\n \"def status_get(): # noqa: E501\\n db = get_db()\\n return [{'id': sample, 'status': db['samples'][sample]['status']} for sample in db['samples'].keys()]\",\n \"def __iter__(self):\\n return iter(self._enums)\",\n \"def get_status(self):\\n return dict(CAMPAIGN_STATUS_CHOICES).get(self.status, \\\"N/A\\\")\",\n \"def handle_enum(enum_annotations: Any) -> list:\\n result = []\\n for attribute in list(enum_annotations):\\n result.append(attribute.value)\\n return result\",\n \"def statuses(self):\\n big = BigCommerceAPI()\\n response = big.get('orderstatuses')\\n return response.text\",\n \"def award_status_populator():\\n award_status_list = funding_data[\\\"Project Status:\\\"].unique()\\n return [{'label': i, 'value': i} for i in award_status_list]\",\n \"def getStatus():\",\n \"def fallback_status_codes(self) -> pulumi.Output[Optional[Sequence[str]]]:\\n return pulumi.get(self, \\\"fallback_status_codes\\\")\",\n \"def get_sorted_equipment_status(self):\\n\\n equipment_fields = [\\n \\\"gas_burner_primus\\\",\\n \\\"axe\\\",\\n \\\"hammer\\\",\\n \\\"saw\\\",\\n \\\"saw_blade\\\",\\n \\\"saw_bench\\\",\\n \\\"spade\\\",\\n \\\"kerosene_lamp\\\",\\n \\\"detergent\\\",\\n \\\"dishware\\\",\\n \\\"cookware\\\",\\n \\\"cabin_book\\\",\\n \\\"candle_holders\\\",\\n \\\"fire_blanket\\\",\\n \\\"fire_extinguisher\\\",\\n ]\\n\\n equipment_status = {\\\"0\\\": [], \\\"1\\\": [], \\\"2\\\": []}\\n\\n for field_name in equipment_fields:\\n value = getattr(self, field_name, None)\\n equipment_status[str(value)].append(field_name)\\n\\n return equipment_status\",\n \"def get_resource_state():\\n output = [f'{\\\"S. No.\\\":6}\\\\t{\\\"Resource\\\":50}\\\\t{\\\"Health State\\\":12}\\\\t{\\\"Reason\\\":100}\\\\n']\\n\\n for index, resource in enumerate(HEALTH_AGGREGATOR.resource_state):\\n output.append(\\n f'{index + 1:<6}\\\\t{resource:<50}\\\\t'\\n f'{\\\"Healthy\\\" if HEALTH_AGGREGATOR.resource_state[resource][\\\"is_healthy\\\"] else \\\"Unhealthy\\\":<12}\\\\t'\\n f'{HEALTH_AGGREGATOR.resource_state[resource][\\\"reason\\\"]:<100}\\\\n'\\n )\\n\\n return Response('\\\\n'.join(output), 200, mimetype='text/plain')\",\n \"def formats(self):\\n logger.debug(\\\"Get formats\\\")\\n return self._raw_api.formats.get()\",\n \"def get_status(self):\\n r = requests.get(self.base_url + '/status')\\n return r.json()\",\n \"async def device_status(self, value):\\n if value is None:\\n return\\n \\n binvalue = str(bin(value))\\n binarr = binvalue[::-1]\\n binarr = binarr[:len(DEVICE_STATUS)]\\n return_value = []\\n for x in range(len(DEVICE_STATUS)):\\n if binarr[len(binarr) - 1 - x] == \\\"1\\\":\\n return_value.append(DEVICE_STATUS[x])\\n\\n return return_value\",\n \"def getAllStatus(self) -> DataFrame:\\n return self.writer.getAllStatus()\",\n \"def status_list(maj_status, min_status, status_type=C.GSS_C_GSS_CODE, mech_type=C.GSS_C_NO_OID):\\n from .oids import OID\\n\\n statuses = []\\n message_context = ffi.new('OM_uint32[1]')\\n minor_status = ffi.new('OM_uint32[1]')\\n\\n if isinstance(mech_type, OID):\\n mech_type = ffi.addressof(mech_type._oid) # OID._oid is type \\\"struct gss_OID_desc\\\"\\n elif mech_type == C.GSS_C_NO_OID:\\n mech_type = ffi.cast('gss_OID', C.GSS_C_NO_OID)\\n elif not isinstance(mech_type, ffi.CData) or ffi.typeof(mech_type) != ffi.typeof('gss_OID'):\\n raise TypeError(\\n \\\"Expected mech_type to be a gssapi.oids.OID or gss_OID, got {0}\\\".format(type(mech_type))\\n )\\n\\n while True:\\n status_buf = ffi.new('gss_buffer_desc[1]')\\n\\n try:\\n retval = C.gss_display_status(\\n minor_status,\\n maj_status,\\n status_type,\\n mech_type,\\n message_context,\\n status_buf\\n )\\n if retval == C.GSS_S_COMPLETE:\\n statuses.append(\\\"({0}) {1}.\\\".format(\\n maj_status,\\n _buf_to_str(status_buf[0]).decode(\\\"utf-8\\\", errors=\\\"replace\\\")\\n ))\\n elif retval == C.GSS_S_BAD_MECH:\\n statuses.append(\\\"Unsupported mechanism type passed to GSSException\\\")\\n break\\n elif retval == C.GSS_S_BAD_STATUS:\\n statuses.append(\\\"Unrecognized status value passed to GSSException\\\")\\n break\\n finally:\\n C.gss_release_buffer(minor_status, status_buf)\\n\\n if message_context[0] == 0:\\n break\\n\\n if min_status:\\n minor_status_msgs = status_list(min_status, 0, C.GSS_C_MECH_CODE, mech_type)\\n if minor_status_msgs:\\n statuses.append(\\\"Minor code:\\\")\\n statuses.extend(minor_status_msgs)\\n return statuses\",\n \"def _get_errortypes_params(error_types):\\n return {et: \\\"1\\\" for et in error_types}\",\n \"def getStatus():\\n return json.dumps({'camera': Camera.status(), 'rover': rover.status()}), 200\",\n \"def _GetStatusFromOp(op):\\n for prop in op.response.additionalProperties:\\n if prop.key == 'status':\\n return prop.value.string_value\\n return 'UNKNOWN'\",\n \"def getInfoOnStatus(self):\\n raise NotImplementedError();\",\n \"def status(self) -> str:\\n return self._search_in_description(REGEXP_ATTR_STATUS)\",\n \"def _get_status(self, context, object_list=None):\\n status = self.request.GET.get(\\\"status\\\", \\\"\\\").upper()\\n\\n if object_list is not None:\\n return self._get_object_list(\\n object_list, status != \\\"\\\" and JobStatus.is_member(status), status=status\\n )\\n\\n options = list(map(lambda s: (s.name, s.value), JobStatus))\\n\\n return {\\n **context,\\n \\\"status_options\\\": sorted(options, key=lambda x: x[0]),\\n \\\"status\\\": status,\\n }\",\n \"def test__validate_status__0():\\n for input_value, expected_output in (\\n (ScheduledEventStatus.active, ScheduledEventStatus.active),\\n (ScheduledEventStatus.active.value, ScheduledEventStatus.active)\\n ):\\n output = validate_status(input_value)\\n vampytest.assert_is(output, expected_output)\",\n \"def status_info(self):\\n def subdevice_filter(info):\\n return bool(info['kind'] & Kind.normal)\\n\\n return ophydobj_info(self, subdevice_filter=subdevice_filter)\",\n \"async def fetch_status(self, params={}):\\n #\\n # [1] # operative\\n # [0] # maintenance\\n #\\n response = await self.publicGetPlatformStatus(params)\\n statusRaw = self.safe_string(response, 0)\\n return {\\n 'status': self.safe_string({'0': 'maintenance', '1': 'ok'}, statusRaw, statusRaw),\\n 'updated': None,\\n 'eta': None,\\n 'url': None,\\n 'info': response,\\n }\",\n \"def get_container_statuses(self):\\n return {c['id']: c['state'] for c in self.get_containers()}\",\n \"def _get_info(self):\\n\\n info = {}\\n if self.field is not None and self.field.check_in_enum is not None:\\n info.update(in_enum=self.field.check_in_enum.options(),\\n in_enum_lookup=self.field.check_in_enum.to_dict())\\n\\n elif self.valid_values_provider is not None and \\\\\\n not callable(self.valid_values_provider):\\n info.update(in_enum=dict_utils.create_options(self.valid_values),\\n in_enum_lookup=dict_utils.create_dict(self.valid_values))\\n\\n base_info = super()._get_info()\\n if base_info:\\n info.update(base_info)\\n\\n return info\",\n \"def states(self) -> Type[Any]:\\n return []\",\n \"def tpn_valid_values(self):\\n return self.get_valid_values_map()\",\n \"def get_labels():\\n return {\\\"contradiction\\\": 0, \\\"neutral\\\": 1, \\\"entailment\\\": 2}\",\n \"def status(self):\\n return status_dict[self._get_property_(self.STATUS).upper()]\",\n \"def statuses(self):\\n return self._get_paged(\\\"statuses\\\")\",\n \"def formats(self):\\n return self._map.keys()\",\n \"def as_base_types(self) -> Dict[Text, Any]:\\n running_phase_state = None\\n if self.running_phase_state:\\n running_phase_state = self.running_phase_state.as_base_types()\\n return {\\n 'status': data.convert_to_base_types(self._status),\\n 'test_record': self.test_record.as_base_types(),\\n 'plugs': self.plug_manager.as_base_types(),\\n 'running_phase_state': running_phase_state,\\n }\",\n \"def json_statuslist():\\n statuses = Status.query.all()\\n out = {'statuses': []}\\n for status in statuses:\\n out['statuses'].append(status.value)\\n\\n return jsonify(out)\",\n \"def _filter_resources_by_status(self, resources: [], statuses: []):\\n all_resources = []\\n for resource in resources:\\n if statuses:\\n status = ResourceModel.Status.from_string(resource.status)\\n if status in statuses:\\n all_resources.append(resource)\\n else:\\n all_resources.append(resource)\\n return all_resources\",\n \"def _cls_repr(self):\\n prefixes = []\\n for name, invert in ( ('enable', False), ('disable', True) ):\\n states = self._getEnabled(nondefault=False,\\n invert=invert)\\n if len(states):\\n prefixes.append(\\\"%s_states=%s\\\" % (name, str(states)))\\n return prefixes\",\n \"def check_status(self) -> Mapping[str, bool]:\\n ups_stat = {}\\n for name in self.ups_names:\\n ups_stat[name] = self.check_ups(name)\\n return ups_stat\",\n \"def getValidations(self):\\n return self.objectValues('InstrumentValidation')\",\n \"def status(self):\\n if isinstance(self.attrs['State'], dict):\\n return self.attrs['State']['Status']\\n return self.attrs['State']\",\n \"def _serialize_event_status(event, messages):\\n if event.status == MessagingEvent.STATUS_COMPLETED:\\n if event.xforms_session_id:\\n return event.xforms_session.status_slug\\n if any(message[\\\"status\\\"] == SMS.STATUS_ERROR for message in messages):\\n return SMS.STATUS_ERROR # mark event status as 'error' if any messages errored\\n return MessagingEvent.STATUS_SLUGS.get(event.status, 'unknown')\",\n \"def device_state_attributes(self):\\n tmp = self._boiler.__dict__.items()\\n return {'status': {k: v for k, v in tmp if k in GH_STATE_ATTRS}}\",\n \"def _serialize(self, data: Any) -> Dict[Any, Any]:\\n\\n return {field: value.value if isinstance(value, Enum) else value for field, value in data}\",\n \"def value_items(self):\\n if self._parent:\\n return [ WARP_MODE_NAMES[x] for x in self._parent.available_warp_modes ]\\n return ()\",\n \"def valid_unit() -> List[str]:\\n return [\\n AssignmentState.CREATED,\\n AssignmentState.LAUNCHED,\\n AssignmentState.ASSIGNED,\\n AssignmentState.COMPLETED,\\n AssignmentState.ACCEPTED,\\n AssignmentState.REJECTED,\\n AssignmentState.SOFT_REJECTED,\\n AssignmentState.EXPIRED,\\n ]\",\n \"def status_determine():\\n b_status = False\\n b_statusInput = True\\n b_statusAnalyze = True\\n b_statusOutput = True\\n nonlocal dret_inputSet\\n nonlocal dret_analyze\\n nonlocal dret_outputSet\\n nonlocal fn_inputReadCallback\\n nonlocal fn_analysisCallback\\n nonlocal fn_outputWriteCallback\\n\\n if fn_inputReadCallback:\\n if 'status' in dret_inputSet.keys():\\n b_statusInput = dret_inputSet['status']\\n if fn_analysisCallback:\\n if 'status' in dret_analyze.keys():\\n b_statusAnalyze = dret_analyze['status']\\n if fn_outputWriteCallback:\\n if 'status' in dret_outputSet.keys():\\n b_statusOutput = dret_outputSet['status']\\n\\n b_status = b_statusInput and b_statusAnalyze and b_statusOutput\\n return {\\n 'status': b_status\\n }\",\n \"def enum(self):\\r\\n raise NotImplementedError\",\n \"def applicable_job_statuses(self):\\n return self._applicable_job_statuses\",\n \"def get_response_serializers(self):\\n responses = OrderedDict({\\n '400': 'Invalid arguments',\\n '401': 'Not authenticated',\\n '403': \\\"You don't have access to do this operation on this company\\\",\\n 'error': ErrorSerializer,\\n })\\n\\n responses.update(super().get_response_serializers())\\n\\n return responses\",\n \"def build_expected_system_labels_response(self):\\n labels = [\\n {\\n \\\"key\\\": \\\"name\\\",\\n \\\"value\\\": \\\"appName\\\"\\n },\\n {\\n \\\"key\\\": \\\"boolean_value\\\",\\n \\\"value\\\": \\\"False\\\"\\n },\\n {\\n \\\"key\\\": \\\"list_name\\\",\\n \\\"value\\\": \\\"a\\\"\\n },\\n {\\n \\\"key\\\": \\\"list_name\\\",\\n \\\"value\\\": \\\"b\\\"\\n },\\n {\\n \\\"key\\\": \\\"list_name\\\",\\n \\\"value\\\": \\\"c\\\"\\n }\\n ]\\n return labels\",\n \"def get_status(self):\\n return [l1.get_visible() for (l1, l2) in self.lines]\",\n \"def rights_status(self):\\n return {uri: dict(name=name,\\n open_access=(uri in RightsStatus.OPEN_ACCESS),\\n allows_derivatives=(uri in RightsStatus.ALLOWS_DERIVATIVES))\\n for uri, name in list(RightsStatus.NAMES.items())}\",\n \"def fallback_status_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"fallback_status_codes\\\")\",\n \"def fallback_status_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:\\n return pulumi.get(self, \\\"fallback_status_codes\\\")\",\n \"def value_specs(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:\\n return pulumi.get(self, \\\"value_specs\\\")\",\n \"def badges(self):\\n for test_type, status_getter in [('image', image_status_msg), ('hash', hash_status_msg)]:\\n status = getattr(self, f'{test_type}_status')\\n if (\\n (status == 'missing') or\\n (self.status == 'failed' and status == 'match') or\\n (self.status == 'passed' and status == 'diff')\\n ): # Only show if different to overall status\\n yield {'status': status, 'svg': test_type, 'tooltip': status_getter(status)}\",\n \"def _get_field_enum_info(cls):\\n return {}\",\n \"def health_check_codes(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"health_check_codes\\\")\",\n \"def state_info_specs(self):\\n return list()\",\n \"def status_json():\\n status_map = {key : service.current() for key, service in SERVICES.items()}\\n return jsonify({\\n \\\"statuses\\\": [{\\\"key\\\": key, \\\"status\\\": item[0], \\\"health\\\": str(item[1])} for key, item in status_map.items()]\\n })\",\n \"def test_validation_get_valid_formats(self):\\n self.assertIsInstance(api.validation.fetch_formats(), dict)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70321226","0.69514745","0.6703547","0.66662276","0.66662276","0.6600638","0.60567725","0.6023496","0.6015762","0.60128564","0.58968663","0.5772767","0.5756744","0.5754533","0.5745289","0.5745289","0.5734405","0.5720473","0.569388","0.5622869","0.56093264","0.5596578","0.5584272","0.5558634","0.55571645","0.55234164","0.5519777","0.5516511","0.54480183","0.5444346","0.54423535","0.5440041","0.5430115","0.5403812","0.53649783","0.536391","0.53484434","0.53315973","0.5317216","0.53147346","0.5309036","0.5304025","0.53014535","0.52914864","0.5290278","0.5281027","0.527941","0.52692246","0.5269096","0.52685666","0.52663094","0.5257916","0.5254253","0.5240947","0.523314","0.5224798","0.52238244","0.5219794","0.52185607","0.5208029","0.51987267","0.51883817","0.5186479","0.5186128","0.5178793","0.5176188","0.5173994","0.51684916","0.51671493","0.5166099","0.5163927","0.5159946","0.51538575","0.5152207","0.5147863","0.513831","0.51362604","0.5135575","0.5130546","0.5130503","0.5126651","0.5125079","0.5124566","0.51174027","0.51161766","0.51104605","0.51011276","0.50936294","0.50934416","0.5092642","0.50895923","0.5088941","0.5084592","0.5084592","0.5082593","0.5082368","0.5081545","0.5076383","0.50755024","0.50726855","0.50696313"],"string":"[\n \"0.70321226\",\n \"0.69514745\",\n \"0.6703547\",\n \"0.66662276\",\n \"0.66662276\",\n \"0.6600638\",\n \"0.60567725\",\n \"0.6023496\",\n \"0.6015762\",\n \"0.60128564\",\n \"0.58968663\",\n \"0.5772767\",\n \"0.5756744\",\n \"0.5754533\",\n \"0.5745289\",\n \"0.5745289\",\n \"0.5734405\",\n \"0.5720473\",\n \"0.569388\",\n \"0.5622869\",\n \"0.56093264\",\n \"0.5596578\",\n \"0.5584272\",\n \"0.5558634\",\n \"0.55571645\",\n \"0.55234164\",\n \"0.5519777\",\n \"0.5516511\",\n \"0.54480183\",\n \"0.5444346\",\n \"0.54423535\",\n \"0.5440041\",\n \"0.5430115\",\n \"0.5403812\",\n \"0.53649783\",\n \"0.536391\",\n \"0.53484434\",\n \"0.53315973\",\n \"0.5317216\",\n \"0.53147346\",\n \"0.5309036\",\n \"0.5304025\",\n \"0.53014535\",\n \"0.52914864\",\n \"0.5290278\",\n \"0.5281027\",\n \"0.527941\",\n \"0.52692246\",\n \"0.5269096\",\n \"0.52685666\",\n \"0.52663094\",\n \"0.5257916\",\n \"0.5254253\",\n \"0.5240947\",\n \"0.523314\",\n \"0.5224798\",\n \"0.52238244\",\n \"0.5219794\",\n \"0.52185607\",\n \"0.5208029\",\n \"0.51987267\",\n \"0.51883817\",\n \"0.5186479\",\n \"0.5186128\",\n \"0.5178793\",\n \"0.5176188\",\n \"0.5173994\",\n \"0.51684916\",\n \"0.51671493\",\n \"0.5166099\",\n \"0.5163927\",\n \"0.5159946\",\n \"0.51538575\",\n \"0.5152207\",\n \"0.5147863\",\n \"0.513831\",\n \"0.51362604\",\n \"0.5135575\",\n \"0.5130546\",\n \"0.5130503\",\n \"0.5126651\",\n \"0.5125079\",\n \"0.5124566\",\n \"0.51174027\",\n \"0.51161766\",\n \"0.51104605\",\n \"0.51011276\",\n \"0.50936294\",\n \"0.50934416\",\n \"0.5092642\",\n \"0.50895923\",\n \"0.5088941\",\n \"0.5084592\",\n \"0.5084592\",\n \"0.5082593\",\n \"0.5082368\",\n \"0.5081545\",\n \"0.5076383\",\n \"0.50755024\",\n \"0.50726855\",\n \"0.50696313\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":802,"numItemsPerPage":100,"numTotalItems":95772,"offset":80200,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjIyODAwNywianRpIjoiYWI2OTVjMWMtNGMyMC00ODcxLWE3NTEtZGQ5MWY4Zjg5OTgxIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYyMzE2MDcsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.o3uxQ1cUvRVJvgFE9F2C1tWqMp4wPC4O9TI_yq86ANsbkLptlrAgoXeDdXmFiLiKbJ06A_NvXE-zSS9k89q1Dw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
get_data_from_file returns data from a file, given a path. | def get_data_from_file(self, path):
data = None
if not path:
raise RedisUpdateException("Failed to provide a path")
try:
with open(path, 'r') as _file:
data = _file.read()
print("Retrieved data from {}".format(path))
except Excepti... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data_from_file(filepath):\n with open(filepath) as f:\n return f.read()",
"def read_file(path):\n assert_is_string(path)\n f = open(path, \"r\")\n data = f.read()\n f.close()\n return data",
"def load_data(filepath):\n with open(filepath, 'r') as f:\n data = f.read()\... | [
"0.8003186",
"0.757911",
"0.7487064",
"0.7271406",
"0.72710305",
"0.7209962",
"0.7185837",
"0.716335",
"0.71389616",
"0.7106145",
"0.7102851",
"0.70604414",
"0.7031526",
"0.7019637",
"0.69653034",
"0.68595344",
"0.6819222",
"0.6815672",
"0.68082505",
"0.6782052",
"0.67758113"... | 0.7735694 | 1 |
This returns a DataFrame of the content of glob_or_list. IT MAY CONTAIN DUPLICATES | def bulk_gzipped_jsonline_files_to_dfs(glob_or_list, nproc=20):
import multiprocessing as mp
from tqdm import tqdm
if isinstance(glob_or_list, str):
from glob import glob
glob_or_list = glob(glob_or_list)
if len(glob_or_list) == 0:
return []
pool = mp.Pool(min(nproc, len(g... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_filelist_into_dataframe(file_list, pref_name, junk=5, return_idex_version=False,postname_len=4,backjunk=0):\n pref_len = len(pref_name)\n\n q,sq = read_twocol_data(file_list[0],junk=junk,backjunk=backjunk,shh=True)\n df_all_sq = pd.DataFrame(index=q)\n for i in range(len(file_list)):\n ... | [
"0.62427217",
"0.60388565",
"0.58885",
"0.588173",
"0.58777386",
"0.58511496",
"0.5771708",
"0.5754438",
"0.5697812",
"0.5615192",
"0.5559894",
"0.5550235",
"0.54819506",
"0.54814804",
"0.54708",
"0.54589564",
"0.54551876",
"0.5444385",
"0.5415823",
"0.54004604",
"0.5378023",... | 0.5354352 | 25 |
check the given soup for the given URL | def check_href(url, soup):
# pdb.set_trace()
ret_vals = []
href = soup.find_all("a")
for link in href:
if url in link.get("href"):
ret_vals.append(link.get("href").split(url)[1])
return list(set(ret_vals)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_url(soup):\r\n \"\"\"criteria: any(s in a[\"title\"] for s in ('新增', '確診', '肺炎')\"\"\"\r\n url_list = []\r\n for a in soup.find_all('a', {\"href\": re.compile(\"typeid=9$\")}):\r\n if any(s in a[\"title\"] for s in ('新增', '確診', '肺炎')):\r\n url = \"https://www.cdc.gov.tw\" + a['hr... | [
"0.66171163",
"0.6528606",
"0.6515215",
"0.65107447",
"0.64629287",
"0.6438142",
"0.64015216",
"0.63977945",
"0.6395195",
"0.6379726",
"0.63796556",
"0.63583046",
"0.6352542",
"0.6324256",
"0.6231188",
"0.6229653",
"0.6197432",
"0.6152754",
"0.6152524",
"0.6151828",
"0.614191... | 0.7073773 | 0 |
utility function for sampling from distributions, given noise | def sample(params, eps, dist='gauss'):
if 'bin' in dist:
logits = params[-1]
params = params[:-1]
if 'gauss' in dist:
mean, cov = params
s = mean + tf.sqrt(cov) * eps
elif 'gm' in dist:
means, covs, pi_logits = params
choices = tf.multinomial(pi_logits, num_sa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sample_from(space):\n distrs = {\n 'choice': choice,\n 'randint': randint,\n 'uniform': uniform,\n 'normal': normal,\n }\n s = space[0]\n\n np.random.seed(int(time.time() + np.random.randint(0, 300)))\n\n log = s.startswith('log_')\n s = s[len('log_'):] if log else... | [
"0.6733525",
"0.6709667",
"0.66923374",
"0.6601143",
"0.6528409",
"0.6528409",
"0.65123415",
"0.647184",
"0.6471811",
"0.64671725",
"0.6463913",
"0.6457344",
"0.6455953",
"0.6451384",
"0.6442806",
"0.6442806",
"0.6442806",
"0.6442806",
"0.6442806",
"0.64404196",
"0.64396787",... | 0.0 | -1 |
builds inference model for one time step | def inference(in_pl, hid_pl, f_state, eps_z, fd):
phi_x = fd['phi_x'](in_pl)
mean_0, cov_0 = fd['phi_prior'](hid_pl)
mean_z, cov_z = fd['phi_enc'](phi_x, hid_pl)
z = sample((mean_z, cov_z), eps_z, 'gauss')
phi_z = fd['phi_z'](z)
params_out = fd['phi_dec'](phi_z, hid_pl)
f_in = tf.concat([phi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inference(model, data, diagnostics, seed, extra_fitting_args):\n pass",
"def finetuning_single(phase,token2id_dict,id2embedding_dict,inference,dataloaders,model,optimizer,device,weighted_sampling,criterion,classification,auxiliary_loss=False,attn_loss=False,epoch_count=None,new_task_epochs=None,trial=None... | [
"0.7219933",
"0.6997029",
"0.69138074",
"0.6905621",
"0.6757916",
"0.67068917",
"0.6679972",
"0.6673408",
"0.6594149",
"0.658507",
"0.65409905",
"0.64915425",
"0.6486508",
"0.6433577",
"0.64314353",
"0.64195937",
"0.64091146",
"0.6342456",
"0.63339645",
"0.6313222",
"0.631148... | 0.0 | -1 |
computes log probability of target in Gaussian with given parameters | def gaussian_log_p(params_out, x_target, dim):
mean_x, cov_x = params_out
x_diff = x_target - mean_x
x_square = tf.reduce_sum((x_diff / cov_x) * x_diff, axis=[1])
log_x_exp = -0.5 * x_square
log_cov_x_det = tf.reduce_sum(tf.log(cov_x), axis=[1])
log_x_norm = -0.5 * (dim * tf.log(2 * np.pi) + log... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_gaussian_likelihood(x, mu, log_std):\n log_gaussian_prob = -0.5 * (((x - mu) / (tf.exp(log_std) + EPS)) ** 2 - log_std - 0.5 * np.log(2 * np.pi))\n return tf.reduce_sum(log_gaussian_prob, axis=1)",
"def log_prob(self):",
"def log_prob(target_distribution, x0, xs, accepteds):\n return np.mean([... | [
"0.74791056",
"0.7415539",
"0.73810035",
"0.737954",
"0.71995723",
"0.71843565",
"0.7128425",
"0.7069776",
"0.7023565",
"0.70144814",
"0.7014303",
"0.701235",
"0.6959458",
"0.6924743",
"0.6915048",
"0.68896127",
"0.6878826",
"0.68766814",
"0.68624735",
"0.6858382",
"0.6854947... | 0.78899825 | 0 |
computes log probability of target in Gaussian mixture with given parameters | def gm_log_p(params_out, x_target, dim):
mean_x, cov_x, pi_x_logit = params_out
pi_x = tf.nn.softmax(pi_x_logit)
mean_x = tf.transpose(mean_x, perm=[1, 0, 2])
cov_x = tf.transpose(cov_x, perm=[1, 0, 2])
pi_x = tf.transpose(pi_x, perm=[1, 0])
x_diff = x_target - mean_x
x_square = tf.reduce_s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gaussian_log_p(params_out, x_target, dim):\n mean_x, cov_x = params_out\n x_diff = x_target - mean_x\n x_square = tf.reduce_sum((x_diff / cov_x) * x_diff, axis=[1])\n log_x_exp = -0.5 * x_square\n log_cov_x_det = tf.reduce_sum(tf.log(cov_x), axis=[1])\n log_x_norm = -0.5 * (dim * tf.log(2 * n... | [
"0.7413691",
"0.7035746",
"0.6878685",
"0.6865637",
"0.68429726",
"0.6838593",
"0.6807696",
"0.67913365",
"0.6708026",
"0.66946834",
"0.6656199",
"0.663148",
"0.66271496",
"0.6596391",
"0.65957904",
"0.6587668",
"0.6581443",
"0.6546727",
"0.65407664",
"0.64943653",
"0.6489907... | 0.6380243 | 31 |
computes KL divergences between two Gaussians with given parameters | def gaussian_kl_div(mean_0, cov_0, mean_1, cov_1, dim):
mean_diff = mean_1 - mean_0
cov_1_inv = tf.reciprocal(cov_1)
log_cov_1_det = tf.reduce_sum(tf.log(cov_1), axis=[1])
log_cov_0_det = tf.reduce_sum(tf.log(cov_0), axis=[1])
log_term = log_cov_1_det - log_cov_0_det
trace_term = tf.reduce_sum(c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def KL_divergence(model_1, model_2, samples):\n posterior_1 = create_posterior_object(model_1, samples)\n posterior_2 = create_posterior_object(model_2, samples)\n return posterior_1.KL(posterior_2)",
"def kl_gaussian_gaussian_analytic(mu_q, logvar_q, mu_p, logvar_p):\n # init\n batch_size = mu_q.... | [
"0.72388107",
"0.6910017",
"0.6894922",
"0.68472576",
"0.6779738",
"0.6659188",
"0.66573954",
"0.6615593",
"0.65750533",
"0.6552618",
"0.6473315",
"0.6462868",
"0.6447152",
"0.64378923",
"0.6435891",
"0.64307237",
"0.64105403",
"0.6390125",
"0.6342134",
"0.6315715",
"0.629020... | 0.6427663 | 16 |
computes binary cross entropy loss given logit estimate and target | def ce_loss(logits_out, bin_target):
l = tf.nn.sigmoid_cross_entropy_with_logits(logits=logits_out, labels=bin_target, name='ce_loss')
return tf.squeeze(l) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def classification_loss(self, logit, target):\n return F.cross_entropy(logit, target)",
"def binary_crossentropy(output, target):\r\n return -(target * tensor.log(output) + (1.0 - target) * tensor.log(1.0 - output))",
"def cross_entropy(input: Tensor, target: Tensor) -> Tensor:\n norm_log = log_so... | [
"0.7688538",
"0.7384541",
"0.7337872",
"0.73106444",
"0.7251753",
"0.7251657",
"0.71824944",
"0.7172774",
"0.7118522",
"0.710551",
"0.71031016",
"0.70961285",
"0.7076509",
"0.70662785",
"0.70476913",
"0.70405006",
"0.7031607",
"0.70242167",
"0.6990047",
"0.69736594",
"0.69541... | 0.6802525 | 37 |
computes variational upper bound, depending on output distribution and optionally adds binary CE loss employs masking, if enabled. also returns partial losses in most setups (inaccurate with masking) | def loss(x_target, mean_0, cov_0, mean_z, cov_z, params_out, param_dict):
maybe_ce = []
kl_div = gaussian_kl_div(mean_z, cov_z, mean_0, cov_0, param_dict['z_dim'])
if param_dict['model'] == 'gauss_out':
log_p, log_x_norm, log_x_exp, abs_diff = gaussian_log_p(params_out, x_target, param_dict['x_dim'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def CE():\n def CE_loss(input,target):\n return nn.CrossEntropyLoss()(input.squeeze(), target)\n\n return CE_loss",
"def bce_loss(input, target):\r\n neg_abs = - input.abs()\r\n loss = input.clamp(min=0) - input * target + (1 + neg_abs.exp()).log()\r\n return loss.mean()",
"def loss_tota... | [
"0.57762206",
"0.5742245",
"0.57354647",
"0.5715962",
"0.57150716",
"0.56465185",
"0.56056947",
"0.5579924",
"0.5569751",
"0.553863",
"0.5532758",
"0.553238",
"0.5495617",
"0.54928374",
"0.549099",
"0.5471299",
"0.5447897",
"0.54031384",
"0.53975034",
"0.5375022",
"0.5372996"... | 0.5766483 | 1 |
creates train operation using ADAM and gradient clipping | def optimization(err_acc, learning_rate):
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
tvars = tf.trainable_variables()
grads = tf.gradients(err_acc, tvars)
tg_pairs = [(tf.clip_by_value(k[0], -100, 100), k[1]) for k in zip(grads, tvars) if k[0] is not None]
train_op = optimizer.a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self):\n learning_rate = tf.train.exponential_decay(self.learning_rate, self.global_step, self.decay_steps,self.decay_rate, staircase=True)\n self.learning_rate_=learning_rate\n #noise_std_dev = tf.constant(0.3) / (tf.sqrt(tf.cast(tf.constant(1) + self.global_step, tf.float32))) #gra... | [
"0.70264864",
"0.69798446",
"0.6939323",
"0.6836911",
"0.683521",
"0.6806715",
"0.6806536",
"0.67949176",
"0.6763052",
"0.67439944",
"0.67263734",
"0.6715664",
"0.67050755",
"0.66781133",
"0.6576617",
"0.6525466",
"0.6515684",
"0.6439034",
"0.6349592",
"0.63356787",
"0.633342... | 0.6183898 | 34 |
executes one timestep of inference and accumulates loss (and partial losses) passes results for next timestep | def train_loop(x_pl, f_theta, bound_acc, count, f_state, eps_z, param_dict, fun_dict, tracked_tensors):
x_t = tf.squeeze(tf.slice(x_pl, [tf.to_int32(count), 0, 0], [1, -1, -1]), axis=[0])
eps_z_t = tf.squeeze(tf.slice(eps_z, [tf.to_int32(count), 0, 0], [1, -1, -1]), axis=[0])
mean_0, cov_0, mean_z, cov_z, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _train_or_inference(self, hparams, res):\n\t\tif self.mode == 'train':\n\t\t\tself.sample_id = res[1]\n\t\t\tself.loss = res[2]\n\t\t\tself.loss_per_token = res[3]\n\t\t\tself.kl_loss = res[4]\n\t\telif self.mode == 'eval':\n\t\t\tself.loss = res[2]\n\t\telif self.mode == 'infer':\n\t\t\tself.infer_logtis, sel... | [
"0.68273246",
"0.68102425",
"0.6779098",
"0.6720618",
"0.67177796",
"0.6677193",
"0.66431224",
"0.66379356",
"0.6615984",
"0.66039443",
"0.6597892",
"0.6579163",
"0.65593505",
"0.65543324",
"0.65461916",
"0.65415984",
"0.64743316",
"0.6473563",
"0.6446455",
"0.64011544",
"0.6... | 0.6539289 | 16 |
function wrapper to assign the dicts. return value can be looped with tf.while_loop | def get_train_loop_fun(param_dict, fun_dict):
def train_loop_fun(x_pl, hid_pl, err_acc, count, f_state, eps_z, debug_tensors):
return train_loop(x_pl, hid_pl, err_acc, count, f_state, eps_z, param_dict, fun_dict, debug_tensors)
return train_loop_fun | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _step(self) -> Dict[str, tf.Tensor]:\n\n # Pull out the data needed for updates/priorities.\n inputs = next(self._iterator)\n\n o_tm1, a_tm1, r_t, d_t, o_t = inputs.data\n keys, probs = inputs.info[:2]\n\n with tf.GradientTape() as tape:\n # Evaluate our networks.\n # `qv` means quanti... | [
"0.5671674",
"0.5550421",
"0.5465736",
"0.54489744",
"0.5430541",
"0.5418484",
"0.53735536",
"0.53536373",
"0.5325152",
"0.53153545",
"0.53073084",
"0.526662",
"0.52653",
"0.52617794",
"0.5245784",
"0.52382976",
"0.5237779",
"0.52322906",
"0.522094",
"0.52148306",
"0.5176101"... | 0.5212006 | 20 |
sequence length counter needed for while loop | def get_train_stop_fun(num_iter):
def train_stop_fun(*args):
count = args[3]
return tf.less(count, num_iter)
return train_stop_fun | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(seq):\n\treturn sum(1 for x in seq)",
"def __len__(self):\n return self.get_num_sequence()",
"def GetSequenceLength(num_nodes: int) -> int:\n return num_nodes * (3 + (num_nodes - 1) * 2)",
"def _setup_next_sequence(cls):\n return 0",
"def __len__(self):\n return len(self.seq... | [
"0.6761017",
"0.67569274",
"0.66916007",
"0.6634269",
"0.6609336",
"0.6609336",
"0.65568435",
"0.64844733",
"0.64844733",
"0.6341952",
"0.6317042",
"0.6269344",
"0.624352",
"0.623329",
"0.622913",
"0.61457485",
"0.61272085",
"0.61186063",
"0.6097058",
"0.6026103",
"0.60050267... | 0.0 | -1 |
builds generative model for one time step | def generation(hid_pl, f_state, eps_z, eps_x, pd, fd):
params_prior = fd['phi_prior'](hid_pl)
z = sample(params_prior, eps_z, 'gauss')
phi_z = fd['phi_z'](z)
params_out = fd['phi_dec'](phi_z, hid_pl)
x = sample(params_out, eps_x, pd['model'])
phi_x = fd['phi_x'](x)
f_in = tf.concat([phi_x, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_model():",
"def build_model_fn(self):",
"def build_model(self):\n pass",
"def build_model(self):\n pass",
"def build_model(self):\n raise NotImplementedError",
"def _build_model(self):\n raise NotImplementedError()",
"def build_sys_rec_model():\n print(\"buildin... | [
"0.7986959",
"0.71801484",
"0.6979665",
"0.6979665",
"0.6917935",
"0.68268156",
"0.6736923",
"0.6727681",
"0.6707003",
"0.66739935",
"0.66584253",
"0.6601041",
"0.6587544",
"0.6551139",
"0.64963394",
"0.64550954",
"0.6439442",
"0.64208007",
"0.64159006",
"0.63939077",
"0.6364... | 0.0 | -1 |
executes one timestep of generation and accumulates results, writing to x_pl. passes results for next timestep | def gen_loop(x_pl, hid_pl, count, f_state, eps_z, eps_x, pd, fun_dict):
eps_z_t = tf.squeeze(tf.slice(eps_z, [tf.to_int32(count), 0, 0], [1, -1, -1]), axis=[0])
eps_x_t = tf.squeeze(tf.slice(eps_x, [tf.to_int32(count), 0, 0], [1, -1, -1]), axis=[0])
x_t, f_out, f_state = generation(hid_pl, f_state, eps_z_t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iterate(self):\n for i in range(self.generations):\n sorted_polulation = sorted(self.data, key=lambda item: - item.fitness_function(item))\n print(\n [item.to_string() for item in sorted_polulation[:8]],\n [round(item.fitness_function(item),2) ... | [
"0.6084154",
"0.60200095",
"0.5987702",
"0.5944604",
"0.5869606",
"0.58060366",
"0.5777766",
"0.57663774",
"0.57506156",
"0.57447004",
"0.5744184",
"0.5738231",
"0.5735162",
"0.5731313",
"0.57287484",
"0.5708319",
"0.5682771",
"0.5663186",
"0.5659958",
"0.5632665",
"0.5632278... | 0.6012473 | 2 |
function wrapper to assign the dicts. return value can be looped with tf.while_loop | def get_gen_loop_fun(param_dict, fun_dict):
def f(x_pl, hid_pl, count, f_state, eps_z, eps_x):
return gen_loop(x_pl, hid_pl, count, f_state, eps_z, eps_x, param_dict, fun_dict)
return f | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _step(self) -> Dict[str, tf.Tensor]:\n\n # Pull out the data needed for updates/priorities.\n inputs = next(self._iterator)\n\n o_tm1, a_tm1, r_t, d_t, o_t = inputs.data\n keys, probs = inputs.info[:2]\n\n with tf.GradientTape() as tape:\n # Evaluate our networks.\n # `qv` means quanti... | [
"0.5671674",
"0.5550421",
"0.5465736",
"0.54489744",
"0.5430541",
"0.5418484",
"0.53735536",
"0.53536373",
"0.5325152",
"0.53153545",
"0.53073084",
"0.526662",
"0.52653",
"0.52617794",
"0.5245784",
"0.52382976",
"0.5237779",
"0.52322906",
"0.522094",
"0.52148306",
"0.5212006"... | 0.0 | -1 |
sequence length counter needed for while loop | def get_gen_stop_fun(num_iter):
def gen_stop_fun(*args):
count = args[2]
return tf.less(count, num_iter)
return gen_stop_fun | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count(seq):\n\treturn sum(1 for x in seq)",
"def __len__(self):\n return self.get_num_sequence()",
"def GetSequenceLength(num_nodes: int) -> int:\n return num_nodes * (3 + (num_nodes - 1) * 2)",
"def _setup_next_sequence(cls):\n return 0",
"def __len__(self):\n return len(self.seq... | [
"0.6761017",
"0.67569274",
"0.66916007",
"0.6634269",
"0.6609336",
"0.6609336",
"0.65568435",
"0.64844733",
"0.64844733",
"0.6341952",
"0.6317042",
"0.6269344",
"0.624352",
"0.623329",
"0.622913",
"0.61457485",
"0.61272085",
"0.61186063",
"0.6097058",
"0.6026103",
"0.60050267... | 0.0 | -1 |
Retrieve the set of tenants and associated data that this service instance is serving requests for. | def get_tenants():
# these are the tenant_id strings configured for the service -
tenants_strings = conf.tenants
result = []
# the tenants service is a special case, as it must be a) configured to serve all tenants and b) actually maintains
# the list of tenants in its own DB. in this case, we retur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tenants(self):\n # print \"tenant list is %s\" % self.auth.tenants.list()\n if not self._tenancy:\n self._tenancy = {}\n for tenant in self.auth.tenants.list():\n t = Tenant(tenant, self)\n self._tenancy[t[\"name\"]] = t\n return self._te... | [
"0.7666496",
"0.7551507",
"0.7327521",
"0.7190773",
"0.69795996",
"0.6883774",
"0.66170615",
"0.65354675",
"0.62560654",
"0.62347025",
"0.6183546",
"0.6130637",
"0.6121122",
"0.61209637",
"0.61066383",
"0.59755176",
"0.5924605",
"0.5888566",
"0.58852446",
"0.58799565",
"0.586... | 0.77167916 | 0 |
Return the config for a specific tenant_id from the tenants config. | def get_tenant_config(tenant_id):
for tenant in tenants:
if tenant['tenant_id'] == tenant_id:
return tenant
raise errors.BaseTapisError("invalid tenant id.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_tenant_id(self, tenant_name):\n _url = \"http://\" + self.host_ip + \":35357/v2.0/tenants\"\n _headers = {'x-auth-token': self.cloud_admin_info['token_project']}\n _body = None\n\n response = self.request(\"GET\", _url, _headers, _body)\n if response is None:\n ... | [
"0.65135497",
"0.64297974",
"0.6343317",
"0.63199764",
"0.614862",
"0.6080383",
"0.6076917",
"0.602286",
"0.5951957",
"0.5922034",
"0.5922034",
"0.5922034",
"0.5922034",
"0.5922034",
"0.5922034",
"0.5922034",
"0.5922034",
"0.5922034",
"0.5922034",
"0.5848894",
"0.5848894",
... | 0.90069056 | 0 |
Allinone convenience function for implementing the basic Tapis authentication and authorization on a flask app. Pass authn_callback, a Python callable, to handle custom authentication mechanisms (such as nonce) when a JWT is not present. (Only called when JWT is not present; not called when JWT is invalid. Pass authz_c... | def authn_and_authz(authn_callback=None, authz_callback=None):
authentication(authn_callback)
authorization(authz_callback) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def basic_auth_required(realm=None, test_func=None, callback_func=None):\r\n if realm is None:\r\n realm = getattr(settings, 'HTTP_AUTHENTICATION_REALM', _('Restricted Access'))\r\n if test_func is None:\r\n test_func = lambda u: u.is_authenticated()\r\n\r\n def decorator(view_func):\r\n ... | [
"0.63016653",
"0.6183594",
"0.6033451",
"0.58979934",
"0.5873151",
"0.5845127",
"0.58035785",
"0.58035785",
"0.5727074",
"0.57164025",
"0.57164025",
"0.57054675",
"0.5703795",
"0.56947964",
"0.5664348",
"0.56487954",
"0.56346077",
"0.56199163",
"0.5616812",
"0.56149024",
"0.5... | 0.70336246 | 0 |
Adds the standard Tapis headers to the flask thread local. | def add_headers():
# the actual access token -
g.x_tapis_token = request.headers.get('X-Tapis-Token')
# the tenant associated with the subject of the request; used, for instance, when the subject is different
# from the subject in the actual access_token (for example, when the access_token represents a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_app_headers(self, app: Flask) -> Flask:\n app.after_request(self.add_report_to_headers)\n app.after_request(self.add_csp_headers)\n return app",
"def setup_request_headers(self, uri: str = None) -> dict:\n\n uri = uri if uri is not None else self.host\n headers = {\n ... | [
"0.6606569",
"0.5847463",
"0.58139145",
"0.5724754",
"0.56415623",
"0.5594848",
"0.5594848",
"0.54990697",
"0.5450078",
"0.54261225",
"0.54148436",
"0.5409216",
"0.5407132",
"0.5405232",
"0.5381111",
"0.5372568",
"0.5370171",
"0.5361144",
"0.53344506",
"0.5326481",
"0.5326137... | 0.66597694 | 0 |
Attempts to validate the Tapis access token in the request based on the public key and signature in the JWT. This function raises NoTokenError if no token is present in the request. AuthenticationError if validation is not successful. | def validate_request_token():
if not g.x_tapis_token:
raise errors.NoTokenError("No access token found in the request.")
claims = validate_token(g.x_tapis_token)
g.token_claims = claims
g.username = claims.get('username')
g.tenant_id = claims.get('tenant_id')
g.account_type = claims.get(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_token(token):\n # first, decode the token data to determine the tenant associated with the token. We are not able to\n # check the signature until we know which tenant, and thus, which public key, to use for validation.\n try:\n data = jwt.decode(token, verify=False)\n except Except... | [
"0.7679794",
"0.6713847",
"0.6641467",
"0.63084567",
"0.6300321",
"0.62817377",
"0.62767637",
"0.6245932",
"0.6244816",
"0.6241664",
"0.6165352",
"0.6150704",
"0.61449933",
"0.61445177",
"0.61367255",
"0.6129596",
"0.6111446",
"0.61058015",
"0.60760295",
"0.60264575",
"0.5998... | 0.66064703 | 3 |
Standalone function to validate a Tapis token. | def validate_token(token):
# first, decode the token data to determine the tenant associated with the token. We are not able to
# check the signature until we know which tenant, and thus, which public key, to use for validation.
try:
data = jwt.decode(token, verify=False)
except Exception as e:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def validate_token(self, token):",
"def testIsValidToken(self):\n self.assertTrue(TokenResource.isValidToken('aValidToken'),\n msg='Expected isValidToken to accept a valid token.')\n self.assertTrue(TokenResource.isValidToken(TokenResource.VALID_TOKEN_CHARS),\n ... | [
"0.8108974",
"0.72230214",
"0.71571887",
"0.7112058",
"0.7027039",
"0.70232147",
"0.70062846",
"0.6983515",
"0.6958597",
"0.6922451",
"0.6837688",
"0.6833468",
"0.68074733",
"0.6803482",
"0.6784022",
"0.6780159",
"0.6730123",
"0.6601923",
"0.65926063",
"0.6585264",
"0.6554804... | 0.6933009 | 9 |
Return the RSA public key object associated with the string `pub_key`. | def get_pub_rsa_key(pub_key):
return RSA.importKey(pub_key) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_pub_key(priv_key: rsa.RSAPrivateKey) -> rsa.RSAPublicKey:\n return priv_key.public_key()",
"def get_pub_key(self):\n return \"RSA {0}\".format(self._cert.get_pubkey().bits)",
"def generate_rsa_public_key(private_key: RSAPrivateKeyWithSerialization) -> RSAPublicKey:\n return private_key.pub... | [
"0.8029845",
"0.75208515",
"0.7244733",
"0.70427233",
"0.6896109",
"0.687922",
"0.6870712",
"0.687044",
"0.67752415",
"0.67175937",
"0.66782856",
"0.66284066",
"0.6616188",
"0.6558369",
"0.65399873",
"0.6535473",
"0.6520587",
"0.6505804",
"0.65016174",
"0.6483023",
"0.6481328... | 0.9062827 | 0 |
Get the method that would be run by 'cmd' if appliable. The convention is that a cmd command translates to a do_cmd method. | def _getCommand(self, cmd):
try:
cmd_str = cmd.decode('utf-8')
return getattr(self, 'do_' + cmd_str, None)
except:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_method_name(self) -> Optional[str]:\n current_mode = self.get_mode()\n # Check that 'Solvent' program is enabled.\n # Retreiving the remaining time without\n # this programm being selected first would trigger\n # a key error when unpacking the device reply.\n if cu... | [
"0.64923793",
"0.6431936",
"0.6302069",
"0.62959874",
"0.6212672",
"0.6197978",
"0.618102",
"0.6149444",
"0.6144598",
"0.6138146",
"0.61116034",
"0.6111449",
"0.6092141",
"0.6064855",
"0.5992648",
"0.5975918",
"0.5930302",
"0.5929651",
"0.5921336",
"0.59118223",
"0.59087247",... | 0.722417 | 0 |
Initialise a new L{SSHSimpleRealm} with proto as a protocol class. | def __init__(self, proto):
self.proto = proto | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, protocol):\n\n # TODO: add client dictionary\n self._name = protocol['name']\n self._mode = protocol['mode']\n\n try:\n from minicps import __file__\n index = __file__.rfind('minicps')\n self._minicps_path = __file__[:index+7] + '/'\n\... | [
"0.5714169",
"0.5532706",
"0.5513191",
"0.5436813",
"0.5364067",
"0.53378403",
"0.5280844",
"0.52689683",
"0.52358013",
"0.5210464",
"0.51737493",
"0.5153141",
"0.5150517",
"0.51443684",
"0.5113164",
"0.5068551",
"0.505757",
"0.5046438",
"0.50045574",
"0.49984568",
"0.4985887... | 0.5785138 | 0 |
Return a L{SSHSimpleAvatar} that uses ``self.proto`` as protocol. | def requestAvatar(self, avatarId, mind, *interfaces):
if conchinterfaces.IConchUser in interfaces:
avatar = SSHSimpleAvatar(avatarId, self.proto)
return interfaces[0], avatar, lambda: None
else:
raise Exception("No supported interfaces found.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __call__(self):\n \n p = self.protocol()\n p.factory = self\n return p",
"def ssh(self, new=False, waitUp=True):\n if new:\n return Ssh(self, \"\".join([self.username, '@', self.url]))\n\n if self._ssh:\n return self._ssh\n\n self._ssh = ... | [
"0.5337256",
"0.5119516",
"0.5052636",
"0.4982192",
"0.49626386",
"0.4958354",
"0.4958292",
"0.49484098",
"0.49389306",
"0.49389306",
"0.49389306",
"0.49307394",
"0.49133503",
"0.48593906",
"0.48505425",
"0.48438805",
"0.48305398",
"0.480467",
"0.478909",
"0.4756514",
"0.4752... | 0.48853382 | 13 |
Initialises a new L{SSHKeyDirectory}. | def __init__(self, baseDir, parseKey=keys.Key.fromString):
self.baseDir = baseDir
self.parseKey = parseKey | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, type_encryption, directory_key_private, directory_key_public):\n\t\t# class variables\n\t\tself.type_encryption = type_encryption\n\t\tself.directory_key_private = directory_key_private\n\t\tself.directory_key_public = directory_key_public\n\n\t\t# check keys\n\t\tself._publicKey = ''\n\t\tself.... | [
"0.60577464",
"0.594606",
"0.5861696",
"0.5753003",
"0.5698743",
"0.56884545",
"0.5672525",
"0.55618393",
"0.55471104",
"0.5519805",
"0.5516461",
"0.5475223",
"0.5460106",
"0.54503596",
"0.54401225",
"0.54034656",
"0.5368837",
"0.53590226",
"0.5354195",
"0.53359336",
"0.53329... | 0.5662154 | 7 |
Return a L{SSHKeyDirectory} based SSH service with the given parameters. Authorized keys are read as per L{SSHKeyDirectory} with ``baseDir`` being ``keyDir/users``. | def conch_helper(endpoint, proto=None, namespace=dict(),
keyDir=None, keySize=4096):
if keyDir is None:
from twisted.python._appdirs import getDataDirectory
keyDir = getDataDirectory()
keyDir = filepath.FilePath(keyDir)
keyDir.child('server').makedirs(True)
keyDir.child... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_directory(self, key):\n raise NotImplementedError",
"def _getSshDir():\n return f'{Path.home()}/.ssh'",
"def __parse_user_keyfiles(self):\n\n user_sshdir = os.path.expanduser('~/.ssh')\n if not os.path.isdir(user_sshdir):\n return\n\n paths = []\n fo... | [
"0.5406035",
"0.53994006",
"0.5377558",
"0.5355839",
"0.5331604",
"0.52853525",
"0.5199522",
"0.5053196",
"0.5026986",
"0.50190806",
"0.49215123",
"0.4920138",
"0.49054453",
"0.48647752",
"0.48550653",
"0.48274633",
"0.48263925",
"0.47565874",
"0.47353023",
"0.47316363",
"0.4... | 0.5810333 | 0 |
Draws an xz plane on the draw object of an image. | def xzplane(draw, r, y, shift = np.array([1000, 1000, 0, 0]), scale = 300):
extent = 2.8
pln = np.array(
[
[-extent,y,0],
[extent,y,0],
[extent,y,extent*2],
[-extent,y,extent*2]
]
)
pln = np.dot(pln, np.transpose... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xyplane(draw, r, x, shift = np.array([1000, 1000, 0, 0]), scale = 300):\n extent = 2.8\n pln = np.array(\n [\n [x,-extent,0],\n [x,extent,0],\n [x,extent,extent*2],\n [x,-extent,extent*2]\n ]\n )\n pln = np.dot(pl... | [
"0.63721764",
"0.59499615",
"0.5940975",
"0.58033735",
"0.57672477",
"0.5749017",
"0.5720184",
"0.56682396",
"0.5658899",
"0.5638984",
"0.56374484",
"0.5617872",
"0.5594936",
"0.5588465",
"0.55832714",
"0.5539843",
"0.5516542",
"0.5481384",
"0.5468149",
"0.54351264",
"0.53915... | 0.7278522 | 0 |
Draws an xy plane on the draw object of an image. | def xyplane(draw, r, x, shift = np.array([1000, 1000, 0, 0]), scale = 300):
extent = 2.8
pln = np.array(
[
[x,-extent,0],
[x,extent,0],
[x,extent,extent*2],
[x,-extent,extent*2]
]
)
pln = np.dot(pln,np.transpose(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xzplane(draw, r, y, shift = np.array([1000, 1000, 0, 0]), scale = 300):\n extent = 2.8\n pln = np.array(\n [\n [-extent,y,0],\n [extent,y,0],\n [extent,y,extent*2],\n [-extent,y,extent*2]\n ]\n )\n pln = np.dot(pl... | [
"0.6190558",
"0.61875355",
"0.6105799",
"0.60978365",
"0.60453653",
"0.600665",
"0.600636",
"0.6005123",
"0.5991991",
"0.5984115",
"0.58482707",
"0.58322734",
"0.58114034",
"0.58027637",
"0.580153",
"0.5790779",
"0.57654315",
"0.57646567",
"0.57402414",
"0.5721477",
"0.570749... | 0.6882824 | 0 |
Creates a multisig wallet. | def create_multisig_wallet(cls, keystores: Sequence, multisig_type: str, gap_limit=None):
store = storage.WalletStorage('if_this_exists_mocking_failed_648151893')
for i, ks in enumerate(keystores):
cosigner_index = i + 1
store.put('x%d/' % cosigner_index, ks.dump())
store... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_wallet(self, walletName):\n return",
"def createwallet(wipe):\n stm = shared_morphene_instance()\n if mph.rpc is not None:\n mph.rpc.rpcconnect()\n if mph.wallet.created() and not wipe:\n wipe_answer = click.prompt(\"'Do you want to wipe your wallet? Are your sure? This i... | [
"0.6475591",
"0.61685926",
"0.58137155",
"0.5811275",
"0.57452744",
"0.5626184",
"0.5559449",
"0.5492333",
"0.5454424",
"0.5401065",
"0.5399363",
"0.53674704",
"0.53329164",
"0.5268474",
"0.5243381",
"0.5242668",
"0.52220947",
"0.520208",
"0.52008766",
"0.5174029",
"0.5087774... | 0.7653589 | 0 |
Converts date string into UTC datetime object | def str_to_datetime(self, dt_string):
return datetime.datetime.strptime(dt_string, "%Y-%m-%d").replace(
tzinfo=timezone.utc) if dt_string is not None else datetime.datetime.utcnow() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_datetime(datestr):\r\n try:\r\n return dateutil.parser.parse(datestr).replace(tzinfo=utc)\r\n except ValueError:\r\n raise DashboardError(_(\"Unable to parse date: \") + datestr)",
"def parse(date_string: str):\n # parse the date string\n date = dateutil.parser.parse(date_stri... | [
"0.7567312",
"0.754763",
"0.754763",
"0.75145286",
"0.73969394",
"0.7324327",
"0.7264657",
"0.7232909",
"0.7204877",
"0.7177064",
"0.71701044",
"0.71201634",
"0.7108171",
"0.7096173",
"0.7055034",
"0.70515555",
"0.70351195",
"0.7005439",
"0.6998112",
"0.6957853",
"0.6954065",... | 0.72054285 | 8 |
Detect couriers for tracking number. Add any optional parameters as kwargs when calling the method. An overview can be found at | async def detect_couriers_for_tracking_number(self, tracking_number,
**kwargs):
headers = {
'aftership-api-key': self.api_key,
'Content-Type': 'application/json'
}
url = "{}/couriers/detect".format(URL)
data = {}
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, routine, **kw):\n super().__init__(routine=routine, **kw)\n # FIXME: use general parameters from FindFrequency for now\n self.parameter_lookups = self.routine.parameter_lookups\n self.parameter_sublookups = self.routine.parameter_sublookups\n ... | [
"0.5049607",
"0.49687684",
"0.49674186",
"0.4944877",
"0.49375364",
"0.4890782",
"0.48639542",
"0.47709024",
"0.47329307",
"0.46712676",
"0.4589541",
"0.4587399",
"0.45867696",
"0.45704305",
"0.45490083",
"0.45390007",
"0.45230392",
"0.45195344",
"0.45174828",
"0.4509526",
"0... | 0.64663106 | 0 |
Return the last meta response. | def meta(self):
return self._meta | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_model_api_last_response(self):\n return self._last_response",
"def meta(self):\r\n url = '{0}/{1}'.format(self.get_url(), 'meta')\r\n\r\n return http.Request('GET', url), parsers.parse_json",
"def last(self):\n data = self._http_get(\"last\")\n return data.json()",
... | [
"0.66965777",
"0.66848415",
"0.63479745",
"0.634627",
"0.632676",
"0.6163344",
"0.6144499",
"0.6102744",
"0.5884768",
"0.5876844",
"0.58724266",
"0.5859006",
"0.58491874",
"0.5838473",
"0.5800524",
"0.57896864",
"0.57868093",
"0.5754891",
"0.57464105",
"0.57243663",
"0.570871... | 0.6036977 | 10 |
This is the main receiver code | def process_message(msg):
global fout
print("received ")
if len(msg)==200: #is header or end
msg_in=msg.decode("utf-8","ignore")
msg_in=msg_in.split(",,")
if msg_in[0]=="header": #header
filename=extract_file_data(msg_in[1])
file_out="copy-"+filename
fout=open(file_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def receive(self):\n pass",
"def receiver():\r\n global data\r\n DW1000.newReceive()\r\n DW1000.receivePermanently()\r\n DW1000.startReceive()",
"def receive():\n pass",
"def receive(self, message):",
"def receiver(): \n global data\n DW1000.newReceive()\n DW1000.receivePe... | [
"0.76090187",
"0.71404535",
"0.7065118",
"0.7059495",
"0.70585096",
"0.6973347",
"0.6973347",
"0.6973347",
"0.69117665",
"0.6830646",
"0.6703256",
"0.6566006",
"0.6476829",
"0.6430624",
"0.6395208",
"0.6376315",
"0.6376315",
"0.6376315",
"0.6376315",
"0.6376315",
"0.6376315",... | 0.0 | -1 |
Converts a datetime instance to an HTTP date string. | def dt_to_http(dt):
# Tue, 15 Nov 1994 12:45:26 GMT
return dt.strftime('%a, %d %b %Y %H:%M:%S GMT') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def httpdate(date_obj):\n return date_obj.strftime(\"%a, %d %b %Y %H:%M:%S GMT\")",
"def http_date(d=None):\n if not d:\n d = datetime.datetime.utcnow()\n return d.strftime(\"%a, %d %b %Y %H:%M:%S GMT\")",
"def http_date(epoch_seconds=None):\n return formatdate(epoch_seconds, usegmt=True)",
... | [
"0.7712367",
"0.73308283",
"0.70412636",
"0.69220614",
"0.674512",
"0.66672254",
"0.6651549",
"0.6576911",
"0.6574302",
"0.6549761",
"0.6496985",
"0.6476049",
"0.6476049",
"0.6464428",
"0.6451866",
"0.63511235",
"0.63375556",
"0.62699145",
"0.62502176",
"0.6221522",
"0.622039... | 0.7186173 | 3 |
Converts a dict of params to an actual query string. | def to_query_str(params):
if not params:
return ''
# PERF: This is faster than a list comprehension and join, mainly
# because it allows us to inline the value transform.
query_str = '?'
for k, v in params.items():
if v is True:
v = 'true'
elif v is False:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_query_string(params: Optional[Dict[str, Any]] = None) -> str:\n if params is None:\n return ''\n components = []\n for key, value in params.items():\n if isinstance(value, (list, tuple, set)):\n for v in value:\n c = '='.join([key, quote_plus(str(v))])\n ... | [
"0.78997064",
"0.77389985",
"0.7303582",
"0.7127169",
"0.70824003",
"0.6948749",
"0.6851403",
"0.68277687",
"0.68115485",
"0.68115485",
"0.67238486",
"0.66717523",
"0.6662173",
"0.6593251",
"0.6551027",
"0.6503054",
"0.6491908",
"0.6478017",
"0.6459579",
"0.6337528",
"0.63150... | 0.8021034 | 0 |
Code from Stack Overflow's thread 2D gaussian mask should give the same result as MATLAB's fspecial('gaussian',[shape],[sigma]) | def gauss_2d(shape=(3, 3), sigma=0.5):
m, n = [(ss - 1.) / 2. for ss in shape]
y, x = np.ogrid[-m:m + 1, -n:n + 1]
h = np.exp(-(x * x + y * y) / (2. * sigma * sigma))
h[h < np.finfo(h.dtype).eps * h.max()] = 0
sumh = h.sum()
if sumh != 0:
h /= sumh
return h | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fspecial_gaussian(shape=(3, 3), sigma=0.5):\n m, n = [(ss - 1.) / 2. for ss in shape]\n y, x = np.ogrid[-m:m + 1, -n:n + 1]\n h = np.exp(-(x * x + y * y) / (2. * sigma * sigma))\n h[h < np.finfo(h.dtype).eps * h.max()] = 0\n sumh = h.sum()\n if sumh != 0:\n h /= sumh\n return h",
... | [
"0.78761524",
"0.7835241",
"0.7257477",
"0.7124766",
"0.7013949",
"0.6976483",
"0.69737065",
"0.6862989",
"0.6862989",
"0.68552184",
"0.6814549",
"0.67824596",
"0.677597",
"0.67612404",
"0.6757782",
"0.67248285",
"0.6699591",
"0.66922706",
"0.66522694",
"0.6613883",
"0.661035... | 0.6392105 | 37 |
This function is the entry point for making requests. | def _make_get_request(self,url,object_fh,params=None,return_type=None,extras=None):
if params is None:
params = {}
if extras is None:
extras = {}
#Polite Pool Work
#---------------------------------------
#Example
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _make_request(self):\n try:\n self.response = requests.request(\n method=self.method,\n url=self.url,\n params=self.params,\n data=self.data,\n )\n\n logger.debug(f\"Request URL: {self.response.url}\")\n\n ... | [
"0.6656559",
"0.66180503",
"0.6486032",
"0.64114904",
"0.63888973",
"0.63717866",
"0.63412136",
"0.63108295",
"0.6291359",
"0.62690324",
"0.62436515",
"0.61723375",
"0.6147059",
"0.6139604",
"0.61257833",
"0.6107213",
"0.6097222",
"0.6091524",
"0.60824835",
"0.6058591",
"0.60... | 0.61050695 | 16 |
n_random not supported select not supported | def funders(self,filter=None,n_rows=None,
offset=None,query=None,sort_by=None,order=None,
facet=None,cursor=None,return_type=None):
params = self._options_to_dict(filter=filter,n_rows=n_rows,
n_random=None,offset=offset,query=query,
so... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Chose_rand():\r\n total_list=list(range(1,467681))\r\n select=13788\r\n random_selected= random.sample(total_list,select)\r\n return (random_selected)",
"def choose_random(N):\n db = pymongo.MongoClient('localhost',27020).chembldb\n # Get all CHEMBL IDs\n db.molecules.ensure_index('chemb... | [
"0.6967902",
"0.69522023",
"0.6594779",
"0.6483721",
"0.6418708",
"0.64016896",
"0.6392054",
"0.6306159",
"0.63005924",
"0.6261867",
"0.62477386",
"0.622141",
"0.622141",
"0.6192581",
"0.6178769",
"0.6147042",
"0.61248004",
"0.61128944",
"0.61124444",
"0.6070057",
"0.60632735... | 0.0 | -1 |
??? This seems to return all licenses Example Data .URL .workcount | def licenses(self,filter=None,n_rows=None,n_random=None,
offset=None,query=None,sort_by=None,order=None,
facet=None,cursor=None,select=None,return_type=None):
params = self._options_to_dict(filter=filter,n_rows=n_rows,
n_random=n_random,offset=offs... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_resource_license_resource_count_list(self):\n pass",
"def example_data():\n return [\n {'id': 'cc-by', 'title': {'en': 'Creative Commons Attribution'},\n 'type': 'licenses'},\n {'id': 'cc0', 'title': {'en': 'Creative Commons Zero'},\n 'type': 'licenses'},\n ... | [
"0.632174",
"0.6099382",
"0.59777987",
"0.58566386",
"0.576463",
"0.55406904",
"0.54988503",
"0.5466911",
"0.54048777",
"0.5387021",
"0.53721786",
"0.5370196",
"0.5367013",
"0.5332364",
"0.5319262",
"0.53074574",
"0.52883095",
"0.5281296",
"0.5277077",
"0.52634877",
"0.522953... | 0.0 | -1 |
Examples from crossref.api import API api = API() doi = '10.1016/j.urology.2023.01.012' result = api.works_doi(doi) | def works_doi(self,doi,return_type=None):
params = {}
url = self.BASE_URL + f'works/{doi}/'
return self._make_get_request(url,None,params,return_type) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def doi_info(self,doi):\n \n doi = _clean_doi(doi)\n \n url = self.BASE_URL + 'works/' + doi\n \n try:\n return self._make_get_request(url,models.work_single)\n except errors.RequestError:\n #TODO: Check for 404\n #last_response.stat... | [
"0.6810304",
"0.6086377",
"0.60213614",
"0.5970753",
"0.5929596",
"0.59263915",
"0.5889747",
"0.5857135",
"0.5758046",
"0.5643174",
"0.55543613",
"0.5549364",
"0.5461784",
"0.54591",
"0.5457254",
"0.5441897",
"0.5428848",
"0.53719085",
"0.5350076",
"0.5324575",
"0.53110355",
... | 0.8207812 | 0 |
Returns crossref.models.Work If the DOI is not found the errors.InvalidDOI exception is raised. Example import crossref api = crossref.API() m = api.doi_info('10.1109/TNSRE.2011.2163145') | def doi_info(self,doi):
doi = _clean_doi(doi)
url = self.BASE_URL + 'works/' + doi
try:
return self._make_get_request(url,models.work_single)
except errors.RequestError:
#TODO: Check for 404
#last_response.status_code
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def works_doi(self,doi,return_type=None):\n \n params = {}\n \n url = self.BASE_URL + f'works/{doi}/'\n return self._make_get_request(url,None,params,return_type)",
"def get_doi(self):\n\n return self._dois",
"def doi(self):\n return LiteratureReader(self.record... | [
"0.6677814",
"0.6116707",
"0.6039603",
"0.5952847",
"0.58862245",
"0.58078146",
"0.57711214",
"0.569314",
"0.55778825",
"0.5530802",
"0.54897994",
"0.54798776",
"0.54640657",
"0.5429963",
"0.54216063",
"0.5377707",
"0.53602475",
"0.53576905",
"0.532476",
"0.53072464",
"0.5269... | 0.7794295 | 0 |
Returns metadata for the DOI owner prefix Returns crossref.models.Prefix Implements /prefixes/{owner_prefix} Example Data | def prefix_info(self,prefix_id):
url = self.BASE_URL + 'prefixes/' + prefix_id
return self._make_get_request(url,models.prefix_single) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prefix(self):\n return self[\"prefix\"]",
"def prefix(self):\n return self[\"prefix\"]",
"def get_by_metadata_prefix(metadata_prefix):\n return OaiMetadataFormat.get_by_metadata_prefix(\n metadata_prefix=metadata_prefix\n )",
"def prefix(self) -> typing.Optional[str]:\n ... | [
"0.64397043",
"0.64397043",
"0.622263",
"0.59024286",
"0.59024286",
"0.59024286",
"0.585944",
"0.5855058",
"0.58408695",
"0.58408695",
"0.58408695",
"0.5816162",
"0.57742304",
"0.57204545",
"0.57204545",
"0.5717945",
"0.5713031",
"0.5652193",
"0.5652193",
"0.56421614",
"0.550... | 0.6969877 | 0 |
This doesn't seem to be all that useful, since it just returns the subset of work_types() Example api.work_type_info('journal') | def work_type_info(self,type_id):
url = self.BASE_URL + 'types/' + type_id
return self._make_get_request(url,models.pass_through) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_work_list_type_filter(self):\n # Login as simple user\n self.authenticate(self.user)\n\n # Get works list for type wt1\n # should return only work1 and work2\n response = self.client.get(self.url, {\"type\": \"wt1\"})\n self.assertEqual(response.status_code, s... | [
"0.6128776",
"0.5625096",
"0.55931836",
"0.54858536",
"0.5469247",
"0.5398693",
"0.5290816",
"0.5184457",
"0.5176279",
"0.5157655",
"0.51465964",
"0.51203597",
"0.51197135",
"0.5115443",
"0.5079298",
"0.5057034",
"0.50508094",
"0.50491095",
"0.5042974",
"0.50390005",
"0.50068... | 0.667355 | 0 |
GIVEN a MultiChoiceQuestion with valid data WHEN this data has to be compared THEN assert it returns what is expected | def test_model_mc_question(mc_question_one_true):
assert mc_question_one_true.answer1 == "a1"
assert mc_question_one_true.answer1_correct == True
assert mc_question_one_true.answer2 == "a2"
assert mc_question_one_true.answer2_correct == False
assert mc_question_one_true.answer3 == "a3"
assert mc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_model_mc_question_all_true(mc_question_all_true):\n assert mc_question_all_true.answer1_correct == True\n assert mc_question_all_true.answer2_correct == True\n assert mc_question_all_true.answer3_correct == True",
"def test_multi_choice_question_possibilities(self):\n my_step = WorkflowS... | [
"0.72464216",
"0.6873948",
"0.677739",
"0.6737346",
"0.6633856",
"0.65543157",
"0.6410493",
"0.64002144",
"0.638308",
"0.63673925",
"0.63080984",
"0.6236714",
"0.62363225",
"0.622393",
"0.6201957",
"0.6161354",
"0.61485213",
"0.6138616",
"0.61232615",
"0.61002254",
"0.6100149... | 0.7110679 | 1 |
GIVEN a MultiChoiceQuestion where all questions are True WHEN this data has to be compared THEN assert it returns what is expected | def test_model_mc_question_all_true(mc_question_all_true):
assert mc_question_all_true.answer1_correct == True
assert mc_question_all_true.answer2_correct == True
assert mc_question_all_true.answer3_correct == True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_model_mc_question(mc_question_one_true):\n assert mc_question_one_true.answer1 == \"a1\"\n assert mc_question_one_true.answer1_correct == True\n assert mc_question_one_true.answer2 == \"a2\"\n assert mc_question_one_true.answer2_correct == False\n assert mc_question_one_true.answer3 == \"a3... | [
"0.7324127",
"0.67642087",
"0.6470132",
"0.64656526",
"0.6461357",
"0.64389974",
"0.63520503",
"0.63066167",
"0.62987787",
"0.6295936",
"0.6269627",
"0.6198932",
"0.6155377",
"0.60732865",
"0.6065219",
"0.6020827",
"0.5968577",
"0.5963992",
"0.59543484",
"0.59224224",
"0.5921... | 0.78412426 | 0 |
This is a decorator that lets us associate fixtures with one or more arbitrary types. We'll later use this type to determine what tests to run on the result | def typedfixture(*types, **kwargs):
def fixture_wrapper(func):
for t in types:
registered_types.setdefault(t, []).append(func.__name__)
return pytest.fixture(**kwargs)(func)
return fixture_wrapper | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fixtures():",
"def __fixture_decorator_factory(fixture_type):\n def fixture_method(func):\n MetaTestCase._fixture_accumulator[fixture_type].append(func)\n func._fixture_type = fixture_type\n return func\n return fixture_method",
"def pytest_generate_tests(metafunc):\n if \"map... | [
"0.6420398",
"0.63586724",
"0.61313206",
"0.58412457",
"0.57845324",
"0.56449497",
"0.5609401",
"0.5594321",
"0.5594321",
"0.54439896",
"0.54254866",
"0.54079115",
"0.53840494",
"0.5353019",
"0.5349806",
"0.53131664",
"0.5305571",
"0.5304818",
"0.526498",
"0.5259065",
"0.5249... | 0.7396351 | 0 |
Generates a btree node containing the given keys and children. | def __init__(self, keys, children):
self.keys = keys
self.children = children
self.str_pos = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_node_kml(self, d, children):\n return self.generate_leaf_kml(d, \"\\n\".join(children))",
"def build_node(self,key):\n\t\tchildren = self.edges.loc[self.edges[self.parentkey]==key]\n\t\tparent = self.edges.loc[self.edges[self.childkey]==key]\n\t\tcontext = {'link':key}\n\t\tmixed_children = [self.b... | [
"0.6096955",
"0.598687",
"0.5864048",
"0.5862965",
"0.5818496",
"0.58160436",
"0.5708533",
"0.56483185",
"0.55681473",
"0.55629885",
"0.55351895",
"0.55134845",
"0.5472535",
"0.547004",
"0.5436146",
"0.54358304",
"0.54183835",
"0.5415848",
"0.53927886",
"0.5363014",
"0.534810... | 0.57768047 | 6 |
Returns the number of key stored in self. | def num_keys(self):
return len(self.keys) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getNumberOfKeys(self) -> int:\n ...",
"def getKeyCount(self,\n key):\n if (self.hasKey(key) == 1):\n return self.__keyCount[key]\n else:\n return 0",
"def getNoOfKeys(self):\n return len(self.__keyList)",
"def size(self, key):\n ... | [
"0.8223332",
"0.8059746",
"0.772476",
"0.7713106",
"0.7676172",
"0.7665692",
"0.7628625",
"0.76206857",
"0.7604216",
"0.7455673",
"0.7455673",
"0.74253446",
"0.73838294",
"0.7367744",
"0.7305631",
"0.73002994",
"0.7284549",
"0.7284549",
"0.7281263",
"0.72693294",
"0.72623026"... | 0.7749467 | 2 |
Returns the number of children in self. | def num_children(self):
return len(self.children) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def child_count(self):\n\t\treturn len(self._children)",
"def get_num_children(self):\n return len(self.children)",
"def children_count(self):\n return len(self._children_ids)",
"def n_children(self):\n ch = self.children\n return 0 if not ch else len(ch) + sum([c.n_children for c... | [
"0.9265085",
"0.9214745",
"0.90355635",
"0.8766905",
"0.8657029",
"0.8415583",
"0.8351195",
"0.8347997",
"0.830729",
"0.82977325",
"0.82969064",
"0.8269557",
"0.8222202",
"0.819979",
"0.8181198",
"0.815542",
"0.81494474",
"0.81494474",
"0.80688536",
"0.8059617",
"0.80556947",... | 0.9027928 | 3 |
Checks whether self is a leaf. | def is_leaf(self):
return self.num_children() == 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_leaf(self):\n return isinstance(self, Leaf)",
"def is_leaf(self):\n if len(self.children) == 0: #If the Node has no children, it's a leaf\n return True\n else:\n return False",
"def is_leaf(self):\n if len(self... | [
"0.8699565",
"0.85564995",
"0.85333204",
"0.8457117",
"0.845169",
"0.84258795",
"0.8417539",
"0.84157974",
"0.8409402",
"0.8363046",
"0.8351346",
"0.83394974",
"0.8338415",
"0.83189255",
"0.83147204",
"0.82866836",
"0.82800835",
"0.82800835",
"0.82800835",
"0.82800835",
"0.82... | 0.8497543 | 3 |
Returns the index of the key preceding key in self. If all keys in self are smaller than key, then the returned index equals the number of keys in self. | def search(self, key):
left = 0
right = self.num_keys()
while right > left:
mid = (left + right)//2
if self.keys[mid] >= key:
right = mid
else:
left = mid + 1
return left | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def locate_predecessor(self, key):\r\n index = self.search(key)\r\n return index-1",
"def locate_successor(self, key):\r\n index = 0\r\n while index < self.num_keys() and self.keys[index] <= key:\r\n index += 1\r\n return index",
"def find_pos(self, _node, _key):\n... | [
"0.72809225",
"0.6939995",
"0.68590945",
"0.68413186",
"0.67561585",
"0.66752625",
"0.6412625",
"0.63675463",
"0.6203015",
"0.6094198",
"0.6082233",
"0.6056718",
"0.59587926",
"0.593308",
"0.5910885",
"0.5910568",
"0.5881031",
"0.58729",
"0.5737283",
"0.5720458",
"0.5712113",... | 0.6353615 | 8 |
Returns the index of the key preceding key in self. If all keys in self are smaller than key, then the returned index equals the number of keys in self. | def linear_search(self, key):
index = 0
while index < self.num_keys() and self.keys[index] < key:
index += 1
return index | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def locate_predecessor(self, key):\r\n index = self.search(key)\r\n return index-1",
"def locate_successor(self, key):\r\n index = 0\r\n while index < self.num_keys() and self.keys[index] <= key:\r\n index += 1\r\n return index",
"def find_pos(self, _node, _key):\n... | [
"0.72809225",
"0.6939995",
"0.68590945",
"0.68413186",
"0.66752625",
"0.6412625",
"0.63675463",
"0.6353615",
"0.6203015",
"0.6094198",
"0.6082233",
"0.6056718",
"0.59587926",
"0.593308",
"0.5910885",
"0.5910568",
"0.5881031",
"0.58729",
"0.5737283",
"0.5720458",
"0.5712113",
... | 0.67561585 | 4 |
Checks whether index is the index of key in self. | def contains_key_at(self, key, index):
return index < self.num_keys() and self.keys[index] == key | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_key(self,index):\n\t\ttry:\n\t\t\tself.__get(index)\n\t\t\treturn True\n\t\texcept:\n\t\t\treturn False",
"def __contains__(self, key):\n return (key in self.index)",
"def __contains__(self, key):\n return key in self._index",
"def is_index(self, key):\n if key not in self:\n ... | [
"0.80958515",
"0.8080907",
"0.7898593",
"0.7691593",
"0.76814926",
"0.7461165",
"0.7258421",
"0.72347355",
"0.72082126",
"0.7156153",
"0.71312",
"0.70865715",
"0.7085773",
"0.70831966",
"0.7078573",
"0.7066213",
"0.705248",
"0.69911355",
"0.69047403",
"0.68976754",
"0.6862757... | 0.820087 | 0 |
Returns the smallest key in self's subtree. | def deep_min(self):
node = self
while not node.is_leaf():
node = node.children[0]
return node.keys[0] if node.keys else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_min(self):\n if self.root is None: # BC1\n return float('+inf')\n\n current = self.root\n while current.left is not None: # Traverse like a linked-list\n current = current.left\n\n return current.key",
"def min(self):\n if not self.root:\n ... | [
"0.82188064",
"0.8162049",
"0.7955827",
"0.77344906",
"0.768402",
"0.75149393",
"0.7390059",
"0.7334936",
"0.7302149",
"0.7246546",
"0.7226745",
"0.71841216",
"0.7107352",
"0.70095193",
"0.69946045",
"0.69824237",
"0.696417",
"0.6937441",
"0.6906481",
"0.69047743",
"0.6857602... | 0.76173735 | 5 |
Returns the largest key in self's subtree. | def deep_max(self):
node = self
while not node.is_leaf():
node = node.children[-1]
return node.keys[-1] if node.keys else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_max(self):\n if self.root is None: # BC1\n return float('-inf')\n\n current = self.root\n while current.right is not None: # Traverse like a linked-list\n current = current.right\n\n return current.key",
"def max(self):\n if not self.root:\n ... | [
"0.81600595",
"0.79450095",
"0.74522495",
"0.73599684",
"0.7321719",
"0.73032093",
"0.7209396",
"0.71139634",
"0.7080734",
"0.7050053",
"0.69687974",
"0.68866014",
"0.6819253",
"0.67932934",
"0.6767476",
"0.67378",
"0.6650723",
"0.66402555",
"0.6632629",
"0.66247076",
"0.6565... | 0.7431459 | 3 |
Returns the index of the key potentially preceding key in self. If no predecessor exists, then 1 is returned. | def locate_predecessor(self, key):
index = self.search(key)
return index-1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predecessor(self, key):\r\n index = self.locate_predecessor(key)\r\n return self.keys[index] if index >= 0 else None",
"def predecessor(self, key):\r\n node = self.root\r\n predecessor = None\r\n while node:\r\n index = node.locate_predecessor(key)\r\n ... | [
"0.7872401",
"0.7589656",
"0.6912195",
"0.66506773",
"0.63922715",
"0.6348661",
"0.63404214",
"0.6321943",
"0.6298526",
"0.6276858",
"0.6144792",
"0.6108566",
"0.6081407",
"0.6023274",
"0.59759766",
"0.59638053",
"0.5955006",
"0.59512085",
"0.5928223",
"0.59244543",
"0.592433... | 0.8231871 | 0 |
Returns the key preceding key in self. If no predecessor exists, then None is returned. | def predecessor(self, key):
index = self.locate_predecessor(key)
return self.keys[index] if index >= 0 else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predecessor(self, key):\r\n node = self.root\r\n predecessor = None\r\n while node:\r\n index = node.locate_predecessor(key)\r\n if index >= 0:\r\n predecessor = node.keys[index]\r\n node = node.children[index+1] if not node.is_leaf() else No... | [
"0.81663084",
"0.7901949",
"0.7320799",
"0.7194191",
"0.7021487",
"0.695712",
"0.66491675",
"0.65032935",
"0.6382113",
"0.63646156",
"0.63179505",
"0.62725496",
"0.62594867",
"0.62569416",
"0.62057287",
"0.6177524",
"0.61598325",
"0.61568946",
"0.6125257",
"0.6108996",
"0.610... | 0.86580616 | 0 |
Returns the key, in self's subtree, that precedes the indexth key in self. | def deep_predecessor(self, index):
return self.children[index].deep_max() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_key_at_index(self, index):\n return self.chain_key.subkey(index)",
"def locate_predecessor(self, key):\r\n index = self.search(key)\r\n return index-1",
"def get_key(self, proxy_index):\n return self.treeItem(proxy_index)",
"def __next__(self):\n\n nxt = next(self.t... | [
"0.7427632",
"0.73217237",
"0.68301684",
"0.6672804",
"0.6520573",
"0.64545286",
"0.64450806",
"0.6401319",
"0.63935626",
"0.63909465",
"0.6362552",
"0.63624",
"0.6286595",
"0.62645453",
"0.6250981",
"0.6207541",
"0.6196273",
"0.61318624",
"0.61301345",
"0.6081644",
"0.608085... | 0.6196459 | 16 |
Returns the index of the key potentially succeeding key in self. If no successor exists, then the number of keys in self is returned. | def locate_successor(self, key):
index = 0
while index < self.num_keys() and self.keys[index] <= key:
index += 1
return index | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def successor(self, key):\r\n node = self.root\r\n successor = None\r\n while node:\r\n index = node.locate_successor(key)\r\n if index < node.num_keys():\r\n successor = node.keys[index]\r\n node = node.children[index] if not node.is_leaf() else... | [
"0.7063382",
"0.70533043",
"0.7016425",
"0.6872748",
"0.6482853",
"0.6422271",
"0.62887204",
"0.6276225",
"0.624498",
"0.62333864",
"0.6225246",
"0.6175305",
"0.6157319",
"0.61103994",
"0.61052746",
"0.6092125",
"0.6037587",
"0.60236263",
"0.597652",
"0.59452987",
"0.59405917... | 0.7840635 | 0 |
Returns the key succeeding key in self. If no successor exists, then None is returned. | def successor(self, key):
index = self.locate_successor(key)
self.keys[index] if index < self.num_keys() else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def successor(self, key):\r\n node = self.root\r\n successor = None\r\n while node:\r\n index = node.locate_successor(key)\r\n if index < node.num_keys():\r\n successor = node.keys[index]\r\n node = node.children[index] if not node.is_leaf() else... | [
"0.8028854",
"0.73851246",
"0.7282003",
"0.7208794",
"0.7198265",
"0.6955634",
"0.6844323",
"0.6605388",
"0.6567931",
"0.64927167",
"0.64615375",
"0.64292336",
"0.640851",
"0.6341994",
"0.6266964",
"0.62656814",
"0.6251835",
"0.62339365",
"0.62281877",
"0.62220705",
"0.621249... | 0.80394524 | 0 |
Returns the key, in self's subtree, that succeeds the indexth key in self. | def deep_successor(self, index):
return self.children[index+1].deep_min() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_key_at_index(self, index):\n return self.chain_key.subkey(index)",
"def get_key(self, proxy_index):\n return self.treeItem(proxy_index)",
"def __getitem__(self, item: int) -> int:\n return self.root[item].key",
"def get_by_index_key(self, index, key=str):\n return str(self... | [
"0.7776442",
"0.7432982",
"0.7077935",
"0.6845125",
"0.68328536",
"0.6783659",
"0.6702943",
"0.6666974",
"0.6651412",
"0.6620797",
"0.6506993",
"0.64967424",
"0.64375025",
"0.64341646",
"0.64169234",
"0.63980854",
"0.6383009",
"0.6362972",
"0.63480264",
"0.6338995",
"0.633723... | 0.0 | -1 |
Inserts key in self. | def insert(self, key):
index = self.search(key)
self.keys.insert(index, key) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _insert(self, key):\n self.tree.insert(key)",
"def insert(self, key, value):\n\t\tself.__insert(key, value, key[1:])",
"def _insert_item(self, key: _KT, value: _VT) -> None:\n dict.__setitem__(self, key, value)",
"def _insert(self, key, value):\n entry = self._lookup(key)\n if... | [
"0.8215291",
"0.8130354",
"0.7747777",
"0.75291866",
"0.7488285",
"0.74673647",
"0.7428965",
"0.74166065",
"0.7409694",
"0.739464",
"0.73516124",
"0.73007077",
"0.72898746",
"0.7252617",
"0.7230919",
"0.7208782",
"0.7203209",
"0.7197184",
"0.71301323",
"0.71083945",
"0.710483... | 0.84677464 | 0 |
Deletes key from self. | def delete(self, key):
index = self.search(key)
if self.contains_key_at(key, index):
del self.keys[index] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self, key):\n pass",
"def delete(self, key):\n pass",
"def delete(self, key):\n try: \n self.pop(key)\n \n except KeyError: \n raise KeyError",
"def delete(self, key):",
"def delete(self, key):\n raise NotImplementedError",
"def d... | [
"0.86430204",
"0.86430204",
"0.8612833",
"0.8520839",
"0.8519579",
"0.8519579",
"0.85070837",
"0.8474945",
"0.8459517",
"0.8453593",
"0.8411753",
"0.8394384",
"0.83813727",
"0.8342736",
"0.83096606",
"0.83096606",
"0.816677",
"0.8119352",
"0.8118048",
"0.8099478",
"0.80872786... | 0.8364644 | 13 |
Splits self's indexth child. | def split_child(self, index):
child = self.children[index]
median = (child.num_keys())//2
median_key = child.keys[median]
left = Node(child.keys[:median], child.children[:median + 1])
right = Node(child.keys[median + 1:], child.children[median + 1:])
self.keys.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def child(self, index):\n self.__initChild()\n return self.__child[index]",
"def left_child(self, index):\n return 2 * index",
"def left_child(self, index):\n return 2 * index + 1",
"def getChilds(self, index):\n return index, (2 * index) + 1, (2 * index) + 2",
"def right... | [
"0.71440786",
"0.71244633",
"0.71180373",
"0.70349526",
"0.6969549",
"0.68918955",
"0.6713321",
"0.65907323",
"0.65504557",
"0.6508575",
"0.6449697",
"0.64457214",
"0.6435579",
"0.63858145",
"0.6366688",
"0.634847",
"0.6344875",
"0.62523496",
"0.6234957",
"0.6202311",
"0.6193... | 0.7300562 | 0 |
Merges self's indexth keyi and its left and right children into a single node. | def merge_children(self, index):
median_key = self.keys[index]
left, right = self.children[index : index+2]
left.keys.append(median_key)
left.keys.extend(right.keys)
if not right.is_leaf():
left.children.extend(right.children)
del self.keys[index]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transfer_key_counter_clockwise(self, index):\r\n left, right = self.children[index : index+2]\r\n left.keys.append(self.keys[index])\r\n\r\n if not right.is_leaf():\r\n left.children.append(right.children[0])\r\n del right.children[0]\r\n\r\n self.keys[index] =... | [
"0.63334984",
"0.63204676",
"0.62463367",
"0.61867297",
"0.61666614",
"0.5982319",
"0.59687746",
"0.5849334",
"0.57942855",
"0.5774177",
"0.57697964",
"0.57500196",
"0.57442075",
"0.5695976",
"0.5688016",
"0.56424654",
"0.56276697",
"0.5625674",
"0.5612786",
"0.5512356",
"0.5... | 0.71881837 | 0 |
Returns self's indexth child after increasing its number of | def grow_child(self, index, min_num_keys):
child = self.children[index]
left_sibling = (index > 0) and self.children[index-1]
right_sibling = (index < self.num_keys()) and self.children[index+1]
if left_sibling and left_sibling.num_keys() > min_num_keys:
self.transfer_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def right_child(self, index):\n return 2 * index + 1",
"def get_parent_index(self, child):\n return (child-1)//2",
"def parent(self, index):\n return index / 2",
"def left_child(self, index):\n return 2 * index + 1",
"def get_parent(self, index):\n return (index - 1) // (... | [
"0.7636268",
"0.75757277",
"0.7561977",
"0.7540755",
"0.74996656",
"0.7438475",
"0.7419933",
"0.7398625",
"0.73944867",
"0.73817414",
"0.73779047",
"0.7339845",
"0.7339434",
"0.733684",
"0.7296411",
"0.7257258",
"0.72059125",
"0.7184709",
"0.71317303",
"0.7089428",
"0.7061995... | 0.6773244 | 32 |
Let child be self's indexth child and let sibling be child's left sibling. This method transfers the largest key of sibling to self, replacing its indexth key. Then the replaced key and the rightmost child of sibling are transferred to child. | def transfer_key_clockwise(self, index):
left, right = self.children[index : index+2]
right.keys.insert(0, self.keys[index])
if left.children:
right.children.insert(0, left.children[-1])
del left.children[-1]
self.keys[index] = left.keys[-1]
del... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def grow_child(self, index, min_num_keys):\r\n child = self.children[index]\r\n left_sibling = (index > 0) and self.children[index-1]\r\n right_sibling = (index < self.num_keys()) and self.children[index+1]\r\n\r\n if left_sibling and left_sibling.num_keys() > min_num_keys:\r\n ... | [
"0.6706722",
"0.66297823",
"0.634008",
"0.6338777",
"0.6173428",
"0.61367226",
"0.6129858",
"0.60990214",
"0.60599846",
"0.60426533",
"0.59968555",
"0.5979916",
"0.5940587",
"0.5929607",
"0.5894123",
"0.58354366",
"0.5834681",
"0.5830441",
"0.5830441",
"0.57984436",
"0.579428... | 0.6807251 | 0 |
Let child be self's indexth child and let sibling be the right sibling of child. This method transfers the smallest key of sibling to self, replacing its indexth key. Then the replaced key and the leftmost child of sibling are transferred to child. | def transfer_key_counter_clockwise(self, index):
left, right = self.children[index : index+2]
left.keys.append(self.keys[index])
if not right.is_leaf():
left.children.append(right.children[0])
del right.children[0]
self.keys[index] = right.keys[0]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transfer_key_clockwise(self, index):\r\n left, right = self.children[index : index+2]\r\n right.keys.insert(0, self.keys[index])\r\n\r\n if left.children:\r\n right.children.insert(0, left.children[-1])\r\n del left.children[-1]\r\n\r\n self.keys[index] = left.... | [
"0.68184465",
"0.67039645",
"0.6297882",
"0.6214918",
"0.60740006",
"0.60549283",
"0.6019058",
"0.6003216",
"0.5945567",
"0.58862376",
"0.5861213",
"0.5845852",
"0.5827546",
"0.58161736",
"0.57754976",
"0.57537955",
"0.5708677",
"0.56796926",
"0.56702685",
"0.5666705",
"0.566... | 0.65648276 | 2 |
Returns a string representing self. | def __str__(self):
T = Btree(2)
T.root = Node(self.keys, [Node(child.keys, []) for child in self.children])
return str(T) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __repr__(self) -> str:\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())",
"def __repr__(self) -> str:\n return '{:s}({!r})'.format(self.__class__.__name__, self.getvalue())",
"def __repr__(self) -> str:\n return '{:s}({!r})'.format(self.__class__.__name__, self.ge... | [
"0.8629778",
"0.8629778",
"0.8629778",
"0.86215127",
"0.8617751",
"0.859226",
"0.859226",
"0.859226",
"0.859226",
"0.85823804",
"0.85522574",
"0.8511063",
"0.85021406",
"0.8465271",
"0.84598",
"0.84598",
"0.84598",
"0.84598",
"0.84598",
"0.84598",
"0.84598",
"0.84598",
"0... | 0.0 | -1 |
Returns an empty btree with the given degree. | def __init__(self, degree):
self.root = Node([], [])
self.min_num_keys = degree - 1
self.max_num_keys = 2*degree - 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def empty_trie():\n trie = Trie()\n return trie",
"def create_empty_node():\n from linked_list import Node\n return Node()",
"def generate_kdtree(self):\n if self.method==2:\n coordinates = self.unassigned_data[0:3,:]\n else:\n coordinates = self.unassigned_data[0:2,:]\n tree... | [
"0.54264593",
"0.5319066",
"0.5302084",
"0.5298092",
"0.5296648",
"0.5273489",
"0.5268416",
"0.5260879",
"0.52504086",
"0.52388066",
"0.52255917",
"0.52025175",
"0.5162751",
"0.51332253",
"0.51297206",
"0.5105742",
"0.51046455",
"0.50928676",
"0.50726986",
"0.50614315",
"0.50... | 0.60590124 | 0 |
Searches for the given key in the btree. Returns a location pair (node, index), if the given key is found, and None otherwise. | def search(self, key):
(node, index) = self.root, self.root.search(key)
while not node.contains_key_at(key, index) and not node.is_leaf():
node = node.children[index]
index = node.search(key)
return (node, index) if node.contains_key_at(key, index) else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def search(self, key):\n if key in self.key_list:\n return (self.nodes)[key]\n return None",
"def search(self, key):\n\n current = self.head\n\n while current:\n if current.data == key:\n return current\n else:\n current =... | [
"0.7536763",
"0.7263329",
"0.7258225",
"0.7240818",
"0.7216984",
"0.7094803",
"0.704646",
"0.70330936",
"0.7024418",
"0.701099",
"0.6984862",
"0.6956169",
"0.6842266",
"0.68282413",
"0.6815757",
"0.67921466",
"0.676543",
"0.6735953",
"0.6735286",
"0.67308915",
"0.67175317",
... | 0.8333514 | 0 |
Returns the predecessor of key in the btree if a predecessor exists and None otherwise. | def predecessor(self, key):
node = self.root
predecessor = None
while node:
index = node.locate_predecessor(key)
if index >= 0:
predecessor = node.keys[index]
node = node.children[index+1] if not node.is_leaf() else None
return ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predecessor(self, key):\r\n index = self.locate_predecessor(key)\r\n return self.keys[index] if index >= 0 else None",
"def get_predecessor(self, key):\r\n parent_node, search_node = self.__compare(key, method='search')\r\n self.__check_node(search_node)\r\n\r\n # if the no... | [
"0.87234277",
"0.81638896",
"0.8081363",
"0.79326314",
"0.7544297",
"0.70686626",
"0.6950241",
"0.66327226",
"0.6330043",
"0.6280026",
"0.61215246",
"0.59075844",
"0.58937025",
"0.58603984",
"0.58209646",
"0.57893604",
"0.5765395",
"0.57520866",
"0.5751986",
"0.5748757",
"0.5... | 0.86200005 | 1 |
Returns the successor of key in the btree if a successor exists and None otherwise. | def successor(self, key):
node = self.root
successor = None
while node:
index = node.locate_successor(key)
if index < node.num_keys():
successor = node.keys[index]
node = node.children[index] if not node.is_leaf() else None
retu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def successor(self, key):\r\n index = self.locate_successor(key)\r\n self.keys[index] if index < self.num_keys() else None",
"def successor(self, key: int) -> TreeNode:\n tree_node = self.search(key, possible_parent=True)\n if tree_node:\n if tree_node.right and tree_node.v... | [
"0.81975126",
"0.7886115",
"0.7700922",
"0.71824485",
"0.6839009",
"0.67402244",
"0.6659933",
"0.65732276",
"0.6505783",
"0.6441283",
"0.64137965",
"0.63921624",
"0.63333684",
"0.6327468",
"0.63146824",
"0.6298344",
"0.6289164",
"0.6283962",
"0.6269921",
"0.6258933",
"0.62448... | 0.8570802 | 0 |
Inserts key in the btree. | def insert(self, key):
if self.root.num_keys() == self.max_num_keys:
self.root = Node([], [self.root])
self.root.split_child(0)
node = self.root
while not node.is_leaf():
index = node.search(key)
child = node.children[index]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _insert(self, key):\n self.tree.insert(key)",
"def insert(self, key):\r\n index = self.search(key)\r\n self.keys.insert(index, key)",
"def insert(self, key):\n # Create new node\n n = TreeNode(key)\n if not self.node:\n self.node = n\n self.no... | [
"0.80723226",
"0.7769577",
"0.76046723",
"0.7550876",
"0.7482923",
"0.7411101",
"0.73503846",
"0.73227596",
"0.7145061",
"0.713891",
"0.7106708",
"0.7089842",
"0.7040802",
"0.70233256",
"0.69976085",
"0.6994933",
"0.69864684",
"0.6960579",
"0.69592124",
"0.6953528",
"0.693474... | 0.7746731 | 2 |
Deletes key from the btree. | def delete(self, key):
node = self.root
while not node.is_leaf():
index = node.search(key)
if node.contains_key_at(key, index):
left, right = node.children[index : index+2]
if left.num_keys() > self.min_num_keys:
node... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self, key):\n self.tree.delete(key)",
"def deleteKey(self, key):\n key.delete()",
"def delete(self, key):\r\n index = self.search(key)\r\n if self.contains_key_at(key, index):\r\n del self.keys[index]",
"def delete(self, key):",
"def _delete_key(self):\n ... | [
"0.7991843",
"0.79806525",
"0.78956145",
"0.789383",
"0.7867929",
"0.7845178",
"0.7845178",
"0.7822401",
"0.77904487",
"0.77550066",
"0.77327126",
"0.7691955",
"0.76657486",
"0.76657486",
"0.7637523",
"0.7621908",
"0.7568555",
"0.75683135",
"0.7559642",
"0.75456744",
"0.75188... | 0.76733583 | 12 |
Generates the keys of the btree in nondecreasing order. | def inorder(self):
queue = []
node = self.root
index = 0
while node:
if node.is_leaf():
yield from node.keys
if not queue:
node = None
else:
node, index = queue.pop()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __gen_keys__(self):\n if self.seed == b'':\n self.seed = urandom(self.seed_size)\n\n n_prev = Node(hash=hash_factory(data=bytes(self.seed)).digest())\n self.keys.insert(0, n_prev)\n\n for i in range(1, self.l + 1):\n n = Node(hash=hash_factory(data=bytes(n_prev... | [
"0.7092828",
"0.6634701",
"0.60903746",
"0.60409904",
"0.59731305",
"0.59087855",
"0.58942914",
"0.57111263",
"0.57087433",
"0.5708065",
"0.56831133",
"0.56762445",
"0.5663076",
"0.56439334",
"0.5626762",
"0.5597993",
"0.55945045",
"0.55350876",
"0.55234456",
"0.5508163",
"0.... | 0.60486114 | 3 |
Generates the nodes of the btree in breathfirst order. | def breadth_first_search(self):
queue = [self.root]
while queue:
node = queue.pop()
yield node
queue.extend(node.children) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _breadthfirst(self,root, action=lambda nodes: print(nodes)):\n nodes = []\n breadth = Queue()\n visited = []\n\n breadth.enqueue(root)\n visited.append(root)\n\n while breadth.front:\n front = breadth.dequeue()\n nodes.append(front.value)\n\n ... | [
"0.6592182",
"0.6576818",
"0.65263",
"0.6493668",
"0.64677995",
"0.64018893",
"0.6374469",
"0.631121",
"0.6179695",
"0.61257946",
"0.60737664",
"0.6021041",
"0.59558225",
"0.5927343",
"0.58865863",
"0.58744186",
"0.58461434",
"0.5842087",
"0.58408606",
"0.583984",
"0.58299184... | 0.5814027 | 21 |
Generates the nodes of the btree in depthfirst order. | def depth_first_search(self):
queue = [self.root]
ordered = []
while queue:
node = queue.pop()
ordered.append(node)
queue.extend(node.children)
while ordered:
yield ordered.pop() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_nodes(self):\n self.nodes = []\n for i in range(self.num_nodes):\n self.nodes.append(Node(self.fk))",
"def bfs_nodes_generator(graph, source, reverse=...):\n ...",
"def _forest_nodes(self):\n\n self.arbor._grow_tree(self)\n root = self.root\n for link in... | [
"0.6897027",
"0.6522184",
"0.643602",
"0.63939285",
"0.636438",
"0.63289636",
"0.6324205",
"0.6229833",
"0.6213625",
"0.6175851",
"0.6126817",
"0.6121301",
"0.60758805",
"0.60136724",
"0.5981834",
"0.5974182",
"0.5920892",
"0.5901309",
"0.5882063",
"0.5875607",
"0.5871025",
... | 0.55194694 | 81 |
Returns a string representing the btree. | def __str__(self):
levels = tuple(self.generate_levels())
self.compute_representation_positions()
levels_to_strings = self.represent_tree_levels(levels)
branches = self.represent_tree_branches(levels)
return "".join("".join((level, "\n\n", branch))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\r\n T = Btree(2)\r\n T.root = Node(self.keys, [Node(child.keys, []) for child in self.children])\r\n return str(T)",
"def __str__(self):\n tree_rows = [\n [\"Index\", str(self.index)],\n [\n \"Interval\",\n f\"{sel... | [
"0.7546317",
"0.7204102",
"0.7018558",
"0.6907456",
"0.6907456",
"0.6722232",
"0.6719562",
"0.66999125",
"0.66915786",
"0.6672689",
"0.66499346",
"0.6554646",
"0.6547603",
"0.6458844",
"0.6446414",
"0.6432816",
"0.6422437",
"0.6398321",
"0.63936335",
"0.63900334",
"0.63284117... | 0.63268274 | 22 |
Generates the levels of the tree. Here, a level is a list containing the nodes of the corresponding level in the tree. | def generate_levels(self):
level = (self.root,)
while level:
yield level
level = tuple(child for node in level for child in node.children) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def represent_tree_levels(self, levels):\r\n prev_node_end = 0 \r\n level_string = []\r\n for level in levels:\r\n prev_node_end = 0 \r\n level_string = []\r\n for node in level: \r\n node_to_str = str(node.keys)\r\n space_between_... | [
"0.77440464",
"0.70990723",
"0.681317",
"0.67359656",
"0.6714505",
"0.66331315",
"0.6547001",
"0.64071316",
"0.638283",
"0.6314174",
"0.629522",
"0.6271361",
"0.6245086",
"0.6224963",
"0.62211055",
"0.6192207",
"0.6147419",
"0.6091803",
"0.60699326",
"0.6028028",
"0.6007356",... | 0.8173879 | 0 |
Consider a node in the tree and define the label of a node be the string representation of its list of keys. This method computes the start position of the label of every node in the tree and stores the result in an attribute node.repr_pos | def compute_representation_positions(self):
offset = 3
for node in self.depth_first_search():
if node.is_leaf():
node.str_pos = offset
offset += len(str(node.keys)) + 2
else:
first_child_mid = node.children[ 0].str_pos + ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _str(self):\n label = str(self.key)\n if self.left is None:\n left_lines, left_pos, left_width = [], 0, 0\n else:\n left_lines, left_pos, left_width = self.left._str()\n if self.right is None:\n right_lines, right_pos, right_width = [], 0, 0\n ... | [
"0.6528252",
"0.650806",
"0.61717063",
"0.6095379",
"0.5988239",
"0.59429073",
"0.591858",
"0.5913944",
"0.5873949",
"0.58515847",
"0.58018136",
"0.5764564",
"0.57590497",
"0.5692352",
"0.56786346",
"0.5662169",
"0.5628585",
"0.56167775",
"0.55897444",
"0.55868715",
"0.555483... | 0.6413993 | 2 |
Generates the string representation of every level in the tree. | def represent_tree_levels(self, levels):
prev_node_end = 0
level_string = []
for level in levels:
prev_node_end = 0
level_string = []
for node in level:
node_to_str = str(node.keys)
space_between_nodes = node.str_pos ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\n string = ''\n\n # gets the nodes at each level and puts the values into a string\n for i in range(self.get_height()+1):\n nodes = self.get_nodes_on_level(i)\n level = [str(node.value) if node else '-' for node in nodes]\n string += '{}\\n'.... | [
"0.79816777",
"0.7870697",
"0.7510032",
"0.7510032",
"0.7411677",
"0.7384896",
"0.728976",
"0.7282386",
"0.72574866",
"0.71412945",
"0.7100166",
"0.7081404",
"0.70636654",
"0.70597094",
"0.70047724",
"0.6962785",
"0.6947879",
"0.6914737",
"0.69016016",
"0.689865",
"0.68854123... | 0.78502977 | 2 |
Generates the string representation of the branches of every level in the tree. | def represent_tree_branches(self, levels):
for level in levels[:-1]:
branch = []
prev_child_mid = 0
for node in level:
curr_child_mid = node.children[0].str_pos + len(str(node.children[0].keys))//2
space_between_children = curr_child_mid... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __str__(self):\r\n levels = tuple(self.generate_levels())\r\n self.compute_representation_positions()\r\n levels_to_strings = self.represent_tree_levels(levels)\r\n branches = self.represent_tree_branches(levels)\r\n\r\n return \"\".join(\"\".join((level, \"\\n\\n\", branch))... | [
"0.7995158",
"0.71415323",
"0.7092648",
"0.6965924",
"0.69347084",
"0.69347084",
"0.6869118",
"0.67561233",
"0.6710999",
"0.6701027",
"0.66574997",
"0.6621628",
"0.6544818",
"0.6485891",
"0.6470006",
"0.6462897",
"0.645523",
"0.63816184",
"0.63812333",
"0.63696843",
"0.635928... | 0.79277086 | 1 |
Returns a code description of the given handshake | def code(action_sequence):
# refuse any invalid action :
if set(action_sequence) - set(CODE_MAP): # some action was not in the known ones.
return '0' # per spec (test_unknown_action)
mapdict = dict(zip(CODE_MAP, (1, 2, 4, 8)))
da_code = [mapdict[action] for action in action_sequence]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def handshake(code):\n # Get standardized binary string and reverse it to easily read left-ro-right\n scode = standardized_code(code)[::-1]\n if scode == _invalid_code: return _invalid_hshk\n # If input was valid, generate the list of actions that correspond to the\n # input 'code' by reading throug... | [
"0.7176368",
"0.6627802",
"0.60709524",
"0.5658093",
"0.5606787",
"0.5603338",
"0.55955744",
"0.5593792",
"0.5593628",
"0.5551586",
"0.55509025",
"0.55008304",
"0.545813",
"0.5452217",
"0.5406096",
"0.5395542",
"0.53359044",
"0.52636343",
"0.5240677",
"0.5225355",
"0.5209067"... | 0.0 | -1 |
Restore parameters to their default values | def restore_defaults(self):
# Entry Widgets
self.name.delete(0, tk.END)
self.num_invest.delete(0, tk.END)
self.num_flows.delete(0, tk.END)
self.name.insert(0, self.ini_name)
self.num_invest.insert(0, self.ini_num_invest)
self.num_flows.insert(0, self.ini_num_flow... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def restore_parameters(self):\n for p in self.parameters:\n setattr(self, p, self.parameters[p].init_value)\n self.set_symmetry()",
"def set_default_parameters(self):\n super().set_default_parameters()",
"def _restore(self):\n self._logger = LOGGER\n self._param_st... | [
"0.746875",
"0.7371194",
"0.7262057",
"0.7246145",
"0.7239424",
"0.7164283",
"0.71043086",
"0.7073957",
"0.70345813",
"0.70345813",
"0.6979964",
"0.6945354",
"0.6928959",
"0.69264185",
"0.68758583",
"0.6829242",
"0.6829242",
"0.6824344",
"0.67598563",
"0.6753171",
"0.67494166... | 0.0 | -1 |
Empties all pending items in a queue and returns them in a list. | def dump_queue(queue):
result = []
queue.put("STOP")
for i in iter(queue.get, 'STOP'):
result.append(i)
# time.sleep(.1)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pop_all(self):\n with self.lock:\n output = list(self.queue)\n self.queue.clear()\n\n return output",
"def syncdequeue(self):\n #FIXME: Handle exceptions caused when some queue in the list might be empty\n temp=[]\n for itr, contextqueue in enumerate(s... | [
"0.7560036",
"0.74379015",
"0.73933333",
"0.72794014",
"0.7082574",
"0.7025572",
"0.69835323",
"0.6933574",
"0.6933574",
"0.69274217",
"0.6894741",
"0.67466766",
"0.6738973",
"0.6546527",
"0.6539666",
"0.6518188",
"0.64681697",
"0.646041",
"0.6407431",
"0.6362687",
"0.6346074... | 0.61977243 | 27 |
Method to update config and set a default | def update_config(self, config):
self.config = {
"key": "",
"display_name": "",
"description": "",
"required": 1,
"type": "string"
}
self.config.update(config)
self.API_KEY = self.config['github_api_key'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def conf_update(self):\n pass",
"def _auto_update_configuration(self) -> None:\n self.config = rasa.utils.train_utils.update_confidence_type(self.config)\n rasa.utils.train_utils.validate_configuration_settings(self.config)\n self.config = rasa.utils.train_utils.update_similarity_type... | [
"0.7264598",
"0.7069323",
"0.6961064",
"0.68372047",
"0.6822155",
"0.6778296",
"0.67771703",
"0.67771703",
"0.6683653",
"0.6655199",
"0.66525483",
"0.6628711",
"0.66100997",
"0.65775234",
"0.6572172",
"0.65567",
"0.6530263",
"0.6490007",
"0.646487",
"0.6441587",
"0.6429744",
... | 0.6605716 | 13 |
Property that is returned when the worker's current task is referenced | def task(self):
return self._task | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_current_task():\r\n return current_task",
"def _get_current_task():\r\n return current_task",
"def task(self) -> base_model.BaseTask:\n return self._task",
"def get_worker(self):\n return self.worker",
"def worker(self):\n return self._worker",
"def target(self):\n ... | [
"0.7258875",
"0.7258875",
"0.7125476",
"0.7059717",
"0.6981324",
"0.6890757",
"0.6786947",
"0.6784656",
"0.675614",
"0.66428393",
"0.66238403",
"0.6599714",
"0.65985817",
"0.6598365",
"0.6567491",
"0.6450682",
"0.64116323",
"0.64116323",
"0.641029",
"0.6402253",
"0.6399225",
... | 0.7673366 | 4 |
entry point for the broker to add a task to the queue Adds this task to the queue, and calls method to process queue | def task(self, value):
if value['job_type'] == "UPDATE" or value['job_type'] == "MAINTAIN":
self._queue.put(value)
if 'focused_task' in value:
if value['focused_task'] == 1:
logging.info("Focused task is ON\n")
self.finishing_task = True
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_task(self, func, *args, **kwargs):\n self.queue.put((func, args, kwargs))",
"def queue(self, *args, **kwargs):\n queue_args = self._pop_tq_add_args(kwargs)\n app = queue_args.pop('app', None) or flask.current_app\n\n with app.test_request_context():\n # flask.url_fo... | [
"0.7253905",
"0.70889986",
"0.70391834",
"0.68631244",
"0.67951286",
"0.6636714",
"0.6634228",
"0.6612948",
"0.6591344",
"0.65668356",
"0.65632844",
"0.6521921",
"0.64878726",
"0.64713013",
"0.6422268",
"0.63997406",
"0.6351592",
"0.6346175",
"0.63318634",
"0.63318634",
"0.63... | 0.0 | -1 |
Data collection and storage method Query the github api for contributors and issues (not yet implemented) | def badges_model(self, num):
git_url = str(num)
extension = "/en/projects/" + str(git_url) + ".json"
url = self.config['endpoint'] + extension
print("******************")
print(url)
logging.info("Hitting endpoint: " + url + " ...\n")
r = requests.get(url=url)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_repo_data(gh, user, name, start, end):\n repo = gh.get_repo(name)\n\n commits = []\n issues = []\n\n all_commits = repo.get_commits(author=user, since=start, until=end)\n for commit in all_commits:\n # skip merge commits\n if len(commit.parents) == 1:\n commits.appen... | [
"0.6635733",
"0.66275537",
"0.65354526",
"0.65154076",
"0.64518225",
"0.6380046",
"0.63328266",
"0.62949836",
"0.6287409",
"0.6218887",
"0.61803705",
"0.61606205",
"0.61269826",
"0.6107223",
"0.6102897",
"0.6024642",
"0.60007703",
"0.5956787",
"0.595639",
"0.5942637",
"0.5914... | 0.0 | -1 |
Function to process each entry in the worker's task queue Determines what action to take based off the message type | def collect(self):
while True:
if not self._queue.empty():
message = self._queue.get()
self.working_on = message['job_type']
else:
break
logging.info("Popped off message: {}\n".format(str(message)))
if message['job_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _dispatch_messages(self):\n while True:\n select_obj = (yield)\n if select_obj == self._message_queue.selobj:\n msg = self._message_queue.get_nowait()\n if msg is not None:\n msg_type = msg.get('type', None)\n if m... | [
"0.65989715",
"0.64549685",
"0.63235414",
"0.6317404",
"0.62745744",
"0.62171584",
"0.6126182",
"0.6099452",
"0.6088659",
"0.6075633",
"0.6074768",
"0.6067571",
"0.6065684",
"0.60568345",
"0.601493",
"0.6004395",
"0.6",
"0.598145",
"0.5960497",
"0.59493786",
"0.5925146",
"0... | 0.6423937 | 2 |
Kicks off the processing of the queue if it is not already being processed Gets run whenever a new task is added | def run(self):
logging.info("Running...\n")
self._child = Process(target=self.collect, args=())
self._child.start() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def schdule(self):\n while self.queue:\n if self.processing >= self.maxProcessing:\n # We have reached the maximum number of parallel\n # tasks.\n break\n\n item, completeDeferred = self.queue.pop(0)\n\n self.processing += 1 ... | [
"0.69388866",
"0.6733097",
"0.67244655",
"0.67082673",
"0.66665846",
"0.6658585",
"0.6600161",
"0.65939516",
"0.65230006",
"0.6475039",
"0.6474375",
"0.6474239",
"0.6462289",
"0.643574",
"0.6401118",
"0.6358066",
"0.6355609",
"0.6351405",
"0.63341194",
"0.63219726",
"0.630714... | 0.0 | -1 |
Indicates if the group is discoverable for users to selfregister to it. | def discoverable(self):
return sa.Column(sa.Boolean(), default=False) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_registered(self) -> bool:\n from arkouda.util import is_registered\n\n if self.registered_name is None:\n return False\n return is_registered(self.registered_name)",
"def can_group(self) -> bool:\n return (\n self.all_icon is not None and\n self... | [
"0.6570439",
"0.6480385",
"0.64103687",
"0.63470215",
"0.62850165",
"0.62850165",
"0.61633754",
"0.6154956",
"0.61019635",
"0.607818",
"0.60778564",
"0.6061658",
"0.60249096",
"0.59742856",
"0.5905762",
"0.5863819",
"0.58594495",
"0.58562326",
"0.5855537",
"0.58496606",
"0.58... | 0.55592 | 65 |
Text containing the terms and conditions. | def terms(self):
return sa.Column(sa.UnicodeText(), nullable=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def terms_and_conditions(request):\n\treturn render(request, 'tailored/terms_and_conditions.html', {})",
"def __str__(self):\n value = []\n for term in self.terms:\n value += [term.termname]\n return '<formula: %s>' % ' + '.join(value)",
"def __str__(self):\n value = []\n... | [
"0.7217661",
"0.644716",
"0.644716",
"0.60568434",
"0.59968853",
"0.5941543",
"0.59272987",
"0.58720255",
"0.58531255",
"0.58456415",
"0.58353406",
"0.58314884",
"0.57985574",
"0.5666815",
"0.5553111",
"0.5552348",
"0.5544842",
"0.55418533",
"0.5538942",
"0.549686",
"0.549234... | 0.0 | -1 |
Sorting priority weight of the group for resolving conflicting permissions. | def priority(self):
# type: () -> GroupPriority
if self._priority is not None:
return self._priority
if self.group_name == get_constant("MAGPIE_ANONYMOUS_GROUP"):
self._priority = -1 # lowest of all for *special* public group
elif self.group_name == get_constant(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _grokker_sort_key(args):\n grokker, name, obj = args\n return priority.bind().get(grokker)",
"def getPriority(self):",
"def priority(self):\n pass # pragma: no cover",
"def priority(self):\n pass # pragma: no cover",
"def _sort(self, groups):\n return sorted(groups, key=lam... | [
"0.6338274",
"0.62321174",
"0.61597615",
"0.61597615",
"0.61081684",
"0.597041",
"0.58988225",
"0.587243",
"0.5862533",
"0.5848476",
"0.58239365",
"0.5780499",
"0.5731992",
"0.5679707",
"0.5672135",
"0.564723",
"0.55861855",
"0.55627245",
"0.5561452",
"0.5561452",
"0.5561066"... | 0.6633872 | 0 |
Returns all supported representation values that can be mapped to a valid status. | def allowed(cls):
# type: () -> List[Str]
names = cls.names()
allowed = names
allowed.extend([name.lower() for name in names])
return allowed | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def valid_statuses(self):\n return [\n \"dish_maintenance\",\n \"dish_ok\",\n \"RF_maintenance\",\n \"RF_ok\",\n \"digital_maintenance\",\n \"digital_ok\",\n \"calibration_maintenance\",\n \"calibration_ok\",\n ... | [
"0.70321226",
"0.69514745",
"0.6703547",
"0.66662276",
"0.66662276",
"0.6600638",
"0.60567725",
"0.6023496",
"0.6015762",
"0.60128564",
"0.58968663",
"0.5772767",
"0.5756744",
"0.5754533",
"0.5745289",
"0.5745289",
"0.5734405",
"0.5720473",
"0.569388",
"0.5622869",
"0.5609326... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.