0, f\\\"Worker script is not running. Check logs in:\\\\n{script_dir}\\\"\\n assert script_count <= expected_script_count, f\\\"Worker script started too many times. Check logs in:\\\\n{script_dir}\\\"\\n assert script_count == expected_script_count, f\\\"Worker script not started on all workers. Check logs in:\\\\n{script_dir}\\\"\\n \\n _execution_dir, workflow_inst = launch_flow(template_dir, num_workers, _custom_execute_fn=execute)\\n script_dir = Path(workflow_inst.config['worker-initialization']['script-path']).parent\\n script_count = len(find_processes('_TEST_SCRIPT_FAKE_ARG_'))\\n\\n assert script_count == 0, \\\\\\n (\\\"Worker script(s) remained running after the workflow exited.\\\"\\\\\\n f\\\"Check logs in:\\\\n{script_dir}\\\")\",\n \"async def test_engine_stopped_exception_breaks_loop_gracefully(\\n decoy: Decoy,\\n state_store: StateStore,\\n command_executor: CommandExecutor,\\n subject: QueueWorker,\\n) -> None:\\n decoy.when(\\n await state_store.wait_for(condition=state_store.commands.get_next_to_execute)\\n ).then_raise(RunStoppedError(\\\"oh no\\\"))\\n\\n subject.start()\\n await subject.join()\",\n \"def test_raise_error_on_parallel_unavailable(self):\\r\\n self.assertRaises(\\r\\n RuntimeError,\\r\\n raise_error_on_parallel_unavailable,\\r\\n {})\\r\\n self.assertRaises(RuntimeError, raise_error_on_parallel_unavailable,\\r\\n {'jobs_to_start': '1'})\\r\\n raise_error_on_parallel_unavailable({'jobs_to_start': '2'})\\r\\n raise_error_on_parallel_unavailable({'jobs_to_start': '24'})\",\n \"def test_error(self, mock_validate_session):\\n mock_validate_session.return_value = False\\n with pytest.raises(SystemExit) as ctx:\\n celery_command.worker(Namespace(queues=1, concurrency=1))\\n assert str(ctx.value) == \\\"Worker exiting, database connection precheck failed.\\\"\",\n \"def testJobSerialization(self):\\n change = ChangeState(self.config, \\\"changestate_t\\\")\\n\\n locationAction = self.daoFactory(classname=\\\"Locations.New\\\")\\n locationAction.execute(\\\"site1\\\", pnn=\\\"T2_CH_CERN\\\")\\n\\n testWorkflow = Workflow(spec=self.specUrl, owner=\\\"Steve\\\",\\n name=\\\"wf001\\\", task=self.taskName)\\n testWorkflow.create()\\n testFileset = Fileset(name=\\\"TestFileset\\\")\\n testFileset.create()\\n\\n testFile = File(lfn=\\\"SomeLFNC\\\", locations=set([\\\"T2_CH_CERN\\\"]))\\n testFile.create()\\n testFileset.addFile(testFile)\\n testFileset.commit()\\n\\n testSubscription = Subscription(fileset=testFileset,\\n workflow=testWorkflow)\\n testSubscription.create()\\n\\n splitter = SplitterFactory()\\n jobFactory = splitter(package=\\\"WMCore.WMBS\\\",\\n subscription=testSubscription)\\n jobGroup = jobFactory(files_per_job=1)[0]\\n\\n assert len(jobGroup.jobs) == 1, \\\\\\n \\\"Error: Splitting should have created one job.\\\"\\n\\n testJobA = jobGroup.jobs[0]\\n testJobA[\\\"user\\\"] = \\\"sfoulkes\\\"\\n testJobA[\\\"group\\\"] = \\\"DMWM\\\"\\n testJobA[\\\"taskType\\\"] = \\\"Processing\\\"\\n\\n change.propagate([testJobA], 'created', 'new')\\n myReport = Report()\\n reportPath = os.path.join(getTestBase(),\\n \\\"WMCore_t/JobStateMachine_t/Report.pkl\\\")\\n myReport.unpersist(reportPath)\\n testJobA[\\\"fwjr\\\"] = myReport\\n\\n change.propagate([testJobA], 'executing', 'created')\\n\\n changeStateDB = self.couchServer.connectDatabase(dbname=\\\"changestate_t/fwjrs\\\")\\n allDocs = changeStateDB.document(\\\"_all_docs\\\")\\n\\n self.assertEqual(len(allDocs[\\\"rows\\\"]), 2,\\n \\\"Error: Wrong number of documents\\\")\\n\\n result = changeStateDB.loadView(\\\"FWJRDump\\\", \\\"fwjrsByWorkflowName\\\")\\n self.assertEqual(len(result[\\\"rows\\\"]), 1,\\n \\\"Error: Wrong number of rows.\\\")\\n for row in result[\\\"rows\\\"]:\\n couchJobDoc = changeStateDB.document(row[\\\"value\\\"][\\\"id\\\"])\\n self.assertEqual(couchJobDoc[\\\"_rev\\\"], row[\\\"value\\\"][\\\"rev\\\"],\\n \\\"Error: Rev is wrong.\\\")\\n\\n for resultRow in allDocs[\\\"rows\\\"]:\\n if resultRow[\\\"id\\\"] != \\\"_design/FWJRDump\\\":\\n fwjrDoc = changeStateDB.document(resultRow[\\\"id\\\"])\\n break\\n\\n assert fwjrDoc[\\\"retrycount\\\"] == 0, \\\\\\n \\\"Error: Retry count is wrong.\\\"\\n\\n assert len(fwjrDoc[\\\"fwjr\\\"][\\\"steps\\\"]) == 2, \\\\\\n \\\"Error: Wrong number of steps in FWJR.\\\"\\n assert \\\"cmsRun1\\\" in fwjrDoc[\\\"fwjr\\\"][\\\"steps\\\"], \\\\\\n \\\"Error: cmsRun1 step is missing from FWJR.\\\"\\n assert \\\"stageOut1\\\" in fwjrDoc[\\\"fwjr\\\"][\\\"steps\\\"], \\\\\\n \\\"Error: stageOut1 step is missing from FWJR.\\\"\\n\\n return\",\n \"def test_crashes(self, exit_on_deadlock, func, args, expected_err):\\n executor = get_reusable_executor(max_workers=2)\\n res = executor.submit(func, *args)\\n with pytest.raises(expected_err):\\n res.result()\",\n \"def work(self, job):\\n pass\",\n \"def test_send_email_with_incomplete_payload(app, session, email_msg):\\n # TEST\\n with pytest.raises(QueueException) as excinfo:\\n worker.send_email(email_msg, None)\\n\\n assert 'Unsuccessful sending email' in str(excinfo)\",\n \"def test_unknown_job(self):\\n unknown_job = json.loads(BASE_JSON % ('null', 'null', 0, 1433166609))[0]\\n self.assertEquals(self.query_api.get_job_status(unknown_job), UNKNOWN)\",\n \"def _fail_on_bad_torque_start(self):\\n for bundle in self._model.batch_get_bundles(state=State.WAITING_FOR_WORKER_STARTUP, bundle_type='run'):\\n failure_message = self._read_torque_error_log(bundle.metadata.job_handle)\\n if failure_message is None and time.time() - bundle.metadata.last_updated > 20 * 60:\\n failure_message = 'Worker failed to start. You may have requested too many resources.'\\n if failure_message is not None:\\n logger.info('Failing %s: %s', bundle.uuid, failure_message)\\n self._model.update_bundle(\\n bundle, {'state': State.FAILED,\\n 'metadata': {'failure_message': failure_message}})\",\n \"async def test_exception(coresys: CoreSys):\\n\\n class TestClass:\\n \\\"\\\"\\\"Test class.\\\"\\\"\\\"\\n\\n def __init__(self, coresys: CoreSys):\\n \\\"\\\"\\\"Initialize the test class.\\\"\\\"\\\"\\n self.coresys = coresys\\n\\n @Job(conditions=[JobCondition.HEALTHY])\\n async def execute(self):\\n \\\"\\\"\\\"Execute the class method.\\\"\\\"\\\"\\n raise HassioError()\\n\\n test = TestClass(coresys)\\n\\n with pytest.raises(HassioError):\\n assert await test.execute()\",\n \"def test_retry_errors_sooner(self):\\n config_manager, json_file = self._setup_config_manager(\\n 'socorro.unittest.cron.test_crontabber.BarBackfillJob|1d\\\\n'\\n 'socorro.unittest.cron.test_crontabber.FooBackfillJob|1d\\\\n'\\n 'socorro.unittest.cron.test_crontabber.FooBarBackfillJob|1d',\\n extra_value_source={\\n # crontabber already has a good default for this but by\\n # being explict like this we not only show that it can be\\n # changed, we also make it clear what the unit test is\\n # supposed to do.\\n 'crontabber.error_retry_time': '3600' # 1 hour\\n }\\n )\\n\\n # first we need to hack-about so that BarBackfillJob fails only\\n # once.\\n\\n class SomeError(Exception):\\n pass\\n\\n def nosy_run(self, date):\\n dates_used[self.__class__].append(date)\\n if self.__class__ == BarBackfillJob:\\n if len(dates_used[self.__class__]) == 1:\\n # first time run, simulate trouble\\n raise SomeError(\\\"something went wrong\\\")\\n return originals[self.__class__](self, date)\\n\\n classes = BarBackfillJob, FooBackfillJob, FooBarBackfillJob\\n originals = {}\\n dates_used = collections.defaultdict(list)\\n for klass in classes:\\n originals[klass] = klass.run\\n klass.run = nosy_run\\n\\n try:\\n with config_manager.context() as config:\\n tab = crontabber.CronTabber(config)\\n tab.run_all()\\n self.assertEqual(len(dates_used[FooBackfillJob]), 1)\\n self.assertEqual(len(dates_used[FooBackfillJob]), 1)\\n # never gets there because dependency fails\\n self.assertEqual(len(dates_used[FooBarBackfillJob]), 0)\\n\\n structure = json.load(open(json_file))\\n assert structure['foo-backfill']\\n assert not structure['foo-backfill']['last_error']\\n next_date = utc_now() + datetime.timedelta(days=1)\\n assert (\\n next_date.strftime('%Y-%m-%d %H:%M') in\\n structure['foo-backfill']['next_run']\\n )\\n\\n assert structure['bar-backfill']\\n assert structure['bar-backfill']['last_error']\\n next_date = utc_now() + datetime.timedelta(hours=1)\\n assert (\\n next_date.strftime('%Y-%m-%d %H:%M') in\\n structure['bar-backfill']['next_run']\\n )\\n\\n assert 'foobar-backfill' not in structure\\n\\n # Now, let the magic happen, we pretend time passes by 2 hours\\n # and run all jobs again\\n self._wind_clock(json_file, hours=2)\\n # this forces in crontabber instance to reload the JSON file\\n tab._database = None\\n\\n # here, we go two hours later\\n tab.run_all()\\n\\n # Here's the magic sauce! The FooBarBackfillJob had to wait\\n # two hours to run after FooBackfillJob but it should\\n # have been given the same date input as when FooBackfillJob\\n # ran.\\n self.assertEqual(len(dates_used[FooBackfillJob]), 1)\\n self.assertEqual(len(dates_used[FooBackfillJob]), 1)\\n self.assertEqual(len(dates_used[FooBarBackfillJob]), 1)\\n\\n # use this formatter so that we don't have to compare\\n # datetimes with microseconds\\n format = lambda x: x.strftime('%Y%m%d %H:%M %Z')\\n self.assertEqual(\\n format(dates_used[FooBackfillJob][0]),\\n format(dates_used[FooBarBackfillJob][0])\\n )\\n # also check the others\\n self.assertEqual(\\n format(dates_used[BarBackfillJob][0]),\\n format(dates_used[FooBarBackfillJob][0])\\n )\\n\\n structure = json.load(open(json_file))\\n self.assertTrue(structure['foo-backfill'])\\n self.assertTrue(not structure['foo-backfill']['last_error'])\\n self.assertTrue(structure['bar-backfill'])\\n self.assertTrue(not structure['bar-backfill']['last_error'])\\n self.assertTrue(structure['foobar-backfill'])\\n self.assertTrue(not structure['foobar-backfill']['last_error'])\\n\\n finally:\\n for klass in classes:\\n klass.run = originals[klass]\",\n \"def test_workerConnectionPoolPerformJob(self):\\n clock = Clock()\\n peerPool = ControllerQueue(clock, None)\\n factory = peerPool.workerListenerFactory()\\n\\n def peer():\\n p = factory.buildProtocol(None)\\n t = StringTransport()\\n p.makeConnection(t)\\n return p, t\\n\\n worker1, _ignore_trans1 = peer()\\n worker2, _ignore_trans2 = peer()\\n\\n # Ask the worker to do something.\\n worker1.performJob(JobDescriptor(1, 1, \\\"ABC\\\"))\\n self.assertEquals(worker1.currentLoad, 1)\\n self.assertEquals(worker2.currentLoad, 0)\\n\\n # Now ask the pool to do something\\n peerPool.workerPool.performJob(JobDescriptor(2, 1, \\\"ABC\\\"))\\n self.assertEquals(worker1.currentLoad, 1)\\n self.assertEquals(worker2.currentLoad, 1)\",\n \"async def test_unpacker_do_work_raise_exception(config, mocker, path_map_mock):\\n BUNDLE_OBJ = {\\n \\\"uuid\\\": \\\"f74db80e-9661-40cc-9f01-8d087af23f56\\\"\\n }\\n logger_mock = mocker.MagicMock()\\n lta_rc_mock = mocker.patch(\\\"rest_tools.client.RestClient.request\\\", new_callable=AsyncMock)\\n lta_rc_mock.return_value = {\\n \\\"bundle\\\": BUNDLE_OBJ,\\n }\\n dwb_mock = mocker.patch(\\\"lta.unpacker.Unpacker._do_work_bundle\\\", new_callable=AsyncMock)\\n dwb_mock.side_effect = Exception(\\\"LTA DB started on fire again\\\")\\n qb_mock = mocker.patch(\\\"lta.unpacker.Unpacker._quarantine_bundle\\\", new_callable=AsyncMock)\\n p = Unpacker(config, logger_mock)\\n with pytest.raises(Exception):\\n await p._do_work_claim()\\n lta_rc_mock.assert_called_with(\\\"POST\\\", '/Bundles/actions/pop?source=NERSC&dest=WIPAC&status=unpacking', mocker.ANY)\\n dwb_mock.assert_called_with(lta_rc_mock, BUNDLE_OBJ)\\n qb_mock.assert_called_with(lta_rc_mock, BUNDLE_OBJ, \\\"LTA DB started on fire again\\\")\",\n \"def test_get_worker_raw_config_None(self):\\n broker = FakeBroker()\\n worker = WorkerHelper.get_worker_raw(\\n BaseWorker, None, broker)\\n self.assertIsInstance(worker, BaseWorker)\\n self.assertIsInstance(worker._amqp_client, FakeAMQClient)\\n self.assertEqual(worker._amqp_client.broker, broker)\\n self.assertEqual(worker.config, {})\",\n \"async def test_exectution_limit_once(coresys: CoreSys, loop: asyncio.BaseEventLoop):\\n\\n class TestClass:\\n \\\"\\\"\\\"Test class.\\\"\\\"\\\"\\n\\n def __init__(self, coresys: CoreSys):\\n \\\"\\\"\\\"Initialize the test class.\\\"\\\"\\\"\\n self.coresys = coresys\\n self.run = asyncio.Lock()\\n\\n @Job(limit=JobExecutionLimit.ONCE, on_condition=JobException)\\n async def execute(self, sleep: float):\\n \\\"\\\"\\\"Execute the class method.\\\"\\\"\\\"\\n assert not self.run.locked()\\n async with self.run:\\n await asyncio.sleep(sleep)\\n\\n test = TestClass(coresys)\\n run_task = loop.create_task(test.execute(0.3))\\n\\n await asyncio.sleep(0.1)\\n with pytest.raises(JobException):\\n await test.execute(0.1)\\n\\n await run_task\",\n \"def test_create(self):\\n assert self.worker.connection is None or self.worker.connection.is_alive()\\n # TODO(orlade): Mock this stuff.\\n # assert_queue_size({TEST_REQUEST_QUEUE: 0, TEST_RESULT_QUEUE: 0})\",\n \"def restore(self, raw_data) -> Any:\\n obj = decode_redis_hash(raw_data)\\n try:\\n raw_data = obj['data']\\n except KeyError:\\n raise NoSuchJobError('Unexpected job format: {0}'.format(obj))\\n\\n try:\\n self.data = zlib.decompress(raw_data)\\n except zlib.error:\\n # Fallback to uncompressed string\\n self.data = raw_data\\n\\n self.created_at = str_to_date(obj.get('created_at'))\\n self.origin = as_text(obj.get('origin')) if obj.get('origin') else ''\\n self.worker_name = obj.get('worker_name').decode() if obj.get('worker_name') else None\\n self.description = as_text(obj.get('description')) if obj.get('description') else None\\n self.enqueued_at = str_to_date(obj.get('enqueued_at'))\\n self.started_at = str_to_date(obj.get('started_at'))\\n self.ended_at = str_to_date(obj.get('ended_at'))\\n self.last_heartbeat = str_to_date(obj.get('last_heartbeat'))\\n result = obj.get('result')\\n if result:\\n try:\\n self._result = self.serializer.loads(result)\\n except Exception:\\n self._result = UNSERIALIZABLE_RETURN_VALUE_PAYLOAD\\n self.timeout = parse_timeout(obj.get('timeout')) if obj.get('timeout') else None\\n self.result_ttl = int(obj.get('result_ttl')) if obj.get('result_ttl') else None\\n self.failure_ttl = int(obj.get('failure_ttl')) if obj.get('failure_ttl') else None\\n self._status = obj.get('status').decode() if obj.get('status') else None\\n\\n if obj.get('success_callback_name'):\\n self._success_callback_name = obj.get('success_callback_name').decode()\\n\\n if 'success_callback_timeout' in obj:\\n self._success_callback_timeout = int(obj.get('success_callback_timeout'))\\n\\n if obj.get('failure_callback_name'):\\n self._failure_callback_name = obj.get('failure_callback_name').decode()\\n\\n if 'failure_callback_timeout' in obj:\\n self._failure_callback_timeout = int(obj.get('failure_callback_timeout'))\\n\\n if obj.get('stopped_callback_name'):\\n self._stopped_callback_name = obj.get('stopped_callback_name').decode()\\n\\n if 'stopped_callback_timeout' in obj:\\n self._stopped_callback_timeout = int(obj.get('stopped_callback_timeout'))\\n\\n dep_ids = obj.get('dependency_ids')\\n dep_id = obj.get('dependency_id') # for backwards compatibility\\n self._dependency_ids = json.loads(dep_ids.decode()) if dep_ids else [dep_id.decode()] if dep_id else []\\n allow_failures = obj.get('allow_dependency_failures')\\n self.allow_dependency_failures = bool(int(allow_failures)) if allow_failures else None\\n self.enqueue_at_front = bool(int(obj['enqueue_at_front'])) if 'enqueue_at_front' in obj else None\\n self.ttl = int(obj.get('ttl')) if obj.get('ttl') else None\\n try:\\n self.meta = self.serializer.loads(obj.get('meta')) if obj.get('meta') else {}\\n except Exception: # depends on the serializer\\n self.meta = {'unserialized': obj.get('meta', {})}\\n\\n self.retries_left = int(obj.get('retries_left')) if obj.get('retries_left') else None\\n if obj.get('retry_intervals'):\\n self.retry_intervals = json.loads(obj.get('retry_intervals').decode())\\n\\n raw_exc_info = obj.get('exc_info')\\n if raw_exc_info:\\n try:\\n self._exc_info = as_text(zlib.decompress(raw_exc_info))\\n except zlib.error:\\n # Fallback to uncompressed string\\n self._exc_info = as_text(raw_exc_info)\",\n \"async def test_job_discarded(my_job):\\n\\n # Set up callback to get notifications when job state changes.\\n job = None\\n\\n def on_job_update(_job):\\n \\\"\\\"\\\"The callback to update `job`.\\\"\\\"\\\"\\n nonlocal job\\n job = _job\\n # Asserts that job is either pending or canceled.\\n assert job.state in ['PENDING', 'CANCELED'], (\\n 'Job that canceled immediately after submission has wrong '\\n f'state `{job.state}`!')\\n\\n my_job.set_on_update(on_job_update)\\n\\n # Submit a job.\\n new_job = await my_job.job(mustfail=False)\\n\\n # It must be canceled OK, because we are sure it has not started.\\n my_job.job_manager_class.cancel(new_job.id)\\n\\n # Process ASGI messages but do not wait for jobs (no jobs started).\\n await my_job.process_jobs()\\n\\n # Check a state of the job.\\n assert job.state == 'CANCELED', ('Canceled job has wrong state '\\n f'`{job.state}`!')\",\n \"def test_temporaryFailure(self):\\n dbpool, _ignore_qpool, clock, _ignore_performerChosen = self._setupPools()\\n fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)\\n\\n # Let's create a couple of work items directly, not via the enqueue\\n # method, so that they exist but nobody will try to immediately execute\\n # them.\\n\\n @transactionally(dbpool.pool.connection)\\n @inlineCallbacks\\n def setup(txn):\\n # Next, create failing work that's actually far enough into the past to run.\\n yield DummyWorkItem.makeJob(\\n txn, a=-2, b=1, notBefore=fakeNow - datetime.timedelta(20 * 60)\\n )\\n yield setup\\n clock.advance(20 - 12)\\n\\n @transactionally(dbpool.pool.connection)\\n def check(txn):\\n return JobItem.all(txn)\\n\\n jobs = yield check\\n self.assertTrue(len(jobs) == 1)\\n self.assertTrue(jobs[0].assigned is None)\\n self.assertEqual(jobs[0].isAssigned, 0)\\n self.assertTrue(jobs[0].failed == 1)\\n self.assertTrue(jobs[0].notBefore > datetime.datetime.utcnow() + datetime.timedelta(seconds=90))\",\n \"def test_notBeforeWhenCheckingForWork(self):\\n dbpool, _ignore_qpool, clock, _ignore_performerChosen = self._setupPools()\\n fakeNow = datetime.datetime(2012, 12, 12, 12, 12, 12)\\n\\n # Let's create a couple of work items directly, not via the enqueue\\n # method, so that they exist but nobody will try to immediately execute\\n # them.\\n\\n @transactionally(dbpool.pool.connection)\\n @inlineCallbacks\\n def setup(txn):\\n # First, one that's right now.\\n yield DummyWorkItem.makeJob(txn, a=1, b=2, notBefore=fakeNow)\\n\\n # Next, create one that's actually far enough into the past to run.\\n yield DummyWorkItem.makeJob(\\n txn, a=3, b=4, notBefore=(\\n # Schedule it in the past so that it should have already\\n # run.\\n fakeNow - datetime.timedelta(seconds=20)\\n )\\n )\\n\\n # Finally, one that's actually scheduled for the future.\\n yield DummyWorkItem.makeJob(\\n txn, a=10, b=20, notBefore=fakeNow + datetime.timedelta(1000)\\n )\\n yield setup\\n\\n # Wait for job\\n while len(DummyWorkItem.results) != 2:\\n clock.advance(1)\\n\\n # Work item complete\\n self.assertTrue(DummyWorkItem.results == {1: 3, 2: 7})\",\n \"def test_exception_raised_with_a_dlq():\\n proc: missive.Processor[missive.RawMessage] = missive.Processor()\\n dlq: missive.DLQ = {}\\n proc.set_dlq(dlq)\\n\\n @proc.handle_for(always)\\n def crash(message, ctx):\\n raise RuntimeError(\\\"bad bytes!\\\")\\n\\n with proc.test_client() as test_client:\\n blank_message = missive.RawMessage(b\\\"\\\")\\n test_client.send(blank_message)\\n assert dlq == {blank_message.message_id: (blank_message, \\\"bad bytes!\\\")}\\n assert blank_message in test_client.acked\",\n \"def _exceptionHandlingWorker(self, args):\\n self._doneFlag = False\\n self._abortedFlag = False\\n if not self._notifiersStarted:\\n self._startNotifiers()\\n\\n try:\\n self._worker(args)\\n except Exception as ex:\\n # print \\\"Exc\\\"\\n self._errorRaisedNotifier.notify(ex)\\n finally:\\n # print \\\"Finally\\\"\\n\\n if not self._mustBeAborted:\\n self._done()\\n else:\\n self._aborted()\\n\\n # print \\\"Before stop notifiers\\\"\\n if self._autoStopNotifiers:\\n try:\\n self.stopNotifiers()\\n except Exception as ex:\\n print ex\\n\\n\\n # print \\\"ExcWorkerDone\\\"\",\n \"def test_instance_fault_message_no_rescheduled_details_without_retry(self):\\n instance = self._create_fake_instance_obj()\\n\\n with mock.patch.object(self.compute.driver, 'spawn') as mock_spawn:\\n mock_spawn.side_effect = test.TestingException('Preserve this')\\n self.compute.build_and_run_instance(\\n self.context, instance, {}, {}, {}, [],\\n block_device_mapping=[])\\n self.assertEqual('Preserve this', instance.fault.message)\",\n \"def worker_errordown(self, node, error):\\n self.config.hook.pytest_testnodedown(node=node, error=error)\\n try:\\n crashitem = self.sched.remove_node(node)\\n except KeyError:\\n pass\\n else:\\n if crashitem:\\n self.handle_crashitem(crashitem, node)\\n\\n self._failed_nodes_count += 1\\n maximum_reached = (\\n self._max_worker_restart is not None\\n and self._failed_nodes_count > self._max_worker_restart\\n )\\n if maximum_reached:\\n if self._max_worker_restart == 0:\\n msg = \\\"worker {} crashed and worker restarting disabled\\\".format(\\n node.gateway.id\\n )\\n else:\\n msg = \\\"maximum crashed workers reached: %d\\\" % self._max_worker_restart\\n self._summary_report = msg\\n self.report_line(\\\"\\\\n\\\" + msg)\\n self.triggershutdown()\\n else:\\n self.report_line(\\\"\\\\nreplacing crashed worker %s\\\" % node.gateway.id)\\n self.shuttingdown = False\\n self._clone_node(node)\\n self._active_nodes.remove(node)\",\n \"def test_job_fail(self):\\n with self.settings(JOBS_ROOT=os.path.join(settings.BASE_DIR, \\\"extras/tests/dummy_jobs\\\")):\\n\\n module = \\\"test_fail\\\"\\n name = \\\"TestFail\\\"\\n job_class = get_job(f\\\"local/{module}/{name}\\\")\\n job_result = JobResult.objects.create(\\n name=job_class.class_path,\\n obj_type=self.job_content_type,\\n user=None,\\n job_id=uuid.uuid4(),\\n )\\n run_job(data={}, request=None, commit=False, job_result_pk=job_result.pk)\\n job_result.refresh_from_db()\\n self.assertEqual(job_result.status, JobResultStatusChoices.STATUS_ERRORED)\",\n \"def test_run_job_fail(self):\\n with self.settings(JOBS_ROOT=os.path.join(settings.BASE_DIR, \\\"extras/tests/dummy_jobs\\\")):\\n job_name = \\\"local/test_file_upload_fail/TestFileUploadFail\\\"\\n job_class = get_job(job_name)\\n\\n job_result = JobResult.objects.create(\\n name=job_class.class_path,\\n obj_type=self.job_content_type,\\n user=None,\\n job_id=uuid.uuid4(),\\n )\\n\\n # Serialize the file to FileProxy\\n data = {\\\"file\\\": self.dummy_file}\\n form = job_class().as_form(files=data)\\n self.assertTrue(form.is_valid())\\n serialized_data = job_class.serialize_data(form.cleaned_data)\\n\\n # Assert that the file was serialized to a FileProxy\\n self.assertTrue(isinstance(serialized_data[\\\"file\\\"], uuid.UUID))\\n self.assertEqual(serialized_data[\\\"file\\\"], FileProxy.objects.latest().pk)\\n self.assertEqual(FileProxy.objects.count(), 1)\\n\\n # Run the job\\n run_job(data=serialized_data, request=None, commit=False, job_result_pk=job_result.pk)\\n job_result.refresh_from_db()\\n\\n # Assert that file contents were correctly read\\n self.assertEqual(\\n job_result.data[\\\"run\\\"][\\\"log\\\"][0][2], f\\\"File contents: {self.file_contents}\\\" # \\\"File contents: ...\\\"\\n )\\n # Also ensure the standard log message about aborting the transaction is present\\n self.assertEqual(job_result.data[\\\"run\\\"][\\\"log\\\"][-1][-1], \\\"Database changes have been reverted due to error.\\\")\\n\\n # Assert that FileProxy was cleaned up\\n self.assertEqual(FileProxy.objects.count(), 0)\",\n \"def testA_StraightThrough(self):\\n # Do pre-submit job check\\n nRunning = getCondorRunningJobs()\\n self.assertEqual(nRunning, 0, \\\"User currently has %i running jobs. Test will not continue\\\" % (nRunning))\\n\\n myThread = threading.currentThread()\\n workload = self.createTestWorkload()\\n config = self.getConfig()\\n\\n\\n name = 'WMAgent_Test1'\\n site = self.sites[0]\\n nSubs = 5\\n nFiles = 10\\n workloadPath = os.path.join(self.testDir, 'workloadTest',\\n 'TestWorkload', 'WMSandbox',\\n 'WMWorkload.pkl')\\n\\n # Create a collection of files\\n self.createFileCollection(name = name, nSubs = nSubs,\\n nFiles = nFiles,\\n workflowURL = workloadPath,\\n site = site)\\n\\n\\n\\n ############################################################\\n # Test the JobCreator\\n\\n\\n config.Agent.componentName = 'JobCreator'\\n testJobCreator = JobCreatorPoller(config = config)\\n\\n testJobCreator.algorithm()\\n time.sleep(5)\\n\\n\\n # Did all jobs get created?\\n getJobsAction = self.daoFactory(classname = \\\"Jobs.GetAllJobs\\\")\\n result = getJobsAction.execute(state = 'Created', jobType = \\\"Processing\\\")\\n self.assertEqual(len(result), nSubs*nFiles)\\n\\n\\n # Count database objects\\n result = myThread.dbi.processData('SELECT * FROM wmbs_sub_files_acquired')[0].fetchall()\\n self.assertEqual(len(result), nSubs * nFiles)\\n\\n\\n # Find the test directory\\n testDirectory = os.path.join(self.testDir, 'TestWorkload', 'ReReco')\\n self.assertTrue('JobCollection_1_0' in os.listdir(testDirectory))\\n self.assertTrue(len(os.listdir(testDirectory)) <= 20)\\n\\n groupDirectory = os.path.join(testDirectory, 'JobCollection_1_0')\\n\\n # First job should be in here\\n self.assertTrue('job_1' in os.listdir(groupDirectory))\\n jobFile = os.path.join(groupDirectory, 'job_1', 'job.pkl')\\n self.assertTrue(os.path.isfile(jobFile))\\n with open(jobFile, 'rb') as f:\\n job = pickle.load(f)\\n\\n\\n self.assertEqual(job['workflow'], name)\\n self.assertEqual(len(job['input_files']), 1)\\n self.assertEqual(os.path.basename(job['sandbox']), 'TestWorkload-Sandbox.tar.bz2')\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n ###############################################################\\n # Now test the JobSubmitter\\n\\n config.Agent.componentName = 'JobSubmitter'\\n testJobSubmitter = JobSubmitterPoller(config = config)\\n\\n\\n testJobSubmitter.algorithm()\\n\\n\\n # Check that jobs are in the right state\\n result = getJobsAction.execute(state = 'Created', jobType = \\\"Processing\\\")\\n self.assertEqual(len(result), 0)\\n result = getJobsAction.execute(state = 'Executing', jobType = \\\"Processing\\\")\\n self.assertEqual(len(result), nSubs * nFiles)\\n\\n\\n\\n # Check assigned locations\\n getLocationAction = self.daoFactory(classname = \\\"Jobs.GetLocation\\\")\\n for id in result:\\n loc = getLocationAction.execute(jobid = id)\\n self.assertEqual(loc, [[site]])\\n\\n\\n # Check to make sure we have running jobs\\n nRunning = getCondorRunningJobs()\\n self.assertEqual(nRunning, nFiles * nSubs)\\n\\n\\n #################################################################\\n # Now the JobTracker\\n\\n\\n config.Agent.componentName = 'JobTracker'\\n testJobTracker = JobTrackerPoller(config = config)\\n testJobTracker.setup()\\n\\n testJobTracker.algorithm()\\n\\n # Running the algo without removing the jobs should do nothing\\n result = getJobsAction.execute(state = 'Executing', jobType = \\\"Processing\\\")\\n self.assertEqual(len(result), nSubs * nFiles)\\n\\n\\n condorRM()\\n time.sleep(1)\\n\\n # All jobs gone?\\n nRunning = getCondorRunningJobs()\\n self.assertEqual(nRunning, 0)\\n\\n\\n testJobTracker.algorithm()\\n time.sleep(5)\\n\\n # Running the algo without removing the jobs should do nothing\\n result = getJobsAction.execute(state = 'Executing', jobType = \\\"Processing\\\")\\n self.assertEqual(len(result), 0)\\n result = getJobsAction.execute(state = 'Complete', jobType = \\\"Processing\\\")\\n self.assertEqual(len(result), nSubs * nFiles)\\n\\n\\n\\n\\n #################################################################\\n # Now the JobAccountant\\n\\n # First you need to load all jobs\\n\\n\\n self.getFWJRAction = self.daoFactory(classname = \\\"Jobs.GetFWJRByState\\\")\\n completeJobs = self.getFWJRAction.execute(state = \\\"complete\\\")\\n\\n\\n # Create reports for all jobs\\n self.createReports(jobs = completeJobs, retryCount = 0)\\n\\n\\n\\n\\n\\n\\n config.Agent.componentName = 'JobAccountant'\\n testJobAccountant = JobAccountantPoller(config = config)\\n testJobAccountant.setup()\\n\\n\\n # It should do something with the jobs\\n testJobAccountant.algorithm()\\n\\n\\n # All the jobs should be done now\\n result = getJobsAction.execute(state = 'Complete', jobType = \\\"Processing\\\")\\n self.assertEqual(len(result), 0)\\n result = getJobsAction.execute(state = 'Success', jobType = \\\"Processing\\\")\\n self.assertEqual(len(result), nSubs * nFiles)\\n\\n\\n\\n #######################################################################\\n # Now the JobArchiver\\n\\n\\n config.Agent.componentName = 'JobArchiver'\\n testJobArchiver = JobArchiverPoller(config = config)\\n\\n\\n testJobArchiver.algorithm()\\n\\n # All the jobs should be cleaned up\\n result = getJobsAction.execute(state = 'Success', jobType = \\\"Processing\\\")\\n self.assertEqual(len(result), 0)\\n result = getJobsAction.execute(state = 'Cleanout', jobType = \\\"Processing\\\")\\n self.assertEqual(len(result), nSubs * nFiles)\\n\\n\\n logDir = os.path.join(self.testDir, 'logs')\\n\\n for job in completeJobs:\\n self.assertFalse(os.path.exists(job['fwjr_path']))\\n jobFolder = 'JobCluster_%i' \\\\\\n % (int(job['id']/config.JobArchiver.numberOfJobsToCluster))\\n jobPath = os.path.join(logDir, jobFolder, 'Job_%i.tar' %(job['id']))\\n self.assertTrue(os.path.isfile(jobPath))\\n self.assertTrue(os.path.getsize(jobPath) > 0)\\n\\n\\n\\n\\n ###########################################################################\\n # Now the TaskAchiver\\n\\n\\n config.Agent.componentName = 'TaskArchiver'\\n testTaskArchiver = TaskArchiverPoller(config = config)\\n\\n\\n testTaskArchiver.algorithm()\\n\\n\\n result = getJobsAction.execute(state = 'Cleanout', jobType = \\\"Processing\\\")\\n self.assertEqual(len(result), 0)\\n\\n\\n for jdict in completeJobs:\\n job = Job(id = jdict['id'])\\n self.assertFalse(job.exists())\\n\\n\\n\\n\\n\\n if os.path.isdir('testDir'):\\n shutil.rmtree('testDir')\\n shutil.copytree('%s' %self.testDir, os.path.join(os.getcwd(), 'testDir'))\\n\\n\\n\\n\\n return\",\n \"def test_invalid_process_number():\\n\\n with pytest.raises(ValueError):\\n get_reusable_executor(max_workers=0)\\n\\n with pytest.raises(ValueError):\\n get_reusable_executor(max_workers=-1)\",\n \"def test_execute_get_exception():\\n message = FakeMessage()\\n message.raw_payload = json.dumps(TestData.JOB_TEMPLATE_PAYLOAD_SINGLE_PAGE_GZIPPED)\\n with aioresponses() as mocked:\\n mocked.get(\\n TestData.JOB_TEMPLATES_LIST_URL, status=400, body=\\\"Bad Request in Get Call\\\"\\n )\\n with pytest.raises(Exception) as excinfo:\\n worker.execute(message, TestData.RECEPTOR_CONFIG, queue.Queue())\\n assert \\\"Bad Request in Get Call\\\" in str(excinfo.value)\",\n \"def test_exception_execution(self):\\r\\n a_thread = workerthread.WorkerThread(exception_queue=self.exception_queue,\\r\\n return_queue=self.message_queue,\\r\\n target=self.sample_exception_function, args=(1, 2))\\r\\n a_thread.start()\\r\\n a_thread.join()\\r\\n exc_type, exc = self.exception_queue.get()\\r\\n self.assertTrue(isinstance(exc, Exception))\",\n \"def test_block_missing_batch(self):\\n pass\",\n \"def test_stuff_in_queues_integrated(integrated_ff):\\n search_res = ff_utils.search_metadata('search/?limit=all&type=File', key=integrated_ff['ff_key'])\\n # just take the first handful\\n for item in search_res[:8]:\\n ff_utils.patch_metadata({}, obj_id=item['uuid'], key=integrated_ff['ff_key'])\\n time.sleep(3) # let queues catch up\\n stuff_in_queue = ff_utils.stuff_in_queues(integrated_ff['ff_env_index_namespace'], check_secondary=True)\\n assert stuff_in_queue\\n with pytest.raises(Exception) as exec_info:\\n ff_utils.stuff_in_queues(None, check_secondary=True) # fail if no env specified\\n assert 'Must provide a full fourfront environment name' in str(exec_info.value)\",\n \"async def test_unpacker_run_exception(config, mocker, path_map_mock):\\n logger_mock = mocker.MagicMock()\\n p = Unpacker(config, logger_mock)\\n p.last_work_end_timestamp = None\\n p._do_work = AsyncMock()\\n p._do_work.side_effect = [Exception(\\\"bad thing happen!\\\")]\\n await p.run()\\n p._do_work.assert_called()\\n assert p.last_work_end_timestamp\",\n \"def __init__(self, serial_number, output_root, test_events, expected_result):\\n self.serial_number = serial_number\\n self.output_root = output_root\\n self.cmd_string_replacements = {}\\n self.iteration = 0\\n self.cmd_string_replacements[\\\"iteration\\\"] = 0\\n self.cmd_string_replacements[\\\"serial_number\\\"] = serial_number\\n self.cmd_string_replacements[\\\"output_root\\\"] = output_root\\n self.name = None\\n self.process_loggers = []\\n self.event_log = stress_test_pb2.EventLog()\\n self.cnt_per_iteration = expected_result\\n\\n # Prepare the work queue, and offload the rest of the init into it.\\n self.work_queue = queue.Queue()\\n self.worker = threading.Thread(target=QueueWorker, args=[self.work_queue])\\n self.worker.daemon = True\\n self.worker.name = self.name\\n self.worker.start()\\n self.abort_requested = False\\n self.remove_device = False\\n self.test_events = test_events\\n\\n self.work_queue.put(self.__init_async__)\",\n \"def test_nextjob(self):\\n\\n dbpool = buildConnectionPool(self, jobSchema + schemaText)\\n now = datetime.datetime.utcnow()\\n\\n # Empty job queue\\n @inlineCallbacks\\n def _next(txn, priority=WORK_PRIORITY_LOW):\\n job = yield JobItem.nextjob(txn, now, priority, 1)\\n if job is not None:\\n work = yield job.workItem()\\n else:\\n work = None\\n returnValue((job, work))\\n job, work = yield inTransaction(dbpool.connection, _next)\\n self.assertTrue(job is None)\\n self.assertTrue(work is None)\\n\\n # Unassigned job with future notBefore not returned\\n yield self._enqueue(dbpool, 1, 1, now + datetime.timedelta(days=1))\\n job, work = yield inTransaction(dbpool.connection, _next)\\n self.assertTrue(job is None)\\n self.assertTrue(work is None)\\n\\n # Unassigned job with past notBefore returned\\n yield self._enqueue(dbpool, 2, 1, now + datetime.timedelta(days=-1), priority=WORK_PRIORITY_HIGH)\\n job, work = yield inTransaction(dbpool.connection, _next)\\n self.assertTrue(job is not None)\\n self.assertTrue(work.a == 2)\\n assignID = job.jobID\\n\\n # Assigned job with past notBefore not returned\\n @inlineCallbacks\\n def assignJob(txn, when=None):\\n assignee = yield JobItem.load(txn, assignID)\\n yield assignee.assign(now if when is None else when, ControllerQueue.queueOverdueTimeout)\\n yield inTransaction(dbpool.connection, assignJob)\\n job, work = yield inTransaction(dbpool.connection, _next)\\n self.assertTrue(job is None)\\n self.assertTrue(work is None)\\n\\n # Unassigned, paused job with past notBefore not returned\\n yield self._enqueue(dbpool, 3, 1, now + datetime.timedelta(days=-1), priority=WORK_PRIORITY_HIGH)\\n @inlineCallbacks\\n def pauseJob(txn, pause=True):\\n works = yield DummyWorkItem.all(txn)\\n for work in works:\\n if work.a == 3:\\n job = yield JobItem.load(txn, work.jobID)\\n yield job.pauseIt(pause)\\n yield inTransaction(dbpool.connection, pauseJob)\\n job, work = yield inTransaction(dbpool.connection, _next)\\n self.assertTrue(job is None)\\n self.assertTrue(work is None)\\n\\n # Unassigned, paused then unpaused job with past notBefore is returned\\n yield inTransaction(dbpool.connection, pauseJob, pause=False)\\n job, work = yield inTransaction(dbpool.connection, _next)\\n self.assertTrue(job is not None)\\n self.assertTrue(work.a == 3)\\n @inlineCallbacks\\n def deleteJob(txn, jobID):\\n job = yield JobItem.load(txn, jobID)\\n yield job.delete()\\n yield inTransaction(dbpool.connection, deleteJob, jobID=job.jobID)\\n\\n # Unassigned low priority job with past notBefore not returned if high priority required\\n yield self._enqueue(dbpool, 4, 1, now + datetime.timedelta(days=-1))\\n job, work = yield inTransaction(dbpool.connection, _next, priority=WORK_PRIORITY_HIGH)\\n self.assertTrue(job is None)\\n self.assertTrue(work is None)\\n\\n # Unassigned low priority job with past notBefore not returned if medium priority required\\n yield self._enqueue(dbpool, 5, 1, now + datetime.timedelta(days=-1))\\n job, work = yield inTransaction(dbpool.connection, _next, priority=WORK_PRIORITY_MEDIUM)\\n self.assertTrue(job is None)\\n self.assertTrue(work is None)\\n\\n # Assigned job with past notBefore, but overdue is not returned\\n yield inTransaction(dbpool.connection, assignJob, when=now + datetime.timedelta(days=-1))\\n job, work = yield inTransaction(dbpool.connection, _next, priority=WORK_PRIORITY_HIGH)\\n self.assertTrue(job is None)\\n self.assertTrue(work is None)\",\n \"def test_execute_with_invalid_config_get_exception():\\n message = FakeMessage()\\n message.raw_payload = json.dumps(TestData.JOB_TEMPLATE_PAYLOAD_SINGLE_PAGE_GZIPPED)\\n with aioresponses():\\n with pytest.raises(Exception) as excinfo:\\n worker.execute(message, TestData.RECEPTOR_CONFIG_INVALID, queue.Queue())\\n assert \\\"token or username and password\\\" in str(excinfo.value)\",\n \"def test_cleanup_worker(self):\\n worker_stop_d = Deferred()\\n worker = FakeWorker(stop_d=worker_stop_d)\\n worker_helper = WorkerHelper()\\n worker_helper._workers.append(worker)\\n d = worker_helper.cleanup_worker(worker)\\n self.assertEqual(worker_helper._workers, [])\\n self.assertEqual(d, worker_stop_d)\",\n \"def test_terminate_run(self):\\n pass\",\n \"def test_unexpected_error_in_processor(self):\\n\\n one_process_workflow = \\\"\\\"\\\"file://B <- file://A ! buggy_processor\\n echo A does not produce B\\n \\\"\\\"\\\"\\n process = run_first_process(one_process_workflow, BuggyProcessor())\\n assert process.success is False, process.error_message\\n assert process.error_message.find('An unexpected error have happen in tuttle processor '\\n 'buggy_processor :') >= 0, process.error_message\\n assert process.error_message.find('Traceback (most recent call last):') >= 0, process.error_message\\n assert process.error_message.find('raise Exception(\\\"Unexpected error in processor\\\")') >= 0, process.error_message\\n assert process.error_message.find('will not complete.') >= 0, process.error_message\",\n \"def testJobKilling(self):\\n change = ChangeState(self.config, \\\"changestate_t\\\")\\n\\n locationAction = self.daoFactory(classname=\\\"Locations.New\\\")\\n locationAction.execute(\\\"site1\\\", pnn=\\\"T2_CH_CERN\\\")\\n\\n testWorkflow = Workflow(spec=self.specUrl, owner=\\\"Steve\\\",\\n name=\\\"wf001\\\", task=self.taskName)\\n testWorkflow.create()\\n testFileset = Fileset(name=\\\"TestFileset\\\")\\n testFileset.create()\\n\\n for i in range(4):\\n newFile = File(lfn=\\\"File%s\\\" % i, locations=set([\\\"T2_CH_CERN\\\"]))\\n newFile.create()\\n testFileset.addFile(newFile)\\n\\n testFileset.commit()\\n testSubscription = Subscription(fileset=testFileset,\\n workflow=testWorkflow,\\n split_algo=\\\"FileBased\\\")\\n testSubscription.create()\\n\\n splitter = SplitterFactory()\\n jobFactory = splitter(package=\\\"WMCore.WMBS\\\",\\n subscription=testSubscription)\\n jobGroup = jobFactory(files_per_job=1)[0]\\n\\n assert len(jobGroup.jobs) == 4, \\\\\\n \\\"Error: Splitting should have created four jobs.\\\"\\n\\n testJobA = jobGroup.jobs[0]\\n testJobA[\\\"user\\\"] = \\\"sfoulkes\\\"\\n testJobA[\\\"group\\\"] = \\\"DMWM\\\"\\n testJobA[\\\"taskType\\\"] = \\\"Processing\\\"\\n testJobB = jobGroup.jobs[1]\\n testJobB[\\\"user\\\"] = \\\"sfoulkes\\\"\\n testJobB[\\\"group\\\"] = \\\"DMWM\\\"\\n testJobB[\\\"taskType\\\"] = \\\"Processing\\\"\\n testJobC = jobGroup.jobs[2]\\n testJobC[\\\"user\\\"] = \\\"sfoulkes\\\"\\n testJobC[\\\"group\\\"] = \\\"DMWM\\\"\\n testJobC[\\\"taskType\\\"] = \\\"Processing\\\"\\n testJobD = jobGroup.jobs[3]\\n testJobD[\\\"user\\\"] = \\\"sfoulkes\\\"\\n testJobD[\\\"group\\\"] = \\\"DMWM\\\"\\n testJobD[\\\"taskType\\\"] = \\\"Processing\\\"\\n\\n change.persist([testJobA], \\\"created\\\", \\\"new\\\")\\n change.persist([testJobB], \\\"jobfailed\\\", \\\"executing\\\")\\n change.persist([testJobC, testJobD], \\\"executing\\\", \\\"created\\\")\\n\\n change.persist([testJobA], \\\"killed\\\", \\\"created\\\")\\n change.persist([testJobB], \\\"killed\\\", \\\"jobfailed\\\")\\n change.persist([testJobC, testJobD], \\\"killed\\\", \\\"executing\\\")\\n\\n for job in [testJobA, testJobB, testJobC, testJobD]:\\n job.load()\\n self.assertEqual(job['retry_count'], 99999)\\n self.assertEqual(job['state'], 'killed')\\n\\n return\",\n \"def test_local_job(self):\\r\\n exp = \\\"abc; echo $? > xyz\\\"\\r\\n obs = local_job('abc', 'xyz', 'notused', 'notused')\\r\\n self.assertEqual(obs, exp)\",\n \"def testJobPostponedInspection(databases):\\n\\n class CustomGenerator(DataGenerator):\\n pass\\n gen = CustomGenerator(databases)\\n\\n image = gen.createProduct('image')\\n buildFw = gen.createFramework('build', [], [ image ])\\n testFw = gen.createFramework('test', [ image ], [])\\n buildTask = gen.createTask('build', buildFw)\\n testTask1 = gen.createTask('test1', testFw)\\n testTask2 = gen.createTask('test2', testFw)\\n testTask3 = gen.createTask('test3', testFw)\\n\\n tr = gen.createTaskRunner(name='tr_build',\\n capabilities=['build', 'test'])\\n\\n def simulate(config):\\n sanityCheck(gen, config)\\n\\n job, = config.createJobs(gen.owner)\\n # TODO: The toXML functionality should probably be tested\\n # in a separate test case.\\n\\n # Verify execution:\\n # Successfully complete first build task.\\n task = job.assignTask(databases.resourceDB[tr])\\n assert task is not None\\n assert task.getName() == buildTask\\n taskDone(job, buildTask)\\n assert job.result == ResultCode.OK\\n assert job.getFinalResult() == None\\n # Successfully complete first test task, without result.\\n task = job.assignTask(databases.resourceDB[tr])\\n assert (task is not None) is not None\\n assert task.getName() == testTask1\\n taskDone(job, testTask1, ResultCode.INSPECT)\\n assert not job.isExecutionFinished()\\n assert not job.hasFinalResult()\\n assert job.result == ResultCode.INSPECT\\n assert job.getFinalResult() is None\\n # Successfully complete second test task, with result.\\n task = job.assignTask(databases.resourceDB[tr])\\n assert task is not None\\n assert task.getName() == testTask2\\n taskDone(job, testTask2, ResultCode.OK)\\n assert not job.isExecutionFinished()\\n assert not job.hasFinalResult()\\n assert job.result == ResultCode.INSPECT\\n assert job.getFinalResult() is None\\n # Successfully complete third test task, without result.\\n task = job.assignTask(databases.resourceDB[tr])\\n assert task is not None\\n assert task.getName() == testTask3\\n taskDone(job, testTask3, ResultCode.INSPECT)\\n assert job.isExecutionFinished()\\n assert not job.hasFinalResult()\\n assert job.result == ResultCode.INSPECT\\n assert job.getFinalResult() is None\\n # Attempt to set invalid inspection result.\\n with raises(ValueError):\\n job.inspectDone(testTask1, ResultCode.CANCELLED, 'invalid')\\n # Complete inspection of first task.\\n job.inspectDone(testTask1, ResultCode.WARNING, 'inspect 1')\\n assert job.isExecutionFinished()\\n assert not job.hasFinalResult()\\n assert job.result == ResultCode.INSPECT\\n assert job.getFinalResult() is None\\n # Attempt to change inspection result.\\n with raises(IllegalStateError):\\n job.inspectDone(testTask1, ResultCode.OK, 'invalid')\\n # Complete inspection of third task.\\n job.inspectDone(testTask3, ResultCode.OK, 'inspect 3')\\n assert job.isExecutionFinished()\\n assert job.hasFinalResult()\\n assert job.result == ResultCode.WARNING\\n assert job.getFinalResult() == ResultCode.WARNING\\n\\n runWithReload(databases, gen.createConfiguration(), simulate)\",\n \"def test_error_prefork(self, mocker):\\n expected_msg = [\\n mocker.call('Cannot call resume')\\n ]\\n\\n filename = os.path.join(os.path.dirname(__file__), '../integration/files', 'file2.yaml')\\n factory = get_factory('localhost', config={'splitFile': filename})\\n try:\\n factory.block_until_ready(1)\\n except:\\n pass\\n _logger = mocker.Mock()\\n mocker.patch('splitio.client.factory._LOGGER', new=_logger)\\n factory.resume()\\n assert _logger.warning.mock_calls == expected_msg\\n factory.destroy()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6359065","0.6358153","0.6343971","0.62961966","0.62398404","0.62254554","0.6220339","0.6151781","0.6128433","0.61171836","0.61096936","0.61035645","0.6060205","0.6046334","0.60378677","0.60087585","0.6002686","0.5972724","0.5961226","0.5950227","0.59496874","0.5941109","0.5936259","0.592552","0.59024215","0.5892207","0.5889826","0.58727384","0.5872197","0.58642906","0.58607817","0.58535314","0.58516145","0.5843723","0.5838623","0.5833721","0.58289146","0.5826105","0.58077896","0.5801978","0.5788691","0.5778753","0.5767043","0.5753795","0.57390827","0.5729053","0.5727559","0.5724904","0.57078844","0.5705842","0.5695027","0.5692754","0.56915164","0.56812835","0.566887","0.56686056","0.5646321","0.5614942","0.5603663","0.56027263","0.5591776","0.5590025","0.5589838","0.55836","0.5582973","0.5576002","0.55712116","0.55702454","0.5560657","0.5541569","0.55404","0.55256116","0.5519618","0.55117065","0.5511661","0.5492687","0.5482799","0.54808766","0.54779994","0.54729724","0.54721385","0.54590714","0.54450226","0.5442662","0.5425744","0.54231","0.5422578","0.54153234","0.5411417","0.5407024","0.54067814","0.53960884","0.53956115","0.53955895","0.53901625","0.5387966","0.53796864","0.53783196","0.53765345","0.53748643"],"string":"[\n \"0.6359065\",\n \"0.6358153\",\n \"0.6343971\",\n \"0.62961966\",\n \"0.62398404\",\n \"0.62254554\",\n \"0.6220339\",\n \"0.6151781\",\n \"0.6128433\",\n \"0.61171836\",\n \"0.61096936\",\n \"0.61035645\",\n \"0.6060205\",\n \"0.6046334\",\n \"0.60378677\",\n \"0.60087585\",\n \"0.6002686\",\n \"0.5972724\",\n \"0.5961226\",\n \"0.5950227\",\n \"0.59496874\",\n \"0.5941109\",\n \"0.5936259\",\n \"0.592552\",\n \"0.59024215\",\n \"0.5892207\",\n \"0.5889826\",\n \"0.58727384\",\n \"0.5872197\",\n \"0.58642906\",\n \"0.58607817\",\n \"0.58535314\",\n \"0.58516145\",\n \"0.5843723\",\n \"0.5838623\",\n \"0.5833721\",\n \"0.58289146\",\n \"0.5826105\",\n \"0.58077896\",\n \"0.5801978\",\n \"0.5788691\",\n \"0.5778753\",\n \"0.5767043\",\n \"0.5753795\",\n \"0.57390827\",\n \"0.5729053\",\n \"0.5727559\",\n \"0.5724904\",\n \"0.57078844\",\n \"0.5705842\",\n \"0.5695027\",\n \"0.5692754\",\n \"0.56915164\",\n \"0.56812835\",\n \"0.566887\",\n \"0.56686056\",\n \"0.5646321\",\n \"0.5614942\",\n \"0.5603663\",\n \"0.56027263\",\n \"0.5591776\",\n \"0.5590025\",\n \"0.5589838\",\n \"0.55836\",\n \"0.5582973\",\n \"0.5576002\",\n \"0.55712116\",\n \"0.55702454\",\n \"0.5560657\",\n \"0.5541569\",\n \"0.55404\",\n \"0.55256116\",\n \"0.5519618\",\n \"0.55117065\",\n \"0.5511661\",\n \"0.5492687\",\n \"0.5482799\",\n \"0.54808766\",\n \"0.54779994\",\n \"0.54729724\",\n \"0.54721385\",\n \"0.54590714\",\n \"0.54450226\",\n \"0.5442662\",\n \"0.5425744\",\n \"0.54231\",\n \"0.5422578\",\n \"0.54153234\",\n \"0.5411417\",\n \"0.5407024\",\n \"0.54067814\",\n \"0.53960884\",\n \"0.53956115\",\n \"0.53955895\",\n \"0.53901625\",\n \"0.5387966\",\n \"0.53796864\",\n \"0.53783196\",\n \"0.53765345\",\n \"0.53748643\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74951327"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92094,"cells":{"query":{"kind":"string","value":"Initialize local storage of active agents, connect to the database"},"document":{"kind":"string","value":"def __init__(self, datastore_root: str):\n self.session_storage: Dict[str, ProlificClient] = {}\n self.agent_data: Dict[str, Dict[str, Any]] = {}\n self.table_access_condition = threading.Condition()\n self.conn: Dict[int, sqlite3.Connection] = {}\n self.db_path = os.path.join(datastore_root, f\"{PROVIDER_TYPE}.db\")\n self.init_tables()\n self.datastore_root = datastore_root\n self._last_study_mapping_update_times: Dict[str, float] = defaultdict(\n lambda: time.monotonic()\n )"},"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 initialize_database():\n # TODO: Refactor the funtime library\n this.db = Store(this.host).create_lib(this.store_name).get_store()","def init_database():\n exists = Agent.query.all()\n if exists is None or len(exists) == 0:\n # Setting up agent\n agent = Agent(name='OpenCampus',\n about=\"Este es el chabot de Open Campus capaz de resolver dudas sobre los diferentes cursos de la oferta actual de Open Campus\")\n\n db.session.add(agent)\n\n # Setting upd properties\n\n description_prop = Property(name=\"http://127.0.0.1/ockb/course/ontology/description\")\n begin_date_prop = Property(name=\"http://127.0.0.1/ockb/course/ontology/beginDate\")\n end_date_prop = Property(name=\"http://127.0.0.1/ockb/course/ontology/endDate\")\n requirement_prop = Property(name=\"http://127.0.0.1/ockb/course/ontology/requirement\")\n duration_prop = Property(name=\"http://127.0.0.1/ockb/course/ontology/duration\")\n cost_prop = Property(name=\"http://127.0.0.1/ockb/course/ontology/cost\")\n teacher_name_prop = Property(name=\"http://127.0.0.1/ockb/course/ontology/teacherName\")\n content_name_prop = Property(name=\"http://127.0.0.1/ockb/course/ontology/content\")\n course_name_prop = Property(name=\"http://127.0.0.1/ockb/course/ontology/courseName\")\n\n # db.session.add(description_prop)\n # db.session.add(begin_date_prop)\n # db.session.add(end_date_prop)\n # db.session.add(requirement_prop)\n # db.session.add(duration_prop)\n # db.session.add(cost_prop)\n # db.session.add(teacher_name_prop)\n # db.session.add(content_name_prop)\n # db.session.add(course_name_prop)\n\n # Setting up answers\n\n ObtenerInformacionAnswer = Answer(uri=\"ObtenerInformacionAnswer\", answer_template=\"{%description%}\",\n properties=[description_prop])\n\n # db.session.add(ObtenerInformacionAnswer)\n ObtenerFechasAnswer = Answer(uri=\"ObtenerFechasAnswer\",\n answer_template=\"Las fechas importantes del curso son {%beginDate%} y termina el dia {%endDate%}\",\n properties=[begin_date_prop, end_date_prop])\n\n # db.session.add(ObtenerFechasAnswer)\n ObtenerFechasInicioAnswer = Answer(uri=\"ObtenerFechasInicioAnswer\",\n answer_template=\"El curso inicia el dia {%beginDate%}\",\n properties=[begin_date_prop])\n # db.session.add(ObtenerFechasInicioAnswer)\n ObtenerFechasFinAnswer = Answer(uri=\"ObtenerFechasFinAnswer\",\n answer_template=\"El curso finaliza el dia {%endDate%}\",\n properties=[end_date_prop])\n # db.session.add(ObtenerFechasFinAnswer)\n ObtenerPrerequisitosAnswer = Answer(uri=\"ObtenerPrerequisitosAnswer\",\n answer_template=\"Los prerequisitos del curso son {%requirement%}\",\n properties=[requirement_prop])\n # db.session.add(ObtenerPrerequisitosAnswer)\n ObtenerDuracionAnswer = Answer(uri=\"ObtenerDuracionAnswer\",\n answer_template=\"El curso tiene una duracion de {%duration%}\",\n properties=[duration_prop])\n # db.session.add(ObtenerDuracionAnswer)\n ObtenerPrecioAnswer = Answer(uri=\"ObtenerPrecioAnswer\", answer_template=\"{%cost%}\", properties=[cost_prop])\n # db.session.add(ObtenerPrecioAnswer)\n ObtenerDocenteAnswer = Answer(uri=\"ObtenerDocenteAnswer\",\n answer_template=\"El docente encargado del curso es {%teacherName%}\",\n properties=[teacher_name_prop],\n refers_to=\"http://127.0.0.1/ockb/course/ontology/hasTeacher\")\n # db.session.add(ObtenerDocenteAnswer)\n ObtenerContenidosAnswer = Answer(uri=\"ObtenerContenidosAnswer\",\n answer_template=\"Los contenidos a tratar en el curso son {%content%}\",\n properties=[content_name_prop],\n refers_to=\"http://127.0.0.1/ockb/course/ontology/hasContenido\")\n # db.session.add(ObtenerContenidosAnswer)\n ListarCursosAnswer = Answer(uri=\"ListarCursosAnswer\",\n answer_template=\"Los cursos de la oferta actual son: {%courseName%}\",\n properties=[course_name_prop],\n refers_to=\"http://127.0.0.1/ockb/course/ontology/hasCourse\",\n answer_from=\"http://127.0.0.1/ockb/resources/OpenCampusFebrero-Julio\")\n\n # Setting up resolution\n ObtenerInformacionResolution = Resolution(uri=\"ObtenerInformacionResolution\",\n question=\"De que cursos deseas conocer\",\n resolves=\"http://127.0.0.1/ockb/course/resource/Course\")\n ObtenerFechasResolution = Resolution(uri=\"ObtenerFechasResolution\", question=\"De que cursos deseas conocer\",\n resolves=\"http://127.0.0.1/ockb/course/resource/Course\")\n ObtenerFechasInicioResolution = Resolution(uri=\"ObtenerFechasInicioResolution\",\n question=\"De que cursos deseas conocer\",\n resolves=\"http://127.0.0.1/ockb/course/resource/Course\")\n ObtenerFechasFinResolution = Resolution(uri=\"ObtenerFechasFinResolution\",\n question=\"De que cursos deseas conocer\",\n resolves=\"http://127.0.0.1/ockb/course/resource/Course\")\n ObtenerPrerequisitosResolution = Resolution(uri=\"ObtenerPrerequisitosResolution\",\n question=\"De que cursos deseas conocer\",\n resolves=\"http://127.0.0.1/ockb/course/resource/Course\")\n ObtenerDuracionResolution = Resolution(uri=\"ObtenerDuracionResolution\", question=\"De que cursos deseas conocer\",\n resolves=\"http://127.0.0.1/ockb/course/resource/Course\")\n ObtenerPrecioResolution = Resolution(uri=\"ObtenerPrecioResolution\", question=\"De que cursos deseas conocer\",\n resolves=\"http://127.0.0.1/ockb/course/resource/Course\")\n ObtenerDocenteResolution = Resolution(uri=\"ObtenerDocenteResolution\", question=\"De que cursos deseas conocer\",\n resolves=\"http://127.0.0.1/ockb/course/resource/Course\")\n ObtenerContenidosResolution = Resolution(uri=\"ObtenerContenidosResolution\",\n question=\"De que cursos deseas conocer\",\n resolves=\"http://127.0.0.1/ockb/course/resource/Course\")\n\n # Setting up Entity\n\n curso_entity = Entity(name=\"http://127.0.0.1/ockb/course/resource/Course\")\n\n # setting up synonyms:\n Synonym(name=\"Mooc\", entity=curso_entity)\n Synonym(name=\"Taller\", entity=curso_entity)\n Synonym(name=\"Curso\", entity=curso_entity)\n Synonym(name=\"Open Course\", entity=curso_entity)\n\n # Setting up intents\n\n ObtenerInformacion = Intent(name=\"ObtenerInformacion\", agent=agent,\n description=\"Obtener una breve descripcion del curso\",\n answer=ObtenerInformacionAnswer, resolution=ObtenerInformacionResolution,\n entities=[curso_entity])\n ObtenerFechas = Intent(name=\"ObtenerFechas\", agent=agent,\n description=\"Obtener las fechas importantes del curso\",\n answer=ObtenerFechasAnswer, resolution=ObtenerFechasResolution, entities=[curso_entity])\n ObtenerFechasInicio = Intent(name=\"ObtenerFechasInicio\", agent=agent,\n description=\"Obtener las fechas de inicio del curso\",\n answer=ObtenerFechasInicioAnswer, resolution=ObtenerFechasInicioResolution,\n entities=[curso_entity])\n ObtenerFechasFin = Intent(name=\"ObtenerFechasFin\", agent=agent,\n description=\"Obtener las fechas de finalizacion del curso\",\n answer=ObtenerFechasFinAnswer, resolution=ObtenerFechasFinResolution,\n entities=[curso_entity])\n ObtenerPrerequisitos = Intent(name=\"ObtenerPrerequisitos\", agent=agent,\n description=\"Obtener prerequisitos del curso\",\n answer=ObtenerPrerequisitosAnswer,\n resolution=ObtenerPrerequisitosResolution)\n ObtenerDuracion = Intent(name=\"ObtenerDuracion\", agent=agent,\n description=\"Obtener la duracion del curso\", answer=ObtenerDuracionAnswer,\n resolution=ObtenerDuracionResolution, entities=[curso_entity])\n ObtenerPrecio = Intent(name=\"ObtenerPrecio\", agent=agent, description=\"Obtener el precio del curso\",\n answer=ObtenerPrecioAnswer, resolution=ObtenerPrecioResolution, entities=[curso_entity])\n ObtenerDocente = Intent(name=\"ObtenerDocente\", agent=agent,\n description=\"Obtener los nombres de los docentes del curso\",\n answer=ObtenerDocenteAnswer, resolution=ObtenerDocenteResolution,\n entities=[curso_entity])\n ObtenerContenidos = Intent(name=\"ObtenerContenidos\", agent=agent,\n description=\"Obtener los contenidos del curso\",\n answer=ObtenerContenidosAnswer, resolution=ObtenerDocenteResolution,\n entities=[curso_entity])\n ListarCursos = Intent(name=\"ListarCursos\", agent=agent,\n description=\"Presentar la oferta actual de cursos\", answer=ListarCursosAnswer,\n resolution=ObtenerContenidosResolution)\n # Setting up sentences\n\n Sentence(intent=ObtenerInformacion, sentence=\"De que trata el mooc?\")\n Sentence(intent=ObtenerInformacion, sentence=\"Quiero informacion del curso de emprendimiento\")\n Sentence(intent=ObtenerInformacion, sentence=\"Muestrame un resumen del mooc?\")\n Sentence(intent=ObtenerInformacion, sentence=\"Breve introducción al curso\")\n Sentence(intent=ObtenerInformacion, sentence=\"que es emprendimiento\")\n Sentence(intent=ObtenerInformacion, sentence=\"De que se trata el curso?\")\n Sentence(intent=ObtenerInformacion, sentence=\"De qué va el curso?\")\n Sentence(intent=ObtenerInformacion, sentence=\"Me ayudas con información acerca del curso?\")\n Sentence(intent=ObtenerFechas, sentence=\"Cuáles son las fechas importantes del curso?\")\n Sentence(intent=ObtenerFechas, sentence=\"Fechas clave del curso\")\n Sentence(intent=ObtenerFechas, sentence=\"Que fechas debo tomar en cuenta\")\n Sentence(intent=ObtenerFechas, sentence=\"fechas de inicio y fin\")\n Sentence(intent=ObtenerFechas, sentence=\"Cuándo comienza el curso?\")\n Sentence(intent=ObtenerFechas, sentence=\"Fechas importantes del curso de inteligencia artificial\")\n Sentence(intent=ObtenerFechas, sentence=\"Cuáles son las fechas importantes del curso de emprendimiento\")\n Sentence(intent=ObtenerFechasInicio, sentence=\"Cuándo inicia el curso de emprendimiento\")\n Sentence(intent=ObtenerFechasInicio, sentence=\"Cuándo empiezan los cursos ?\")\n Sentence(intent=ObtenerFechasInicio, sentence=\"Fecha de inicio de los moocs?\")\n Sentence(intent=ObtenerFechasInicio, sentence=\"Día de inicio de los moocs ?\")\n Sentence(intent=ObtenerFechasInicio, sentence=\"En que fecha inician los moocs?\")\n Sentence(intent=ObtenerFechasInicio, sentence=\"A partir de que fecha empiezan los mooc?\")\n Sentence(intent=ObtenerFechasFin, sentence=\"Cuando finaliza el curso?\")\n Sentence(intent=ObtenerFechasFin, sentence=\"En que fecha termina el curso?\")\n Sentence(intent=ObtenerFechasFin, sentence=\"Cuando termina el curso?\")\n Sentence(intent=ObtenerPrerequisitos,\n sentence=\"Cuáles son los requisitos necesarios para el curso de emprendimiento\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"Cuáles son los prerequisitos?\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"Requisitos previos de ingreso al curso\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"Dame a conocer los prerequisitos\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"Me puedes indicar los prerequistos necesarios?\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"Que necesito saber antes de iniciar el curso\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"que se necesita saber para este curso\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"Los pre requisitos cuales son?\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"Qué se necesita?\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"Qué debería saber para tomar el curso?\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"Qué conocimientos previos debo tener?\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"Qué tengo que saber?\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"Requisitos previos\")\n Sentence(intent=ObtenerPrerequisitos, sentence=\"Conocimientos previos\")\n Sentence(intent=ObtenerDuracion, sentence=\"Cuanto dura el curso de empendimiento\")\n Sentence(intent=ObtenerDuracion, sentence=\"Duración del curso\")\n Sentence(intent=ObtenerDuracion, sentence=\"Número de horas del mooc?\")\n Sentence(intent=ObtenerDuracion, sentence=\"En cuántas semanas se realiza el curso?\")\n Sentence(intent=ObtenerDuracion, sentence=\"Cuanto dura el curso\")\n Sentence(intent=ObtenerDuracion, sentence=\"Tiempo que dura un curso?\")\n Sentence(intent=ObtenerDuracion, sentence=\"cuanto puede durar un curso mooc\")\n Sentence(intent=ObtenerDuracion, sentence=\"cuanto dura el curso?\")\n Sentence(intent=ObtenerDuracion, sentence=\"cual es la duracion de psicologia social?\")\n Sentence(intent=ObtenerDuracion, sentence=\"Cuánto tiempo dura el mooc?\")\n Sentence(intent=ObtenerDuracion, sentence=\"De cuántas semanas es el mooc?\")\n Sentence(intent=ObtenerDuracion, sentence=\"Cuántas horas dura el mooc?\")\n Sentence(intent=ObtenerDuracion, sentence=\"Cuánto tiempo dura el mooc?\")\n Sentence(intent=ObtenerDuracion, sentence=\"De cuántas semanas es el mooc?\")\n Sentence(intent=ObtenerPrecio, sentence=\"Cual es el precio del curso de emprendimiento\")\n Sentence(intent=ObtenerPrecio, sentence=\"Cuál es el precio?\")\n Sentence(intent=ObtenerPrecio, sentence=\"Cuánto vale?\")\n Sentence(intent=ObtenerPrecio, sentence=\"Valor del curso?\")\n Sentence(intent=ObtenerPrecio, sentence=\"Costo\")\n Sentence(intent=ObtenerPrecio, sentence=\"Inversión total del curso\")\n Sentence(intent=ObtenerPrecio, sentence=\"cual es el valor de los componentes?\")\n Sentence(intent=ObtenerPrecio, sentence=\"costo de los cursos?\")\n Sentence(intent=ObtenerPrecio, sentence=\"cuanto cuesta los cursos\")\n Sentence(intent=ObtenerPrecio, sentence=\"Cuál es precio del curso?\")\n Sentence(intent=ObtenerPrecio, sentence=\"Cuánto cuesta el mooc de Administración Empresarial?\")\n Sentence(intent=ObtenerPrecio, sentence=\"tiene algun valor los cursos?\")\n Sentence(intent=ObtenerPrecio, sentence=\"Cuanto cuesta el curso Método Toyota?\")\n Sentence(intent=ObtenerPrecio, sentence=\"Cuanto cuesta un curso?\")\n Sentence(intent=ObtenerPrecio, sentence=\"Que vale el curso ?\")\n Sentence(intent=ObtenerPrecio, sentence=\"Es gratis?\")\n Sentence(intent=ObtenerPrecio, sentence=\"Cuanto vale el mooc?\")\n Sentence(intent=ObtenerPrecio, sentence=\"Precio\")\n Sentence(intent=ObtenerDocente, sentence=\"Cual es el docente del curso de emprendimiento\")\n Sentence(intent=ObtenerDocente, sentence=\"Quién es mi profesor en el curso?\")\n Sentence(intent=ObtenerDocente, sentence=\"Docente del mooc?\")\n Sentence(intent=ObtenerDocente, sentence=\"Qué docente imparte el mooc?\")\n Sentence(intent=ObtenerDocente, sentence=\"Quién es el docente encargado de la materia?\")\n Sentence(intent=ObtenerDocente, sentence=\"Nombre del docente del mooc\")\n Sentence(intent=ObtenerDocente, sentence=\"Que profesor esta a cargo del curso\")\n Sentence(intent=ObtenerDocente, sentence=\"cual es mi docente del mooc\")\n Sentence(intent=ObtenerDocente, sentence=\"información del docente\")\n Sentence(intent=ObtenerDocente, sentence=\"Quién es el docente encargado?\")\n Sentence(intent=ObtenerDocente, sentence=\"Quién va a dar el MOOC\")\n Sentence(intent=ObtenerDocente, sentence=\"Que docente acompaña al estudiante?\")\n Sentence(intent=ObtenerDocente, sentence=\"Cual es el profe de Salud Sexual y Reproductiva\")\n Sentence(intent=ObtenerContenidos, sentence=\"Cuáles son los contenidos a tratar en el curos de emprendimiento\")\n Sentence(intent=ObtenerContenidos, sentence=\"Contenido del curso\")\n Sentence(intent=ObtenerContenidos, sentence=\"Cuál es la temática de cada curso?\")\n Sentence(intent=ObtenerContenidos, sentence=\"Qué temas se van a tratar en cada curso?\")\n Sentence(intent=ObtenerContenidos, sentence=\"De que se tratan los moocs\")\n Sentence(intent=ObtenerContenidos, sentence=\"Cuáles son las temas del curso?\")\n Sentence(intent=ObtenerContenidos, sentence=\"Que se va a tratar en este curso?\")\n Sentence(intent=ObtenerContenidos, sentence=\"Qué se va a dar en el curso?\")\n Sentence(intent=ListarCursos, sentence=\"Que cursos hay\")\n Sentence(intent=ListarCursos, sentence=\"Muestrame los cursos\")\n Sentence(intent=ListarCursos, sentence=\"Cual es la oferta actual\")\n Sentence(intent=ListarCursos, sentence=\"Cuentame que cursos tienes\")\n Sentence(intent=ListarCursos, sentence=\"Que cursos me ofreces\")\n Sentence(intent=ListarCursos, sentence=\"Que cursos estan disponibles\")\n Sentence(intent=ListarCursos, sentence=\"Listame los cursos\")\n Sentence(intent=ListarCursos, sentence=\"Que cursos tiene\")\n\n # db.session.add(intent_obtenerinformacion)\n # db.session.add(intent_obtenerfechas)\n # db.session.add(intent_obtenerfechasinicio)\n # db.session.add(intent_obtenerfechasfin)\n # db.session.add(intent_obtenerprerequisitos)\n # db.session.add(intent_obtenerduracion)\n # db.session.add(intent_obtenerprecio)\n # db.session.add(intent_obtenerdocente)\n # db.session.add(intent_obtenercontenidos)\n # db.session.add(intent_listarCursos)\n\n db.session.commit()","async def on_startup(self):\n await self.controller.database.connect()","def agent_init(self):\n pass","def load_agents(self, agents):\n self.agents = agents","def connect(self):\n super(NERDmLoader, self).connect()\n self.lateloadr._client = self._client\n self.lateloadr._db = self._db\n self.relloadr._client = self._client\n self.relloadr._db = self._db","def initialize():\n\t\tDBHelper.con = mdb.connect('localhost', 'root', 'sensepass', 'sensecambrowser')","def init(self):\n self._service_store = ServiceStore(self.driver, self.network)\n self._emulator = NetworkEmulator(self.store, self.driver)","def __init__(self):\n self.databases = []","def initialize(self):\n self.population.initialize()\n self.cache.initialize()\n if self.storage:\n self.storage.initialize()","async def prepare_databases(self):","def __init__(self, wm) -> None:\n conf_dict = wm.context.config.arango_storage._to_dict()\n\n log.debug(conf_dict)\n client = ArangoClient(hosts=conf_dict['hosts'])\n db = client.db(conf_dict['database'],\n username=conf_dict['username'],\n password=conf_dict['password'])\n\n self.db = db\n self.client = client","def initialize():\n DATABASE.connect()\n DATABASE.drop_tables([Journal], safe=True)\n DATABASE.create_tables([Journal], safe=True)\n DATABASE.close()","def set_local_database():\n load_config()\n db_path = get_db_path_from_config()\n db = LocalDB(db_path, log=None)\n return db","def _init(self):\n if os.path.exists(self.fname):\n with open(self.fname, \"rb\") as fh:\n self.db = pickle.load(fh)\n else:\n self.db = {}\n print(\"DB loaded, len\", len(self.db))","def __init__(self):\r\n ms_cli_root = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))\r\n self._working_dir = os.path.join(\".localdata\")\r\n self._db = None\r\n self._db_name = \"ms-cli.db\"\r\n self._db_models = db_base\r\n self._conf_file_name = \"ms-cli.conf\"\r\n self._db_map = {}\r\n\r\n self._appconfig = None\r\n self._session = None\r\n self._current_user_guid = None\r\n\r\n self.init_dir()","def _connect(self):\n database_file = get_database_filename()\n if not os.path.isfile(database_file):\n logger.error('No capabilities database found')\n logger.error(\n 'To import a database from xml: a2p2v --importdb <filename>.xml'\n )\n else:\n self.conn = sqlite3.connect(database_file)","def init():\n database.create_tables([Tracker])\n database.commit()","def _initilise_graph_db(self):\n for collector in self.collectors:\n collector.init_graph_db()","def __init__(self):\n self.database = Database()\n self.load_config()","def initDB():\n global DATABASE\n\n uid0 = generate_resource_uid('Admin1', 0)\n\n DATABASE[\"users\"] = {\n \"Admin1\": {\n \"Type\": \"admin\",\n \"Password\": \"AdminPass\",\n \"Quota\": int(sys.maxsize),\n \"Resources\": {uid0},\n \"Created\": 1,\n },\n \"User1\": {\n \"Type\": \"user\",\n \"Password\": \"UserPass\",\n \"Quota\": int(sys.maxsize),\n \"Resources\": set([]),\n \"Created\": 0,\n }\n }\n\n DATABASE[\"resources\"] = {\n uid0: \"Admin1\",\n }","def __init_database(self):\n from admin.database import init_db\n init_db()","def __post_init__(self):\n self.dbase = databases.Database(\n self.dsn,\n min_size=self.min_size,\n max_size=self.max_size\n )\n self.engine, self.meta = self.get_engine_metadata()","def initialize(self):\n\n db = dict()\n\n db['meta'] = Meta(None)\n db['race'] = Race(None, None, None, None, None)\n db['track'] = Track(None, None)\n db['classes'] = set([])\n db['teams'] = set([])\n db['drivers'] = set([])\n\n self.db = db","def __init__(self):\n\t\tself.obtainDatabaseConnection()","def initialize(self):\n\n \"*** YOUR CODE HERE\"\n self.path = []\n MyAgent.customFood = None\n MyAgent.foodLeft = 0\n MyAgent.specialWalls = {}\n self.followOne = False\n if self.index == 0:\n MyAgent.finding = []\n MyAgent.finding.append(False)","def init(self):\n self.db.connect()\n try:\n self.db.create_tables([JambiModel], safe=True)\n JambiModel.create(ref='0')\n self.logger.info('Database initialized')\n except IntegrityError:\n self.logger.info('Database was already initialized')\n self.db.close()","def __init__(self):\n\n self.__path = \"DataBase.db\"\n self.__admins = []\n self.__update_admin_cache()","def _create_db(self):\n self.db = easydms.dbcore.Database(\":memory:\")\n self.db.create_db()","def load_model(self):\n if torch.cuda.is_available():\n map_location=lambda storage, loc: storage.cuda()\n else:\n map_location='cpu'\n\n for index, agent in enumerate(self.agents):\n agent.actor_local.load_state_dict(torch.load('agent{}_checkpoint_actor.pth'.format(index + 1), map_location=map_location))\n agent.critic_local.load_state_dict(torch.load('agent{}_checkpoint_critic.pth'.format(index + 1), map_location=map_location))","def init_db() -> None:\n conn = sqlite3.connect('../Utils/map_storage.db')\n cursor = conn.cursor()\n\n with conn:\n station_cmd = \"\"\"CREATE TABLE IF NOT EXISTS\n nodes(city TEXT, name TEXT, is_station TEXT, x INT, y INT, zone TEXT)\"\"\"\n\n cursor.execute(station_cmd)\n\n connection_cmd = \"\"\"CREATE TABLE IF NOT EXISTS\n connections(city TEXT, name_1 TEXT, name_2 TEXT, color TEXT)\"\"\"\n\n cursor.execute(connection_cmd)","def _load_local():\n local = session.get('local')\n\n if local is None:\n g.local = None\n else:\n g.local = local","def __init__(self, agent = None, region = None, settings = None, message_handler = None, events_handler = None):\n super(ObjectManager, self).__init__(agent, settings)\n self.region = region\n\n # the object store consists of a list\n # of Object() instances\n self.object_store = []\n\n # the avatar store consists of a list\n # of Avatar() instances\n self.avatar_store = []\n\n # other useful things\n self.helpers = Helpers()\n\n self.message_handler = message_handler\n\n if self.settings.LOG_VERBOSE: logger.info(\"Initializing object storage\")","def initDatabase(self):\n\n try:\n self.dbase = workflowManager(self.wf_name)\n\n working = self.config['working_d']\n self.dbase.initWorkflow(self.wf_name, working)\n\n except sqlite3.Error as error:\n self.logger.warning('Database %s: %s', self.wf_name, error.args)\n #print('Database %s: %s', self.wf_name, error.args)\n\n return","async def conn(self) -> None:\n self.bot.db = await aiosqlite.connect('database.db')","def connect_env(self,environment,agentIndex,allAgents):\n self.environment = environment\n self.agentIndex = agentIndex\n self.allAgents = allAgents\n environment.connect_server(agentIndex)","def setup(cls):\n cls.runner = CliRunner()\n cls.agent_name = \"myagent\"\n cls.cwd = os.getcwd()\n cls.t = tempfile.mkdtemp()\n # copy the 'packages' directory in the parent of the agent folder.\n shutil.copytree(Path(CUR_PATH, \"..\", \"packages\"), Path(cls.t, \"packages\"))\n\n os.chdir(cls.t)\n result = cls.runner.invoke(\n cli,\n [*CLI_LOG_OPTION, \"init\", \"--author\", AUTHOR],\n standalone_mode=False,\n )\n assert result.exit_code == 0\n result = cls.runner.invoke(\n cli,\n [*CLI_LOG_OPTION, \"create\", \"--local\", cls.agent_name],\n standalone_mode=False,\n )\n assert result.exit_code == 0\n os.chdir(cls.agent_name)\n # add connection first time","def init_database(self):\n # init_database(self.engine)","def bootstrap(self):\n\n self.db = connection_manager.get(DbConnection, host=self.ip, port=3306, user=self.user, password=self.password)\n\n self.connected = True","def __init__(self, fname):\n self.fname = fname\n self.connection = sqlite3.connect(fname)\n self.cursor = self.connection.cursor()\n print(f\"Connection to file {fname.split('/')[-1]} established.\")\n \n self.t_init = self.get_initial_time()\n self.duration = self.query(\"Duration\", \"Info\")[0]\n\n # (key,value): (agentId, name), (name, agentId),\n # (spec, agentId), (agentId, spec)\n agents = self.get_agents()\n self.agents = agents[0]\n self.names = agents[1]\n self.specs = agents[2]\n self.agentIds = agents[3]\n\n return","def setupDatabases(self):\n param = self.getDefaultDatabaseConnectionParameter()\n db = DatabaseFactory.getDatabase(self.defaultDriver(), {})\n db.createDatabase(param)\n db.connect(param)\n if db.isConnected():\n self.settingsDb = db\n db.createObservations()\n db.createSensors()\n else:\n return False\n # replace by settings validation method later\n return self.check()","def init_db():\n global app\n Promotions.init_db(app)","def init():\n global __dbChanged\n __dbChanged = False\n loadItemsFromFile()\n global __isInitialized\n if __isInitialized == True:\n return\n\n Report.trace(\"itemdatabase\", \"Initializing the item database.\")\n returnCode = FilterManager.executeFiltersForEvent(\"preInitializeItemDatabase\")\n if returnCode == FilterManager.FINISHED:\n Report.trace(\"itemdatabase\", \"Item database initialized.\")\n __isInitialized = True\n return\n\n for item in Items.items:\n addItem(item)\n\n FilterManager.executeFiltersForEvent(\"postInitializeItemDatabase\")\n __isInitialized = True\n Report.trace(\"itemdatabase\", \"Item database initialized.\")","def main_storer():\n config.config_storer()\n create_storer_paths()\n create_storer_git_repo()\n create_db()\n _logger.info(' -- storer init done setting up paths and db file.')","def __init__(self):\n\n self.storage: list = Storage()\n\n # Start for get data in API and set in storage\n self._set_proxies_in_storage()","def init_db():\n db.drop_all()\n db.create_all()\n\n print(\"Initialized Connect 4 Database.\")","def _initialize_database(self) -> None:\n with self._sqlite_connection:\n self._sqlite_connection.execute('''CREATE TABLE IF NOT EXISTS articles (\n feed_id INTEGER,\n identifier TEXT,\n uri TEXT,\n title TEXT,\n updated FLOAT,\n author TEXT,\n content TEXT,\n unread BOOLEAN,\n flag BOOLEAN)''')","def _instantiate_graph_db(self):\n graph_db_name = self.conf_manager.get_graph_db()\n plugin_parameters = [self.conf_manager]\n self.graph_db = self._load_plugins([graph_db_name],\n common.GRAPH_PACKAGE,\n paths.GRAPH_DB_DIR,\n plugin_parameters)[0]","def __init__(self):\n try:\n self._chat_db = sqlite3.connect(CHAT_DB_PATH)\n except OperationalError:\n print(\"Cannot access chat database.\\nGo to Settings->Security and Privacy->Privacy->Full Disk Access.\\n\"\n \"Give access to the application you are running and restart the program.\")\n sys.exit(1)\n\n self._contacts = Contacts(self._chat_db).get_contacts_df()\n\n try:\n self._message_db = sqlite3.connect(WEEKLY_MESSAGES_DB_PATH)\n except OperationalError:\n print(\"Could not connect to the database server.\")\n sys.exit(1)","def connect_db_and_load_data(cls):\n db.connect()\n db.create_tables([Product], safe=True)\n load_data(transform_data('./inventory.csv'))","def initialize_environment(self):\n logging.debug(\"initialize_environment called\")\n try:\n # logging.info(\"Creating networks...\")\n self.create_networks()\n self.create_machines()\n self.save()\n except Exception, e:\n # something went wrong with the creating of the networks\n logging.warn(\"Exception encountered\")\n import traceback\n logging.debug(traceback.print_exc())\n raise e\n return True","def initialize():\n db.connect()\n db.create_tables([Expense], safe=True)","def init_db(self):\n if self.is_client() or not self.is_responsible_validator():\n return\n\n ip, _ = self.experiment.get_peer_ip_port_by_id(self.my_id)\n\n self.db_path = os.path.join(\"/tmp\", \"postgres-data\", ip)\n shutil.rmtree(self.db_path, ignore_errors=True)\n os.makedirs(self.db_path, exist_ok=True)\n\n os.system(\"/usr/lib/postgresql/11/bin/initdb %s > postgres.out\" % self.db_path)","def init_database(self):\n init_database(self.engine)","def __init__(self):\n self._datastore = dict()","def initialize_connection():\n session = imdb.IMDb()\n return session","def os_start_db( self, ):\r\n pass","def initialize():\n manager.initialize()\n logs.exit_great_success()","def __init__(self):\n os.system('cls')\n\n # Declare instance variables\n self.hosts = []\n self.offline_hosts = []\n\n # Populate the host list\n self.create_host_list()","def connect(self):\n self.cluster = Cluster([self.db_node])\n try:\n self.session = self.cluster.connect()\n self.session.default_timeout = DEFAULT_TIMEOUT\n except Exception as e:\n raise StorageError(\"Cannot connect to {}\".format(self.db_node), e)","def setup(cls):\n super().setup()\n cls.db = DBCommunication()","def initialize_database():\n db = Database(database_name)\n i, m, u, p = db.fetch_needed_data()\n\n return i, m, u, p","def initialize(self):\n if self.real:\n self.agent.connect(self)\n else:\n self.connect() # Connect python client to VREP\n self.agent.connect(self)","def test_init(self):\n self.assertIsNotNone(DatabaseIntermediary(), self.ec.db)","def initialized_tasks_db(tmpdir):\n tasks.start_tasks_db(str(tmpdir), 'tiny')\n\n yield # This is where the testing happens\n\n tasks.stop_tasks_db()","def _init_agents(self):\n self.agents = [Agent(e=0.1, a=0.1, row=self.row, col=self.col) for i in range(2)]","def __init__(self):\n\n self.db = ImageDB()\n self.vitess = VitessConn()\n self.minio = MinioConn()","async def async_initialize(self) -> None:\n prefs = await self._store.async_load()\n\n if prefs is None:\n prefs = {}\n\n self._prefs = prefs","def initialize():\n DATABASE.connect()\n DATABASE.create_tables([User, Entry], safe=True)\n DATABASE.close()","def Init(self, agentEnv):\n self.agentEnv = agentEnv","def database_setup():\n Base.metadata.create_all(bind=engine)\n db = LocalSession()\n try:\n populate_from_json(db, Vector, str(VECTORS))\n populate_from_json(db, Gender, str(GENDERS))\n populate_from_json(db, Tag, str(TAGS))\n finally:\n db.close()","def init_db():\n _conn = sqlite3.connect('results/offerings.db')\n _conn.execute('''CREATE TABLE IF NOT EXISTS offerings (\n link TEXT PRIMARY KEY,\n title TEXT,\n university TEXT,\n category TEXT,\n fare INTEGER)''')\n _conn.commit()\n return _conn","def setUp(self):\n self.a = backend.dbconnection.DBConnect()","def __init__(self):\n self.storage = None\n self.user = None\n self.master_collection = None\n self.current_collection = None","def initdb(self):\n logger.info(\"Initializing database\")\n self.instances.drop()\n self.instances.create_index([('class_id', pymongo.HASHED)])\n # Creates a unique index\n self.instances.create_index(\n 'name',\n unique=True,\n partialFilterExpression={'deleted' : False}\n )\n start_time = time.time()\n timeout = 60 * 5\n while not self.axops_client.ping():\n if time.time() - start_time > timeout:\n raise AXTimeoutException(\"Timed out ({}s) waiting for axops availability\".format(timeout))\n time.sleep(3)\n\n for fix_doc in self.axdb_client.get_fixture_instances():\n instance = FixtureInstance.deserialize_axdbdoc(fix_doc)\n self.instances.insert_one(instance.mongodoc())\n\n logger.info(\"Database initialized\")","def initialized_tasks_db(tmpdir):\n # Setup : start db\n tasks.start_tasks_db(str(tmpdir), 'tiny')\n\n yield # this is where the testing happens\n\n # Teardown : stop db\n tasks.stop_tasks_db()","def initialize(self):\n self.candidate_disease_list = []\n self.candidate_symptom_list = []\n self.agent_action = {\n \"turn\":None,\n \"action\":None,\n \"request_slots\":{},\n \"inform_slots\":{},\n \"explicit_inform_slots\":{},\n \"implicit_inform_slots\":{},\n \"speaker\":\"agent\"\n }","async def _initialize_from_database(self):\n\n _LOGGER.debug(\"%s: initializing values from the database\", self.entity_id)\n\n with session_scope(hass=self.hass) as session:\n query = session.query(States).filter(\n States.entity_id == self._source_entity_id.lower()\n )\n\n if self._samples_max_age is not None:\n records_older_then = dt_util.utcnow() - self._samples_max_age\n _LOGGER.debug(\n \"%s: retrieve records not older then %s\",\n self.entity_id,\n records_older_then,\n )\n query = query.filter(States.last_updated >= records_older_then)\n else:\n _LOGGER.debug(\"%s: retrieving all records\", self.entity_id)\n\n query = query.order_by(States.last_updated.desc()).limit(\n self._samples_max_buffer_size\n )\n states = execute(query, to_native=True, validate_entity_ids=False)\n\n for state in reversed(states):\n self._add_state_to_queue(state)\n\n self.async_schedule_update_ha_state(True)\n\n _LOGGER.debug(\"%s: initializing from database completed\", self.entity_id)","def init_db():\n # We are setting the module variables here for the first time, so disable the warning\n global DB_USER_TABLE # pylint: disable=global-variable-undefined\n global DB_CUSTOMER_TABLE # pylint: disable=global-variable-undefined\n global DB_USER_CUSTOMER_RELS_TABLE # pylint: disable=global-variable-undefined\n global DB_TICKET_TABLE # pylint: disable=global-variable-undefined\n global DB_COMMENT_TABLE # pylint: disable=global-variable-undefined\n\n db = TinyDB(app.config['DB_NAME'])\n\n DB_USER_TABLE = db.table('users')\n DB_CUSTOMER_TABLE = db.table('customers')\n DB_USER_CUSTOMER_RELS_TABLE = db.table('user_customer_rels')\n DB_TICKET_TABLE = db.table('tickets')\n DB_COMMENT_TABLE = db.table('comments')","async def open(self):\n self.db = await self.pool\n return self","def init_data_base_activity(path):\n\n conn = sqlite3.connect(path)\n c = conn.cursor()\n\n c.execute(\"DROP TABLE IF EXISTS Activity\")\n c.execute('''CREATE TABLE Activity\n (\n inseeNb TEXT, comLib TEXT, equipementId TEXT,\n equNbEquIdentique TEXT, actCode TEXT,actLib TEXT,\n equActivitePraticable TEXT, equActivitePratique TEXT,\n equActiviteSalleSpe TEXT, actNivLib TEXT\n )'''\n )\n\n conn.commit()\n conn.close()","def __init__(self):\n self._connection = get_db_connection()","def init_db():\n\tdb.drop_all()\n\tdb.create_all()\n\n\tprint(\"Initialized Database.\")\n\treturn","def init_neo4j_db():\n try:\n app.neo4j_driver = GraphDatabase.driver(\n app.config[\"NEO4J_URI\"],\n auth=(app.config[\"NEO4J_USER\"], app.config[\"NEO4J_PWD\"])\n )\n except AuthError:\n app.neo4j_driver = None\n app._neo4j_up = True\n except:\n app.neo4j_driver = None\n app._neo4j_up = False","def __init__(self):\r\n date_time('Connecting to local database ...')\r\n\r\n self.conn = sqlite3.connect(DATABASE_PATH)\r\n self.cursor = self.conn.cursor()\r\n\r\n # Set up database\r\n self.cursor.execute('PRAGMA synchronous = OFF')\r\n self.cursor.execute('PRAGMA journal_mode = OFF')\r\n self.cursor.execute('PRAGMA locking_mode = EXCLUSIVE')\r\n self.cursor.execute('PRAGMA count_changes = FALSE')\r\n\r\n self.cursor.execute('CREATE TABLE IF NOT EXISTS citations (id INTEGER PRIMARY KEY, citation TEXT UNIQUE);')","def initialize():\n\n db.connect() # Se conecta\n db.create_tables([Entry], safe=True) # Crea las tablas\n # safe=true evita crear modelos ya creados","def __initDataFromImages(self):\n #Check if the local_db exist\n initial_dirs = os.listdir(os.getcwd())\n is_db_empty = False\n if len(os.listdir(self.base_dir)) == 1: #Empty here means no person data\n [images_dir] = os.listdir(self.base_dir)\n is_db_empty = images_dir == cfg.local[\"IMG_DIR\"]\n if cfg.local[\"DEFAULT_IMGS_DIR\"] in initial_dirs and is_db_empty:\n default_path = os.path.join(os.getcwd(), cfg.local[\"DEFAULT_IMGS_DIR\"])\n self.X, self.y = loadDataFromImagesPath(self.detector, default_path)\n self.le = LabelEncoder()\n #Nothing relate to mapping name to dir here, we don't care about\n #This data because of the user doesn't exist in the database\n self.__savePreProcessedData()","def initdb(self, default):\r\n # set the default modulestore\r\n self.options['stores']['default'] = self.options['stores'][default]\r\n self.store = MixedModuleStore(**self.options)\r\n self.addCleanup(self.store.close_all_connections)\r\n\r\n # convert to CourseKeys\r\n self.course_locations = {\r\n course_id: SlashSeparatedCourseKey.from_deprecated_string(course_id)\r\n for course_id in [self.MONGO_COURSEID, self.XML_COURSEID1, self.XML_COURSEID2]\r\n }\r\n # and then to the root UsageKey\r\n self.course_locations = {\r\n course_id: course_key.make_usage_key('course', course_key.run)\r\n for course_id, course_key in self.course_locations.iteritems() # pylint: disable=maybe-no-member\r\n }\r\n self.fake_location = Location('foo', 'bar', 'slowly', 'vertical', 'baz')\r\n self.import_chapter_location = self.course_locations[self.MONGO_COURSEID].replace(\r\n category='chapter', name='Overview'\r\n )\r\n self.xml_chapter_location = self.course_locations[self.XML_COURSEID1].replace(\r\n category='chapter', name='Overview'\r\n )\r\n # get Locators and set up the loc mapper if app is Locator based\r\n if default == 'split':\r\n self.fake_location = loc_mapper().translate_location(self.fake_location)\r\n\r\n self._create_course(default, self.course_locations[self.MONGO_COURSEID].course_key)","def init():\n database = \"database.pkl\"\n\n onsite_bills = BillID(database)\n online_bills = BillID(database)\n\n return onsite_bills, online_bills","def _init_storage(self):\n if self._ is None:\n self._ = Parameters(self)","def initialize_database():\n # Create the schema\n Base.metadata.create_all(engine)\n\n # Create a connection/database session\n session = Session()\n\n # Now, create a few restaurants:\n cupcake = Restaurant(name=\"Cupcakes\")\n five_guys = Restaurant(name=\"Five Guys\")\n ihop = Restaurant(name=\"IHOP\")\n\n # And a few users:\n mike = User(name=\"Mike\")\n ryan = User(name=\"Ryan\")\n\n # And finally a few votes:\n mike.preferences.append(Preference(vote=\"+1\", restaurant=five_guys))\n ryan.preferences.append(Preference(vote=\"+0\", restaurant=five_guys))\n ryan.preferences.append(Preference(vote=\"-0\", restaurant=cupcake))\n\n session.add(mike)\n session.add(ryan)\n session.add(ihop)\n\n session.commit()\n\n session.close()","def _connect(self) -> None:\n if self._agent_thread.is_alive():\n raise ValueError(\"Agent already running.\")\n self._agent_thread.start()\n\n while not self._agent.runtime.is_running: # check agent completely running\n time.sleep(0.01)","def __init__(self):\n\n catalog.connect_database()\n catalog.clean_db()\n self.viewer = Viewer()\n self.editor = Editor()","def __init__(self, database=\"featurehub\"):\n\n self.__orm = ORMManager(database)\n\n if not database_exists(self.__orm.engine.url):\n print(\"Database {} does not exist.\".format(database),\n file=sys.stderr)\n print(\"You might want to create it by calling set_up method\",\n file=sys.stderr)","def initialize_storage(cfg: ElasticBlastConfig, query_files: List[str] = [], wait=ElbExecutionMode.WAIT) -> None:\n use_local_ssd = cfg.cluster.use_local_ssd\n if use_local_ssd:\n initialize_local_ssd(cfg, query_files, wait)\n else:\n initialize_persistent_disk(cfg, query_files, wait)","def __init__(self):\r\n self.conn = create_connection(DATABASE_PATH)","def initialization_step(self):\n # Update where agents are\n self.update_agent_location_vector()\n # update task locations\n self.update_task_location_vector()\n # update deadlines\n self.populate_deadline_vector()\n # update distances to each task and orientation to each task\n self.update_agent_distances_vector()\n self.update_agent_orientation_vector()","def startSession(self):\n self.storage.insert(self.__json__())","def fetch_initial_states(self):\n for agent_id, agent_obj in self.__registered_agents.items():\n # given the agent's capabilities, get everything the agent can perceive\n state = self.__get_agent_state(agent_obj)\n\n # filter other things from the agent state\n filtered_agent_state = agent_obj.filter_observations(state)\n\n # save the current agent's state for the API\n api.add_state(agent_id=agent_id, state=filtered_agent_state,\n agent_inheritence_chain=agent_obj.class_inheritance,\n world_settings=api.MATRX_info)\n\n # add god state\n api.add_state(agent_id=\"god\", state=self.__get_complete_state(), agent_inheritence_chain=\"god\",\n world_settings=api.MATRX_info)\n\n # initialize the message manager\n self.message_manager.agents = self.__registered_agents.keys()\n self.message_manager.teams = self.__teams\n\n # make the information of this tick available via the API, after all\n # agents have been updated\n api.next_tick()","def init_agent(self, kwargs):\n\n exp_params = [('agents_info', is_string),\n ('ip', is_string)]\n try:\n agents_info, agent_ip = check_arguments(exp_params, kwargs)\n agents_info = simplejson.loads(agents_info)\n except Exception as ex:\n return HttpErrorResponse(\"%s\" % ex)\n\n self.logger.info('Setting agent environment')\n\n target_dir = self.VAR_CACHE\n with open(join(target_dir, 'agents.json'), 'w') as outfile:\n simplejson.dump(agents_info, outfile)\n\n agent_role = [i['role'] for i in agents_info if i['ip'] == agent_ip][0]\n master_ip = [i['ip'] for i in agents_info if i['role'] == 'master'][0]\n\n self.env.update({'MY_IP':agent_ip})\n self.env.update({'MY_ROLE':agent_role})\n self.env.update({'MASTER_IP':master_ip})\n\n self.logger.info('Agent initialized')\n return HttpJsonResponse()"],"string":"[\n \"def initialize_database():\\n # TODO: Refactor the funtime library\\n this.db = Store(this.host).create_lib(this.store_name).get_store()\",\n \"def init_database():\\n exists = Agent.query.all()\\n if exists is None or len(exists) == 0:\\n # Setting up agent\\n agent = Agent(name='OpenCampus',\\n about=\\\"Este es el chabot de Open Campus capaz de resolver dudas sobre los diferentes cursos de la oferta actual de Open Campus\\\")\\n\\n db.session.add(agent)\\n\\n # Setting upd properties\\n\\n description_prop = Property(name=\\\"http://127.0.0.1/ockb/course/ontology/description\\\")\\n begin_date_prop = Property(name=\\\"http://127.0.0.1/ockb/course/ontology/beginDate\\\")\\n end_date_prop = Property(name=\\\"http://127.0.0.1/ockb/course/ontology/endDate\\\")\\n requirement_prop = Property(name=\\\"http://127.0.0.1/ockb/course/ontology/requirement\\\")\\n duration_prop = Property(name=\\\"http://127.0.0.1/ockb/course/ontology/duration\\\")\\n cost_prop = Property(name=\\\"http://127.0.0.1/ockb/course/ontology/cost\\\")\\n teacher_name_prop = Property(name=\\\"http://127.0.0.1/ockb/course/ontology/teacherName\\\")\\n content_name_prop = Property(name=\\\"http://127.0.0.1/ockb/course/ontology/content\\\")\\n course_name_prop = Property(name=\\\"http://127.0.0.1/ockb/course/ontology/courseName\\\")\\n\\n # db.session.add(description_prop)\\n # db.session.add(begin_date_prop)\\n # db.session.add(end_date_prop)\\n # db.session.add(requirement_prop)\\n # db.session.add(duration_prop)\\n # db.session.add(cost_prop)\\n # db.session.add(teacher_name_prop)\\n # db.session.add(content_name_prop)\\n # db.session.add(course_name_prop)\\n\\n # Setting up answers\\n\\n ObtenerInformacionAnswer = Answer(uri=\\\"ObtenerInformacionAnswer\\\", answer_template=\\\"{%description%}\\\",\\n properties=[description_prop])\\n\\n # db.session.add(ObtenerInformacionAnswer)\\n ObtenerFechasAnswer = Answer(uri=\\\"ObtenerFechasAnswer\\\",\\n answer_template=\\\"Las fechas importantes del curso son {%beginDate%} y termina el dia {%endDate%}\\\",\\n properties=[begin_date_prop, end_date_prop])\\n\\n # db.session.add(ObtenerFechasAnswer)\\n ObtenerFechasInicioAnswer = Answer(uri=\\\"ObtenerFechasInicioAnswer\\\",\\n answer_template=\\\"El curso inicia el dia {%beginDate%}\\\",\\n properties=[begin_date_prop])\\n # db.session.add(ObtenerFechasInicioAnswer)\\n ObtenerFechasFinAnswer = Answer(uri=\\\"ObtenerFechasFinAnswer\\\",\\n answer_template=\\\"El curso finaliza el dia {%endDate%}\\\",\\n properties=[end_date_prop])\\n # db.session.add(ObtenerFechasFinAnswer)\\n ObtenerPrerequisitosAnswer = Answer(uri=\\\"ObtenerPrerequisitosAnswer\\\",\\n answer_template=\\\"Los prerequisitos del curso son {%requirement%}\\\",\\n properties=[requirement_prop])\\n # db.session.add(ObtenerPrerequisitosAnswer)\\n ObtenerDuracionAnswer = Answer(uri=\\\"ObtenerDuracionAnswer\\\",\\n answer_template=\\\"El curso tiene una duracion de {%duration%}\\\",\\n properties=[duration_prop])\\n # db.session.add(ObtenerDuracionAnswer)\\n ObtenerPrecioAnswer = Answer(uri=\\\"ObtenerPrecioAnswer\\\", answer_template=\\\"{%cost%}\\\", properties=[cost_prop])\\n # db.session.add(ObtenerPrecioAnswer)\\n ObtenerDocenteAnswer = Answer(uri=\\\"ObtenerDocenteAnswer\\\",\\n answer_template=\\\"El docente encargado del curso es {%teacherName%}\\\",\\n properties=[teacher_name_prop],\\n refers_to=\\\"http://127.0.0.1/ockb/course/ontology/hasTeacher\\\")\\n # db.session.add(ObtenerDocenteAnswer)\\n ObtenerContenidosAnswer = Answer(uri=\\\"ObtenerContenidosAnswer\\\",\\n answer_template=\\\"Los contenidos a tratar en el curso son {%content%}\\\",\\n properties=[content_name_prop],\\n refers_to=\\\"http://127.0.0.1/ockb/course/ontology/hasContenido\\\")\\n # db.session.add(ObtenerContenidosAnswer)\\n ListarCursosAnswer = Answer(uri=\\\"ListarCursosAnswer\\\",\\n answer_template=\\\"Los cursos de la oferta actual son: {%courseName%}\\\",\\n properties=[course_name_prop],\\n refers_to=\\\"http://127.0.0.1/ockb/course/ontology/hasCourse\\\",\\n answer_from=\\\"http://127.0.0.1/ockb/resources/OpenCampusFebrero-Julio\\\")\\n\\n # Setting up resolution\\n ObtenerInformacionResolution = Resolution(uri=\\\"ObtenerInformacionResolution\\\",\\n question=\\\"De que cursos deseas conocer\\\",\\n resolves=\\\"http://127.0.0.1/ockb/course/resource/Course\\\")\\n ObtenerFechasResolution = Resolution(uri=\\\"ObtenerFechasResolution\\\", question=\\\"De que cursos deseas conocer\\\",\\n resolves=\\\"http://127.0.0.1/ockb/course/resource/Course\\\")\\n ObtenerFechasInicioResolution = Resolution(uri=\\\"ObtenerFechasInicioResolution\\\",\\n question=\\\"De que cursos deseas conocer\\\",\\n resolves=\\\"http://127.0.0.1/ockb/course/resource/Course\\\")\\n ObtenerFechasFinResolution = Resolution(uri=\\\"ObtenerFechasFinResolution\\\",\\n question=\\\"De que cursos deseas conocer\\\",\\n resolves=\\\"http://127.0.0.1/ockb/course/resource/Course\\\")\\n ObtenerPrerequisitosResolution = Resolution(uri=\\\"ObtenerPrerequisitosResolution\\\",\\n question=\\\"De que cursos deseas conocer\\\",\\n resolves=\\\"http://127.0.0.1/ockb/course/resource/Course\\\")\\n ObtenerDuracionResolution = Resolution(uri=\\\"ObtenerDuracionResolution\\\", question=\\\"De que cursos deseas conocer\\\",\\n resolves=\\\"http://127.0.0.1/ockb/course/resource/Course\\\")\\n ObtenerPrecioResolution = Resolution(uri=\\\"ObtenerPrecioResolution\\\", question=\\\"De que cursos deseas conocer\\\",\\n resolves=\\\"http://127.0.0.1/ockb/course/resource/Course\\\")\\n ObtenerDocenteResolution = Resolution(uri=\\\"ObtenerDocenteResolution\\\", question=\\\"De que cursos deseas conocer\\\",\\n resolves=\\\"http://127.0.0.1/ockb/course/resource/Course\\\")\\n ObtenerContenidosResolution = Resolution(uri=\\\"ObtenerContenidosResolution\\\",\\n question=\\\"De que cursos deseas conocer\\\",\\n resolves=\\\"http://127.0.0.1/ockb/course/resource/Course\\\")\\n\\n # Setting up Entity\\n\\n curso_entity = Entity(name=\\\"http://127.0.0.1/ockb/course/resource/Course\\\")\\n\\n # setting up synonyms:\\n Synonym(name=\\\"Mooc\\\", entity=curso_entity)\\n Synonym(name=\\\"Taller\\\", entity=curso_entity)\\n Synonym(name=\\\"Curso\\\", entity=curso_entity)\\n Synonym(name=\\\"Open Course\\\", entity=curso_entity)\\n\\n # Setting up intents\\n\\n ObtenerInformacion = Intent(name=\\\"ObtenerInformacion\\\", agent=agent,\\n description=\\\"Obtener una breve descripcion del curso\\\",\\n answer=ObtenerInformacionAnswer, resolution=ObtenerInformacionResolution,\\n entities=[curso_entity])\\n ObtenerFechas = Intent(name=\\\"ObtenerFechas\\\", agent=agent,\\n description=\\\"Obtener las fechas importantes del curso\\\",\\n answer=ObtenerFechasAnswer, resolution=ObtenerFechasResolution, entities=[curso_entity])\\n ObtenerFechasInicio = Intent(name=\\\"ObtenerFechasInicio\\\", agent=agent,\\n description=\\\"Obtener las fechas de inicio del curso\\\",\\n answer=ObtenerFechasInicioAnswer, resolution=ObtenerFechasInicioResolution,\\n entities=[curso_entity])\\n ObtenerFechasFin = Intent(name=\\\"ObtenerFechasFin\\\", agent=agent,\\n description=\\\"Obtener las fechas de finalizacion del curso\\\",\\n answer=ObtenerFechasFinAnswer, resolution=ObtenerFechasFinResolution,\\n entities=[curso_entity])\\n ObtenerPrerequisitos = Intent(name=\\\"ObtenerPrerequisitos\\\", agent=agent,\\n description=\\\"Obtener prerequisitos del curso\\\",\\n answer=ObtenerPrerequisitosAnswer,\\n resolution=ObtenerPrerequisitosResolution)\\n ObtenerDuracion = Intent(name=\\\"ObtenerDuracion\\\", agent=agent,\\n description=\\\"Obtener la duracion del curso\\\", answer=ObtenerDuracionAnswer,\\n resolution=ObtenerDuracionResolution, entities=[curso_entity])\\n ObtenerPrecio = Intent(name=\\\"ObtenerPrecio\\\", agent=agent, description=\\\"Obtener el precio del curso\\\",\\n answer=ObtenerPrecioAnswer, resolution=ObtenerPrecioResolution, entities=[curso_entity])\\n ObtenerDocente = Intent(name=\\\"ObtenerDocente\\\", agent=agent,\\n description=\\\"Obtener los nombres de los docentes del curso\\\",\\n answer=ObtenerDocenteAnswer, resolution=ObtenerDocenteResolution,\\n entities=[curso_entity])\\n ObtenerContenidos = Intent(name=\\\"ObtenerContenidos\\\", agent=agent,\\n description=\\\"Obtener los contenidos del curso\\\",\\n answer=ObtenerContenidosAnswer, resolution=ObtenerDocenteResolution,\\n entities=[curso_entity])\\n ListarCursos = Intent(name=\\\"ListarCursos\\\", agent=agent,\\n description=\\\"Presentar la oferta actual de cursos\\\", answer=ListarCursosAnswer,\\n resolution=ObtenerContenidosResolution)\\n # Setting up sentences\\n\\n Sentence(intent=ObtenerInformacion, sentence=\\\"De que trata el mooc?\\\")\\n Sentence(intent=ObtenerInformacion, sentence=\\\"Quiero informacion del curso de emprendimiento\\\")\\n Sentence(intent=ObtenerInformacion, sentence=\\\"Muestrame un resumen del mooc?\\\")\\n Sentence(intent=ObtenerInformacion, sentence=\\\"Breve introducción al curso\\\")\\n Sentence(intent=ObtenerInformacion, sentence=\\\"que es emprendimiento\\\")\\n Sentence(intent=ObtenerInformacion, sentence=\\\"De que se trata el curso?\\\")\\n Sentence(intent=ObtenerInformacion, sentence=\\\"De qué va el curso?\\\")\\n Sentence(intent=ObtenerInformacion, sentence=\\\"Me ayudas con información acerca del curso?\\\")\\n Sentence(intent=ObtenerFechas, sentence=\\\"Cuáles son las fechas importantes del curso?\\\")\\n Sentence(intent=ObtenerFechas, sentence=\\\"Fechas clave del curso\\\")\\n Sentence(intent=ObtenerFechas, sentence=\\\"Que fechas debo tomar en cuenta\\\")\\n Sentence(intent=ObtenerFechas, sentence=\\\"fechas de inicio y fin\\\")\\n Sentence(intent=ObtenerFechas, sentence=\\\"Cuándo comienza el curso?\\\")\\n Sentence(intent=ObtenerFechas, sentence=\\\"Fechas importantes del curso de inteligencia artificial\\\")\\n Sentence(intent=ObtenerFechas, sentence=\\\"Cuáles son las fechas importantes del curso de emprendimiento\\\")\\n Sentence(intent=ObtenerFechasInicio, sentence=\\\"Cuándo inicia el curso de emprendimiento\\\")\\n Sentence(intent=ObtenerFechasInicio, sentence=\\\"Cuándo empiezan los cursos ?\\\")\\n Sentence(intent=ObtenerFechasInicio, sentence=\\\"Fecha de inicio de los moocs?\\\")\\n Sentence(intent=ObtenerFechasInicio, sentence=\\\"Día de inicio de los moocs ?\\\")\\n Sentence(intent=ObtenerFechasInicio, sentence=\\\"En que fecha inician los moocs?\\\")\\n Sentence(intent=ObtenerFechasInicio, sentence=\\\"A partir de que fecha empiezan los mooc?\\\")\\n Sentence(intent=ObtenerFechasFin, sentence=\\\"Cuando finaliza el curso?\\\")\\n Sentence(intent=ObtenerFechasFin, sentence=\\\"En que fecha termina el curso?\\\")\\n Sentence(intent=ObtenerFechasFin, sentence=\\\"Cuando termina el curso?\\\")\\n Sentence(intent=ObtenerPrerequisitos,\\n sentence=\\\"Cuáles son los requisitos necesarios para el curso de emprendimiento\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"Cuáles son los prerequisitos?\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"Requisitos previos de ingreso al curso\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"Dame a conocer los prerequisitos\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"Me puedes indicar los prerequistos necesarios?\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"Que necesito saber antes de iniciar el curso\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"que se necesita saber para este curso\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"Los pre requisitos cuales son?\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"Qué se necesita?\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"Qué debería saber para tomar el curso?\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"Qué conocimientos previos debo tener?\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"Qué tengo que saber?\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"Requisitos previos\\\")\\n Sentence(intent=ObtenerPrerequisitos, sentence=\\\"Conocimientos previos\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"Cuanto dura el curso de empendimiento\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"Duración del curso\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"Número de horas del mooc?\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"En cuántas semanas se realiza el curso?\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"Cuanto dura el curso\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"Tiempo que dura un curso?\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"cuanto puede durar un curso mooc\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"cuanto dura el curso?\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"cual es la duracion de psicologia social?\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"Cuánto tiempo dura el mooc?\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"De cuántas semanas es el mooc?\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"Cuántas horas dura el mooc?\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"Cuánto tiempo dura el mooc?\\\")\\n Sentence(intent=ObtenerDuracion, sentence=\\\"De cuántas semanas es el mooc?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Cual es el precio del curso de emprendimiento\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Cuál es el precio?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Cuánto vale?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Valor del curso?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Costo\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Inversión total del curso\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"cual es el valor de los componentes?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"costo de los cursos?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"cuanto cuesta los cursos\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Cuál es precio del curso?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Cuánto cuesta el mooc de Administración Empresarial?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"tiene algun valor los cursos?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Cuanto cuesta el curso Método Toyota?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Cuanto cuesta un curso?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Que vale el curso ?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Es gratis?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Cuanto vale el mooc?\\\")\\n Sentence(intent=ObtenerPrecio, sentence=\\\"Precio\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"Cual es el docente del curso de emprendimiento\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"Quién es mi profesor en el curso?\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"Docente del mooc?\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"Qué docente imparte el mooc?\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"Quién es el docente encargado de la materia?\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"Nombre del docente del mooc\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"Que profesor esta a cargo del curso\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"cual es mi docente del mooc\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"información del docente\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"Quién es el docente encargado?\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"Quién va a dar el MOOC\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"Que docente acompaña al estudiante?\\\")\\n Sentence(intent=ObtenerDocente, sentence=\\\"Cual es el profe de Salud Sexual y Reproductiva\\\")\\n Sentence(intent=ObtenerContenidos, sentence=\\\"Cuáles son los contenidos a tratar en el curos de emprendimiento\\\")\\n Sentence(intent=ObtenerContenidos, sentence=\\\"Contenido del curso\\\")\\n Sentence(intent=ObtenerContenidos, sentence=\\\"Cuál es la temática de cada curso?\\\")\\n Sentence(intent=ObtenerContenidos, sentence=\\\"Qué temas se van a tratar en cada curso?\\\")\\n Sentence(intent=ObtenerContenidos, sentence=\\\"De que se tratan los moocs\\\")\\n Sentence(intent=ObtenerContenidos, sentence=\\\"Cuáles son las temas del curso?\\\")\\n Sentence(intent=ObtenerContenidos, sentence=\\\"Que se va a tratar en este curso?\\\")\\n Sentence(intent=ObtenerContenidos, sentence=\\\"Qué se va a dar en el curso?\\\")\\n Sentence(intent=ListarCursos, sentence=\\\"Que cursos hay\\\")\\n Sentence(intent=ListarCursos, sentence=\\\"Muestrame los cursos\\\")\\n Sentence(intent=ListarCursos, sentence=\\\"Cual es la oferta actual\\\")\\n Sentence(intent=ListarCursos, sentence=\\\"Cuentame que cursos tienes\\\")\\n Sentence(intent=ListarCursos, sentence=\\\"Que cursos me ofreces\\\")\\n Sentence(intent=ListarCursos, sentence=\\\"Que cursos estan disponibles\\\")\\n Sentence(intent=ListarCursos, sentence=\\\"Listame los cursos\\\")\\n Sentence(intent=ListarCursos, sentence=\\\"Que cursos tiene\\\")\\n\\n # db.session.add(intent_obtenerinformacion)\\n # db.session.add(intent_obtenerfechas)\\n # db.session.add(intent_obtenerfechasinicio)\\n # db.session.add(intent_obtenerfechasfin)\\n # db.session.add(intent_obtenerprerequisitos)\\n # db.session.add(intent_obtenerduracion)\\n # db.session.add(intent_obtenerprecio)\\n # db.session.add(intent_obtenerdocente)\\n # db.session.add(intent_obtenercontenidos)\\n # db.session.add(intent_listarCursos)\\n\\n db.session.commit()\",\n \"async def on_startup(self):\\n await self.controller.database.connect()\",\n \"def agent_init(self):\\n pass\",\n \"def load_agents(self, agents):\\n self.agents = agents\",\n \"def connect(self):\\n super(NERDmLoader, self).connect()\\n self.lateloadr._client = self._client\\n self.lateloadr._db = self._db\\n self.relloadr._client = self._client\\n self.relloadr._db = self._db\",\n \"def initialize():\\n\\t\\tDBHelper.con = mdb.connect('localhost', 'root', 'sensepass', 'sensecambrowser')\",\n \"def init(self):\\n self._service_store = ServiceStore(self.driver, self.network)\\n self._emulator = NetworkEmulator(self.store, self.driver)\",\n \"def __init__(self):\\n self.databases = []\",\n \"def initialize(self):\\n self.population.initialize()\\n self.cache.initialize()\\n if self.storage:\\n self.storage.initialize()\",\n \"async def prepare_databases(self):\",\n \"def __init__(self, wm) -> None:\\n conf_dict = wm.context.config.arango_storage._to_dict()\\n\\n log.debug(conf_dict)\\n client = ArangoClient(hosts=conf_dict['hosts'])\\n db = client.db(conf_dict['database'],\\n username=conf_dict['username'],\\n password=conf_dict['password'])\\n\\n self.db = db\\n self.client = client\",\n \"def initialize():\\n DATABASE.connect()\\n DATABASE.drop_tables([Journal], safe=True)\\n DATABASE.create_tables([Journal], safe=True)\\n DATABASE.close()\",\n \"def set_local_database():\\n load_config()\\n db_path = get_db_path_from_config()\\n db = LocalDB(db_path, log=None)\\n return db\",\n \"def _init(self):\\n if os.path.exists(self.fname):\\n with open(self.fname, \\\"rb\\\") as fh:\\n self.db = pickle.load(fh)\\n else:\\n self.db = {}\\n print(\\\"DB loaded, len\\\", len(self.db))\",\n \"def __init__(self):\\r\\n ms_cli_root = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))\\r\\n self._working_dir = os.path.join(\\\".localdata\\\")\\r\\n self._db = None\\r\\n self._db_name = \\\"ms-cli.db\\\"\\r\\n self._db_models = db_base\\r\\n self._conf_file_name = \\\"ms-cli.conf\\\"\\r\\n self._db_map = {}\\r\\n\\r\\n self._appconfig = None\\r\\n self._session = None\\r\\n self._current_user_guid = None\\r\\n\\r\\n self.init_dir()\",\n \"def _connect(self):\\n database_file = get_database_filename()\\n if not os.path.isfile(database_file):\\n logger.error('No capabilities database found')\\n logger.error(\\n 'To import a database from xml: a2p2v --importdb <filename>.xml'\\n )\\n else:\\n self.conn = sqlite3.connect(database_file)\",\n \"def init():\\n database.create_tables([Tracker])\\n database.commit()\",\n \"def _initilise_graph_db(self):\\n for collector in self.collectors:\\n collector.init_graph_db()\",\n \"def __init__(self):\\n self.database = Database()\\n self.load_config()\",\n \"def initDB():\\n global DATABASE\\n\\n uid0 = generate_resource_uid('Admin1', 0)\\n\\n DATABASE[\\\"users\\\"] = {\\n \\\"Admin1\\\": {\\n \\\"Type\\\": \\\"admin\\\",\\n \\\"Password\\\": \\\"AdminPass\\\",\\n \\\"Quota\\\": int(sys.maxsize),\\n \\\"Resources\\\": {uid0},\\n \\\"Created\\\": 1,\\n },\\n \\\"User1\\\": {\\n \\\"Type\\\": \\\"user\\\",\\n \\\"Password\\\": \\\"UserPass\\\",\\n \\\"Quota\\\": int(sys.maxsize),\\n \\\"Resources\\\": set([]),\\n \\\"Created\\\": 0,\\n }\\n }\\n\\n DATABASE[\\\"resources\\\"] = {\\n uid0: \\\"Admin1\\\",\\n }\",\n \"def __init_database(self):\\n from admin.database import init_db\\n init_db()\",\n \"def __post_init__(self):\\n self.dbase = databases.Database(\\n self.dsn,\\n min_size=self.min_size,\\n max_size=self.max_size\\n )\\n self.engine, self.meta = self.get_engine_metadata()\",\n \"def initialize(self):\\n\\n db = dict()\\n\\n db['meta'] = Meta(None)\\n db['race'] = Race(None, None, None, None, None)\\n db['track'] = Track(None, None)\\n db['classes'] = set([])\\n db['teams'] = set([])\\n db['drivers'] = set([])\\n\\n self.db = db\",\n \"def __init__(self):\\n\\t\\tself.obtainDatabaseConnection()\",\n \"def initialize(self):\\n\\n \\\"*** YOUR CODE HERE\\\"\\n self.path = []\\n MyAgent.customFood = None\\n MyAgent.foodLeft = 0\\n MyAgent.specialWalls = {}\\n self.followOne = False\\n if self.index == 0:\\n MyAgent.finding = []\\n MyAgent.finding.append(False)\",\n \"def init(self):\\n self.db.connect()\\n try:\\n self.db.create_tables([JambiModel], safe=True)\\n JambiModel.create(ref='0')\\n self.logger.info('Database initialized')\\n except IntegrityError:\\n self.logger.info('Database was already initialized')\\n self.db.close()\",\n \"def __init__(self):\\n\\n self.__path = \\\"DataBase.db\\\"\\n self.__admins = []\\n self.__update_admin_cache()\",\n \"def _create_db(self):\\n self.db = easydms.dbcore.Database(\\\":memory:\\\")\\n self.db.create_db()\",\n \"def load_model(self):\\n if torch.cuda.is_available():\\n map_location=lambda storage, loc: storage.cuda()\\n else:\\n map_location='cpu'\\n\\n for index, agent in enumerate(self.agents):\\n agent.actor_local.load_state_dict(torch.load('agent{}_checkpoint_actor.pth'.format(index + 1), map_location=map_location))\\n agent.critic_local.load_state_dict(torch.load('agent{}_checkpoint_critic.pth'.format(index + 1), map_location=map_location))\",\n \"def init_db() -> None:\\n conn = sqlite3.connect('../Utils/map_storage.db')\\n cursor = conn.cursor()\\n\\n with conn:\\n station_cmd = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS\\n nodes(city TEXT, name TEXT, is_station TEXT, x INT, y INT, zone TEXT)\\\"\\\"\\\"\\n\\n cursor.execute(station_cmd)\\n\\n connection_cmd = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS\\n connections(city TEXT, name_1 TEXT, name_2 TEXT, color TEXT)\\\"\\\"\\\"\\n\\n cursor.execute(connection_cmd)\",\n \"def _load_local():\\n local = session.get('local')\\n\\n if local is None:\\n g.local = None\\n else:\\n g.local = local\",\n \"def __init__(self, agent = None, region = None, settings = None, message_handler = None, events_handler = None):\\n super(ObjectManager, self).__init__(agent, settings)\\n self.region = region\\n\\n # the object store consists of a list\\n # of Object() instances\\n self.object_store = []\\n\\n # the avatar store consists of a list\\n # of Avatar() instances\\n self.avatar_store = []\\n\\n # other useful things\\n self.helpers = Helpers()\\n\\n self.message_handler = message_handler\\n\\n if self.settings.LOG_VERBOSE: logger.info(\\\"Initializing object storage\\\")\",\n \"def initDatabase(self):\\n\\n try:\\n self.dbase = workflowManager(self.wf_name)\\n\\n working = self.config['working_d']\\n self.dbase.initWorkflow(self.wf_name, working)\\n\\n except sqlite3.Error as error:\\n self.logger.warning('Database %s: %s', self.wf_name, error.args)\\n #print('Database %s: %s', self.wf_name, error.args)\\n\\n return\",\n \"async def conn(self) -> None:\\n self.bot.db = await aiosqlite.connect('database.db')\",\n \"def connect_env(self,environment,agentIndex,allAgents):\\n self.environment = environment\\n self.agentIndex = agentIndex\\n self.allAgents = allAgents\\n environment.connect_server(agentIndex)\",\n \"def setup(cls):\\n cls.runner = CliRunner()\\n cls.agent_name = \\\"myagent\\\"\\n cls.cwd = os.getcwd()\\n cls.t = tempfile.mkdtemp()\\n # copy the 'packages' directory in the parent of the agent folder.\\n shutil.copytree(Path(CUR_PATH, \\\"..\\\", \\\"packages\\\"), Path(cls.t, \\\"packages\\\"))\\n\\n os.chdir(cls.t)\\n result = cls.runner.invoke(\\n cli,\\n [*CLI_LOG_OPTION, \\\"init\\\", \\\"--author\\\", AUTHOR],\\n standalone_mode=False,\\n )\\n assert result.exit_code == 0\\n result = cls.runner.invoke(\\n cli,\\n [*CLI_LOG_OPTION, \\\"create\\\", \\\"--local\\\", cls.agent_name],\\n standalone_mode=False,\\n )\\n assert result.exit_code == 0\\n os.chdir(cls.agent_name)\\n # add connection first time\",\n \"def init_database(self):\\n # init_database(self.engine)\",\n \"def bootstrap(self):\\n\\n self.db = connection_manager.get(DbConnection, host=self.ip, port=3306, user=self.user, password=self.password)\\n\\n self.connected = True\",\n \"def __init__(self, fname):\\n self.fname = fname\\n self.connection = sqlite3.connect(fname)\\n self.cursor = self.connection.cursor()\\n print(f\\\"Connection to file {fname.split('/')[-1]} established.\\\")\\n \\n self.t_init = self.get_initial_time()\\n self.duration = self.query(\\\"Duration\\\", \\\"Info\\\")[0]\\n\\n # (key,value): (agentId, name), (name, agentId),\\n # (spec, agentId), (agentId, spec)\\n agents = self.get_agents()\\n self.agents = agents[0]\\n self.names = agents[1]\\n self.specs = agents[2]\\n self.agentIds = agents[3]\\n\\n return\",\n \"def setupDatabases(self):\\n param = self.getDefaultDatabaseConnectionParameter()\\n db = DatabaseFactory.getDatabase(self.defaultDriver(), {})\\n db.createDatabase(param)\\n db.connect(param)\\n if db.isConnected():\\n self.settingsDb = db\\n db.createObservations()\\n db.createSensors()\\n else:\\n return False\\n # replace by settings validation method later\\n return self.check()\",\n \"def init_db():\\n global app\\n Promotions.init_db(app)\",\n \"def init():\\n global __dbChanged\\n __dbChanged = False\\n loadItemsFromFile()\\n global __isInitialized\\n if __isInitialized == True:\\n return\\n\\n Report.trace(\\\"itemdatabase\\\", \\\"Initializing the item database.\\\")\\n returnCode = FilterManager.executeFiltersForEvent(\\\"preInitializeItemDatabase\\\")\\n if returnCode == FilterManager.FINISHED:\\n Report.trace(\\\"itemdatabase\\\", \\\"Item database initialized.\\\")\\n __isInitialized = True\\n return\\n\\n for item in Items.items:\\n addItem(item)\\n\\n FilterManager.executeFiltersForEvent(\\\"postInitializeItemDatabase\\\")\\n __isInitialized = True\\n Report.trace(\\\"itemdatabase\\\", \\\"Item database initialized.\\\")\",\n \"def main_storer():\\n config.config_storer()\\n create_storer_paths()\\n create_storer_git_repo()\\n create_db()\\n _logger.info(' -- storer init done setting up paths and db file.')\",\n \"def __init__(self):\\n\\n self.storage: list = Storage()\\n\\n # Start for get data in API and set in storage\\n self._set_proxies_in_storage()\",\n \"def init_db():\\n db.drop_all()\\n db.create_all()\\n\\n print(\\\"Initialized Connect 4 Database.\\\")\",\n \"def _initialize_database(self) -> None:\\n with self._sqlite_connection:\\n self._sqlite_connection.execute('''CREATE TABLE IF NOT EXISTS articles (\\n feed_id INTEGER,\\n identifier TEXT,\\n uri TEXT,\\n title TEXT,\\n updated FLOAT,\\n author TEXT,\\n content TEXT,\\n unread BOOLEAN,\\n flag BOOLEAN)''')\",\n \"def _instantiate_graph_db(self):\\n graph_db_name = self.conf_manager.get_graph_db()\\n plugin_parameters = [self.conf_manager]\\n self.graph_db = self._load_plugins([graph_db_name],\\n common.GRAPH_PACKAGE,\\n paths.GRAPH_DB_DIR,\\n plugin_parameters)[0]\",\n \"def __init__(self):\\n try:\\n self._chat_db = sqlite3.connect(CHAT_DB_PATH)\\n except OperationalError:\\n print(\\\"Cannot access chat database.\\\\nGo to Settings->Security and Privacy->Privacy->Full Disk Access.\\\\n\\\"\\n \\\"Give access to the application you are running and restart the program.\\\")\\n sys.exit(1)\\n\\n self._contacts = Contacts(self._chat_db).get_contacts_df()\\n\\n try:\\n self._message_db = sqlite3.connect(WEEKLY_MESSAGES_DB_PATH)\\n except OperationalError:\\n print(\\\"Could not connect to the database server.\\\")\\n sys.exit(1)\",\n \"def connect_db_and_load_data(cls):\\n db.connect()\\n db.create_tables([Product], safe=True)\\n load_data(transform_data('./inventory.csv'))\",\n \"def initialize_environment(self):\\n logging.debug(\\\"initialize_environment called\\\")\\n try:\\n # logging.info(\\\"Creating networks...\\\")\\n self.create_networks()\\n self.create_machines()\\n self.save()\\n except Exception, e:\\n # something went wrong with the creating of the networks\\n logging.warn(\\\"Exception encountered\\\")\\n import traceback\\n logging.debug(traceback.print_exc())\\n raise e\\n return True\",\n \"def initialize():\\n db.connect()\\n db.create_tables([Expense], safe=True)\",\n \"def init_db(self):\\n if self.is_client() or not self.is_responsible_validator():\\n return\\n\\n ip, _ = self.experiment.get_peer_ip_port_by_id(self.my_id)\\n\\n self.db_path = os.path.join(\\\"/tmp\\\", \\\"postgres-data\\\", ip)\\n shutil.rmtree(self.db_path, ignore_errors=True)\\n os.makedirs(self.db_path, exist_ok=True)\\n\\n os.system(\\\"/usr/lib/postgresql/11/bin/initdb %s > postgres.out\\\" % self.db_path)\",\n \"def init_database(self):\\n init_database(self.engine)\",\n \"def __init__(self):\\n self._datastore = dict()\",\n \"def initialize_connection():\\n session = imdb.IMDb()\\n return session\",\n \"def os_start_db( self, ):\\r\\n pass\",\n \"def initialize():\\n manager.initialize()\\n logs.exit_great_success()\",\n \"def __init__(self):\\n os.system('cls')\\n\\n # Declare instance variables\\n self.hosts = []\\n self.offline_hosts = []\\n\\n # Populate the host list\\n self.create_host_list()\",\n \"def connect(self):\\n self.cluster = Cluster([self.db_node])\\n try:\\n self.session = self.cluster.connect()\\n self.session.default_timeout = DEFAULT_TIMEOUT\\n except Exception as e:\\n raise StorageError(\\\"Cannot connect to {}\\\".format(self.db_node), e)\",\n \"def setup(cls):\\n super().setup()\\n cls.db = DBCommunication()\",\n \"def initialize_database():\\n db = Database(database_name)\\n i, m, u, p = db.fetch_needed_data()\\n\\n return i, m, u, p\",\n \"def initialize(self):\\n if self.real:\\n self.agent.connect(self)\\n else:\\n self.connect() # Connect python client to VREP\\n self.agent.connect(self)\",\n \"def test_init(self):\\n self.assertIsNotNone(DatabaseIntermediary(), self.ec.db)\",\n \"def initialized_tasks_db(tmpdir):\\n tasks.start_tasks_db(str(tmpdir), 'tiny')\\n\\n yield # This is where the testing happens\\n\\n tasks.stop_tasks_db()\",\n \"def _init_agents(self):\\n self.agents = [Agent(e=0.1, a=0.1, row=self.row, col=self.col) for i in range(2)]\",\n \"def __init__(self):\\n\\n self.db = ImageDB()\\n self.vitess = VitessConn()\\n self.minio = MinioConn()\",\n \"async def async_initialize(self) -> None:\\n prefs = await self._store.async_load()\\n\\n if prefs is None:\\n prefs = {}\\n\\n self._prefs = prefs\",\n \"def initialize():\\n DATABASE.connect()\\n DATABASE.create_tables([User, Entry], safe=True)\\n DATABASE.close()\",\n \"def Init(self, agentEnv):\\n self.agentEnv = agentEnv\",\n \"def database_setup():\\n Base.metadata.create_all(bind=engine)\\n db = LocalSession()\\n try:\\n populate_from_json(db, Vector, str(VECTORS))\\n populate_from_json(db, Gender, str(GENDERS))\\n populate_from_json(db, Tag, str(TAGS))\\n finally:\\n db.close()\",\n \"def init_db():\\n _conn = sqlite3.connect('results/offerings.db')\\n _conn.execute('''CREATE TABLE IF NOT EXISTS offerings (\\n link TEXT PRIMARY KEY,\\n title TEXT,\\n university TEXT,\\n category TEXT,\\n fare INTEGER)''')\\n _conn.commit()\\n return _conn\",\n \"def setUp(self):\\n self.a = backend.dbconnection.DBConnect()\",\n \"def __init__(self):\\n self.storage = None\\n self.user = None\\n self.master_collection = None\\n self.current_collection = None\",\n \"def initdb(self):\\n logger.info(\\\"Initializing database\\\")\\n self.instances.drop()\\n self.instances.create_index([('class_id', pymongo.HASHED)])\\n # Creates a unique index\\n self.instances.create_index(\\n 'name',\\n unique=True,\\n partialFilterExpression={'deleted' : False}\\n )\\n start_time = time.time()\\n timeout = 60 * 5\\n while not self.axops_client.ping():\\n if time.time() - start_time > timeout:\\n raise AXTimeoutException(\\\"Timed out ({}s) waiting for axops availability\\\".format(timeout))\\n time.sleep(3)\\n\\n for fix_doc in self.axdb_client.get_fixture_instances():\\n instance = FixtureInstance.deserialize_axdbdoc(fix_doc)\\n self.instances.insert_one(instance.mongodoc())\\n\\n logger.info(\\\"Database initialized\\\")\",\n \"def initialized_tasks_db(tmpdir):\\n # Setup : start db\\n tasks.start_tasks_db(str(tmpdir), 'tiny')\\n\\n yield # this is where the testing happens\\n\\n # Teardown : stop db\\n tasks.stop_tasks_db()\",\n \"def initialize(self):\\n self.candidate_disease_list = []\\n self.candidate_symptom_list = []\\n self.agent_action = {\\n \\\"turn\\\":None,\\n \\\"action\\\":None,\\n \\\"request_slots\\\":{},\\n \\\"inform_slots\\\":{},\\n \\\"explicit_inform_slots\\\":{},\\n \\\"implicit_inform_slots\\\":{},\\n \\\"speaker\\\":\\\"agent\\\"\\n }\",\n \"async def _initialize_from_database(self):\\n\\n _LOGGER.debug(\\\"%s: initializing values from the database\\\", self.entity_id)\\n\\n with session_scope(hass=self.hass) as session:\\n query = session.query(States).filter(\\n States.entity_id == self._source_entity_id.lower()\\n )\\n\\n if self._samples_max_age is not None:\\n records_older_then = dt_util.utcnow() - self._samples_max_age\\n _LOGGER.debug(\\n \\\"%s: retrieve records not older then %s\\\",\\n self.entity_id,\\n records_older_then,\\n )\\n query = query.filter(States.last_updated >= records_older_then)\\n else:\\n _LOGGER.debug(\\\"%s: retrieving all records\\\", self.entity_id)\\n\\n query = query.order_by(States.last_updated.desc()).limit(\\n self._samples_max_buffer_size\\n )\\n states = execute(query, to_native=True, validate_entity_ids=False)\\n\\n for state in reversed(states):\\n self._add_state_to_queue(state)\\n\\n self.async_schedule_update_ha_state(True)\\n\\n _LOGGER.debug(\\\"%s: initializing from database completed\\\", self.entity_id)\",\n \"def init_db():\\n # We are setting the module variables here for the first time, so disable the warning\\n global DB_USER_TABLE # pylint: disable=global-variable-undefined\\n global DB_CUSTOMER_TABLE # pylint: disable=global-variable-undefined\\n global DB_USER_CUSTOMER_RELS_TABLE # pylint: disable=global-variable-undefined\\n global DB_TICKET_TABLE # pylint: disable=global-variable-undefined\\n global DB_COMMENT_TABLE # pylint: disable=global-variable-undefined\\n\\n db = TinyDB(app.config['DB_NAME'])\\n\\n DB_USER_TABLE = db.table('users')\\n DB_CUSTOMER_TABLE = db.table('customers')\\n DB_USER_CUSTOMER_RELS_TABLE = db.table('user_customer_rels')\\n DB_TICKET_TABLE = db.table('tickets')\\n DB_COMMENT_TABLE = db.table('comments')\",\n \"async def open(self):\\n self.db = await self.pool\\n return self\",\n \"def init_data_base_activity(path):\\n\\n conn = sqlite3.connect(path)\\n c = conn.cursor()\\n\\n c.execute(\\\"DROP TABLE IF EXISTS Activity\\\")\\n c.execute('''CREATE TABLE Activity\\n (\\n inseeNb TEXT, comLib TEXT, equipementId TEXT,\\n equNbEquIdentique TEXT, actCode TEXT,actLib TEXT,\\n equActivitePraticable TEXT, equActivitePratique TEXT,\\n equActiviteSalleSpe TEXT, actNivLib TEXT\\n )'''\\n )\\n\\n conn.commit()\\n conn.close()\",\n \"def __init__(self):\\n self._connection = get_db_connection()\",\n \"def init_db():\\n\\tdb.drop_all()\\n\\tdb.create_all()\\n\\n\\tprint(\\\"Initialized Database.\\\")\\n\\treturn\",\n \"def init_neo4j_db():\\n try:\\n app.neo4j_driver = GraphDatabase.driver(\\n app.config[\\\"NEO4J_URI\\\"],\\n auth=(app.config[\\\"NEO4J_USER\\\"], app.config[\\\"NEO4J_PWD\\\"])\\n )\\n except AuthError:\\n app.neo4j_driver = None\\n app._neo4j_up = True\\n except:\\n app.neo4j_driver = None\\n app._neo4j_up = False\",\n \"def __init__(self):\\r\\n date_time('Connecting to local database ...')\\r\\n\\r\\n self.conn = sqlite3.connect(DATABASE_PATH)\\r\\n self.cursor = self.conn.cursor()\\r\\n\\r\\n # Set up database\\r\\n self.cursor.execute('PRAGMA synchronous = OFF')\\r\\n self.cursor.execute('PRAGMA journal_mode = OFF')\\r\\n self.cursor.execute('PRAGMA locking_mode = EXCLUSIVE')\\r\\n self.cursor.execute('PRAGMA count_changes = FALSE')\\r\\n\\r\\n self.cursor.execute('CREATE TABLE IF NOT EXISTS citations (id INTEGER PRIMARY KEY, citation TEXT UNIQUE);')\",\n \"def initialize():\\n\\n db.connect() # Se conecta\\n db.create_tables([Entry], safe=True) # Crea las tablas\\n # safe=true evita crear modelos ya creados\",\n \"def __initDataFromImages(self):\\n #Check if the local_db exist\\n initial_dirs = os.listdir(os.getcwd())\\n is_db_empty = False\\n if len(os.listdir(self.base_dir)) == 1: #Empty here means no person data\\n [images_dir] = os.listdir(self.base_dir)\\n is_db_empty = images_dir == cfg.local[\\\"IMG_DIR\\\"]\\n if cfg.local[\\\"DEFAULT_IMGS_DIR\\\"] in initial_dirs and is_db_empty:\\n default_path = os.path.join(os.getcwd(), cfg.local[\\\"DEFAULT_IMGS_DIR\\\"])\\n self.X, self.y = loadDataFromImagesPath(self.detector, default_path)\\n self.le = LabelEncoder()\\n #Nothing relate to mapping name to dir here, we don't care about\\n #This data because of the user doesn't exist in the database\\n self.__savePreProcessedData()\",\n \"def initdb(self, default):\\r\\n # set the default modulestore\\r\\n self.options['stores']['default'] = self.options['stores'][default]\\r\\n self.store = MixedModuleStore(**self.options)\\r\\n self.addCleanup(self.store.close_all_connections)\\r\\n\\r\\n # convert to CourseKeys\\r\\n self.course_locations = {\\r\\n course_id: SlashSeparatedCourseKey.from_deprecated_string(course_id)\\r\\n for course_id in [self.MONGO_COURSEID, self.XML_COURSEID1, self.XML_COURSEID2]\\r\\n }\\r\\n # and then to the root UsageKey\\r\\n self.course_locations = {\\r\\n course_id: course_key.make_usage_key('course', course_key.run)\\r\\n for course_id, course_key in self.course_locations.iteritems() # pylint: disable=maybe-no-member\\r\\n }\\r\\n self.fake_location = Location('foo', 'bar', 'slowly', 'vertical', 'baz')\\r\\n self.import_chapter_location = self.course_locations[self.MONGO_COURSEID].replace(\\r\\n category='chapter', name='Overview'\\r\\n )\\r\\n self.xml_chapter_location = self.course_locations[self.XML_COURSEID1].replace(\\r\\n category='chapter', name='Overview'\\r\\n )\\r\\n # get Locators and set up the loc mapper if app is Locator based\\r\\n if default == 'split':\\r\\n self.fake_location = loc_mapper().translate_location(self.fake_location)\\r\\n\\r\\n self._create_course(default, self.course_locations[self.MONGO_COURSEID].course_key)\",\n \"def init():\\n database = \\\"database.pkl\\\"\\n\\n onsite_bills = BillID(database)\\n online_bills = BillID(database)\\n\\n return onsite_bills, online_bills\",\n \"def _init_storage(self):\\n if self._ is None:\\n self._ = Parameters(self)\",\n \"def initialize_database():\\n # Create the schema\\n Base.metadata.create_all(engine)\\n\\n # Create a connection/database session\\n session = Session()\\n\\n # Now, create a few restaurants:\\n cupcake = Restaurant(name=\\\"Cupcakes\\\")\\n five_guys = Restaurant(name=\\\"Five Guys\\\")\\n ihop = Restaurant(name=\\\"IHOP\\\")\\n\\n # And a few users:\\n mike = User(name=\\\"Mike\\\")\\n ryan = User(name=\\\"Ryan\\\")\\n\\n # And finally a few votes:\\n mike.preferences.append(Preference(vote=\\\"+1\\\", restaurant=five_guys))\\n ryan.preferences.append(Preference(vote=\\\"+0\\\", restaurant=five_guys))\\n ryan.preferences.append(Preference(vote=\\\"-0\\\", restaurant=cupcake))\\n\\n session.add(mike)\\n session.add(ryan)\\n session.add(ihop)\\n\\n session.commit()\\n\\n session.close()\",\n \"def _connect(self) -> None:\\n if self._agent_thread.is_alive():\\n raise ValueError(\\\"Agent already running.\\\")\\n self._agent_thread.start()\\n\\n while not self._agent.runtime.is_running: # check agent completely running\\n time.sleep(0.01)\",\n \"def __init__(self):\\n\\n catalog.connect_database()\\n catalog.clean_db()\\n self.viewer = Viewer()\\n self.editor = Editor()\",\n \"def __init__(self, database=\\\"featurehub\\\"):\\n\\n self.__orm = ORMManager(database)\\n\\n if not database_exists(self.__orm.engine.url):\\n print(\\\"Database {} does not exist.\\\".format(database),\\n file=sys.stderr)\\n print(\\\"You might want to create it by calling set_up method\\\",\\n file=sys.stderr)\",\n \"def initialize_storage(cfg: ElasticBlastConfig, query_files: List[str] = [], wait=ElbExecutionMode.WAIT) -> None:\\n use_local_ssd = cfg.cluster.use_local_ssd\\n if use_local_ssd:\\n initialize_local_ssd(cfg, query_files, wait)\\n else:\\n initialize_persistent_disk(cfg, query_files, wait)\",\n \"def __init__(self):\\r\\n self.conn = create_connection(DATABASE_PATH)\",\n \"def initialization_step(self):\\n # Update where agents are\\n self.update_agent_location_vector()\\n # update task locations\\n self.update_task_location_vector()\\n # update deadlines\\n self.populate_deadline_vector()\\n # update distances to each task and orientation to each task\\n self.update_agent_distances_vector()\\n self.update_agent_orientation_vector()\",\n \"def startSession(self):\\n self.storage.insert(self.__json__())\",\n \"def fetch_initial_states(self):\\n for agent_id, agent_obj in self.__registered_agents.items():\\n # given the agent's capabilities, get everything the agent can perceive\\n state = self.__get_agent_state(agent_obj)\\n\\n # filter other things from the agent state\\n filtered_agent_state = agent_obj.filter_observations(state)\\n\\n # save the current agent's state for the API\\n api.add_state(agent_id=agent_id, state=filtered_agent_state,\\n agent_inheritence_chain=agent_obj.class_inheritance,\\n world_settings=api.MATRX_info)\\n\\n # add god state\\n api.add_state(agent_id=\\\"god\\\", state=self.__get_complete_state(), agent_inheritence_chain=\\\"god\\\",\\n world_settings=api.MATRX_info)\\n\\n # initialize the message manager\\n self.message_manager.agents = self.__registered_agents.keys()\\n self.message_manager.teams = self.__teams\\n\\n # make the information of this tick available via the API, after all\\n # agents have been updated\\n api.next_tick()\",\n \"def init_agent(self, kwargs):\\n\\n exp_params = [('agents_info', is_string),\\n ('ip', is_string)]\\n try:\\n agents_info, agent_ip = check_arguments(exp_params, kwargs)\\n agents_info = simplejson.loads(agents_info)\\n except Exception as ex:\\n return HttpErrorResponse(\\\"%s\\\" % ex)\\n\\n self.logger.info('Setting agent environment')\\n\\n target_dir = self.VAR_CACHE\\n with open(join(target_dir, 'agents.json'), 'w') as outfile:\\n simplejson.dump(agents_info, outfile)\\n\\n agent_role = [i['role'] for i in agents_info if i['ip'] == agent_ip][0]\\n master_ip = [i['ip'] for i in agents_info if i['role'] == 'master'][0]\\n\\n self.env.update({'MY_IP':agent_ip})\\n self.env.update({'MY_ROLE':agent_role})\\n self.env.update({'MASTER_IP':master_ip})\\n\\n self.logger.info('Agent initialized')\\n return HttpJsonResponse()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6617449","0.61237335","0.5979491","0.5936732","0.59310615","0.5922503","0.58505607","0.5802189","0.57936794","0.5789929","0.5780297","0.5701071","0.56965166","0.56882364","0.56478816","0.5633063","0.56197894","0.5587522","0.558614","0.55832756","0.5567255","0.55670804","0.5557149","0.5548393","0.5546251","0.5541251","0.55324477","0.5507465","0.5498488","0.54879457","0.5481782","0.5474957","0.5463838","0.54561096","0.5437079","0.5436831","0.54149425","0.5413458","0.5409564","0.5407819","0.5407216","0.54022485","0.53998965","0.53835374","0.5375788","0.5375753","0.537353","0.53641087","0.5352884","0.53466684","0.53457916","0.53444713","0.5343914","0.5337972","0.5336967","0.533592","0.5335336","0.5333462","0.53287417","0.5327602","0.53131026","0.5300933","0.5298322","0.5298078","0.5291048","0.5288821","0.5286547","0.5282338","0.5277513","0.52718836","0.52707833","0.52631724","0.52608","0.5255968","0.52502626","0.52497107","0.5247673","0.524619","0.52378464","0.5224239","0.52242213","0.5222393","0.521932","0.5216524","0.52138054","0.52125835","0.52014345","0.52013695","0.5192961","0.5190773","0.51887023","0.5187839","0.5187205","0.51860493","0.5181772","0.5168371","0.5167617","0.5166864","0.51645094","0.516038"],"string":"[\n \"0.6617449\",\n \"0.61237335\",\n \"0.5979491\",\n \"0.5936732\",\n \"0.59310615\",\n \"0.5922503\",\n \"0.58505607\",\n \"0.5802189\",\n \"0.57936794\",\n \"0.5789929\",\n \"0.5780297\",\n \"0.5701071\",\n \"0.56965166\",\n \"0.56882364\",\n \"0.56478816\",\n \"0.5633063\",\n \"0.56197894\",\n \"0.5587522\",\n \"0.558614\",\n \"0.55832756\",\n \"0.5567255\",\n \"0.55670804\",\n \"0.5557149\",\n \"0.5548393\",\n \"0.5546251\",\n \"0.5541251\",\n \"0.55324477\",\n \"0.5507465\",\n \"0.5498488\",\n \"0.54879457\",\n \"0.5481782\",\n \"0.5474957\",\n \"0.5463838\",\n \"0.54561096\",\n \"0.5437079\",\n \"0.5436831\",\n \"0.54149425\",\n \"0.5413458\",\n \"0.5409564\",\n \"0.5407819\",\n \"0.5407216\",\n \"0.54022485\",\n \"0.53998965\",\n \"0.53835374\",\n \"0.5375788\",\n \"0.5375753\",\n \"0.537353\",\n \"0.53641087\",\n \"0.5352884\",\n \"0.53466684\",\n \"0.53457916\",\n \"0.53444713\",\n \"0.5343914\",\n \"0.5337972\",\n \"0.5336967\",\n \"0.533592\",\n \"0.5335336\",\n \"0.5333462\",\n \"0.53287417\",\n \"0.5327602\",\n \"0.53131026\",\n \"0.5300933\",\n \"0.5298322\",\n \"0.5298078\",\n \"0.5291048\",\n \"0.5288821\",\n \"0.5286547\",\n \"0.5282338\",\n \"0.5277513\",\n \"0.52718836\",\n \"0.52707833\",\n \"0.52631724\",\n \"0.52608\",\n \"0.5255968\",\n \"0.52502626\",\n \"0.52497107\",\n \"0.5247673\",\n \"0.524619\",\n \"0.52378464\",\n \"0.5224239\",\n \"0.52242213\",\n \"0.5222393\",\n \"0.521932\",\n \"0.5216524\",\n \"0.52138054\",\n \"0.52125835\",\n \"0.52014345\",\n \"0.52013695\",\n \"0.5192961\",\n \"0.5190773\",\n \"0.51887023\",\n \"0.5187839\",\n \"0.5187205\",\n \"0.51860493\",\n \"0.5181772\",\n \"0.5168371\",\n \"0.5167617\",\n \"0.5166864\",\n \"0.51645094\",\n \"0.516038\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.558001"},"document_rank":{"kind":"string","value":"20"}}},{"rowIdx":92095,"cells":{"query":{"kind":"string","value":"Returns a singular database connection to be shared amongst all calls for a given thread."},"document":{"kind":"string","value":"def _get_connection(self) -> sqlite3.Connection:\n curr_thread = threading.get_ident()\n if curr_thread not in self.conn or self.conn[curr_thread] is None:\n conn = sqlite3.connect(self.db_path, check_same_thread=False)\n conn.row_factory = sqlite3.Row\n self.conn[curr_thread] = conn\n return self.conn[curr_thread]"},"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 _get_connection(self) -> Connection:\n # TODO(101) is there a problem with having just one db connection?\n # Will this cause bugs with failed commits?\n curr_thread = threading.get_ident()\n if curr_thread not in self.conn or self.conn[curr_thread] is None:\n try:\n conn = sqlite3.connect(self.db_path)\n conn.row_factory = StringIDRow\n self.conn[curr_thread] = conn\n except sqlite3.Error as e:\n raise MephistoDBException(e)\n return self.conn[curr_thread]","def connection(self, name=None):\n if not name:\n name = threading.currentThread().getName()\n if name in self:\n return self[name]\n self[name] = self.database.connection()\n return self[name]","def _threadsafe_get_connection(self):\n with self._lock:\n next_con = self._nextConnection\n con = PooledDBConnection(self, self._connections[next_con])\n next_con += 1\n if next_con >= len(self._connections):\n next_con = 0\n self._nextConnection = next_con\n return con","def _unthreadsafe_get_connection(self):\n return PooledDBConnection(self, self._queue.get())","def connection(self):\n try:\n con = self.thread.connection\n except AttributeError:\n con = self.steady_connection()\n self.thread.connection = con\n return con","def GetMasterConnection(self):\n if MASTER_CNXN not in self.sql_cnxns:\n self.sql_cnxns[MASTER_CNXN] = cnxn_pool.get(\n settings.db_instance, settings.db_database_name)\n logging.info(\n 'created a master connection %r', self.sql_cnxns[MASTER_CNXN])\n\n return self.sql_cnxns[MASTER_CNXN]","def get_connection(cls):\n return cls.database.connection","def _get_connection(reconnect=False):\n global _connection\n identity = get_identity()\n # Connect to the database if not already connected\n if _connection.get(identity) is None or reconnect:\n try:\n _connection[identity] = Connection(**_connection_settings)\n except Exception, e:\n raise ConnectionError(\"Cannot connect to the database:\\n%s\" % e)\n return _connection[identity]","def get_connection(path: str):\r\n\treturn sqlite3.connect(path, check_same_thread=False)","def __enter__(self):\n self.conn = sqlite3.connect(self.db_name)\n return self.conn","def get_conn(self):\n return self.get_connection(self.mssql_conn_id)","def get_connection():\n\t# flask.g documentation: http://flask.pocoo.org/docs/0.12/api/#flask.g\n\ttry:\n\t\tconn = flask.g._database_connection\n\texcept AttributeError:\n\t\tconn = flask.g._database_connection = sqlite3.connect(config.PATH_DATABASE,\n\t\t\t\tdetect_types=sqlite3.PARSE_DECLTYPES) # allows storing datetime, etc.\n\t\tconn.row_factory = sqlite3.Row\n\treturn conn","def get_conn(self, *args, **kwargs):\n connections = self.__connections_for('get_conn', args=args, kwargs=kwargs)\n\n if len(connections) == 1:\n return connections[0]\n else:\n return connections","def get_conn(self):\n conn = sqlite3.connect(self.uri)\n conn.row_factory = sqlite3.Row\n return conn","def get_db_connection():\n db = sqlite3.connect(config.PERSISTENCE_LOCATION, check_same_thread=False)\n db.isolation_level = None\n db.row_factory = sqlite3.Row\n return db","def get_db():\n if not hasattr(g, 'db_connection'):\n g.db_connection = connect_db()\n return g.db_connection","def conn(self):\n if self._sentinel:\n return self._sentinel.master_for(self._sentinel_name)\n if not self._conn:\n self._conn = self.__redis_mod.StrictRedis(\n host=self._host, port=self._port, **self._conn_kwargs\n )\n return self._conn","def _get_cached_connection(connection_hash):\n global _CONNECTIONS\n\n # If we've not initialized the _CONNECTIONS global yet, do so\n if not _CONNECTIONS:\n _CONNECTIONS = dict()\n\n # If our connection_hash is in our global connection pool return it\n if connection_hash in _CONNECTIONS:\n\n # Increment our use counter\n _CONNECTIONS[connection_hash]['connections'] += 1\n\n # Return the active connection\n return _CONNECTIONS[connection_hash]['connection']\n\n # Return None, we don't have it in the pool\n return None","def get_connection():\n\n return MongoClientManager().client.__getattr__(MONGODB_SETTINGS['db'])","def connection_for_db(db) -> sqlite3.Connection:\n\n # Make database return dicts instead of tuples.\n # From: https://stackoverflow.com/questions/3300464/how-can-i-get-dict-from-sqlite-query\n def dict_factory(cursor, row):\n d = {}\n for idx, col in enumerate(cursor.description):\n d[col[0]] = row[idx]\n return d\n\n # If appending then we expect there to be an existing connection, or it's the first time\n global DB_CONNECTIONS\n con = DB_CONNECTIONS.get(db, None)\n if con is None:\n con = sqlite3.connect(db, check_same_thread=False)\n con.row_factory = dict_factory\n DB_CONNECTIONS[db] = con\n\n return con","def db_connection():\n global dbconnection\n try:\n conn = dbconnection\n except:\n dbconnection = psycopg2.connect(user = dbuser,\n password = dbpass,\n host = dbserver,\n port = \"5432\",\n database = dbname)\n conn = dbconnection\n return conn","def get_connection(self):\n\n\t\treturn dbapi.connect(credentials.SERVER,\\\n\t\t\t\t\t\t\t credentials.PORT,\\\n\t\t\t\t\t\t\t credentials.USER,\\\n\t\t\t\t\t\t\t credentials.PASSWORD)","def get_connection():\n con = psycopg2.connect(**DB_CONFIG)\n return con","def __enter__(self):\n fp = os.path.abspath(self.db_name)\n if self.read_only:\n self.conn = sqlite3.connect('file:/{}?mode=ro'.format(fp), uri=True)\n else:\n self.conn = sqlite3.connect(fp)\n return self.conn","def get_db():\n conn = g.get('sqlite_db', None)\n if conn is None:\n conn = g.sqlite_db = connect_db()\n return conn","def create_connection(db_file):\r\n try:\r\n #don't check for same thread (to use multithreading)\r\n conn = sqlite3.connect(db_file, check_same_thread=False) \r\n return conn\r\n except Error as e:\r\n print(e)\r\n \r\n return None","def get_dbapi20_connection ():\n return cherrypy.engine.pool.connect ()","def __enter__(self) -> sqlite3.Connection:\n self.conn = sqlite3.connect(self.path_db)\n return self.conn","async def _get_db_connection():\n return await gino.Gino(get_database_dsn())","def _get_cached_db_connection(name='ace'):\n if name is None:\n name = 'ace'\n\n config_section = 'database_{}'.format(name)\n\n if config_section not in saq.CONFIG:\n raise ValueError(\"invalid database {}\".format(name))\n\n try:\n db_identifier = _get_cached_db_identifier(name)\n with _global_db_cache_lock:\n logging.debug(\"aquiring existing cached database connection {}\".format(db_identifier))\n db = _global_db_cache[db_identifier]\n\n try:\n db.rollback()\n #logging.debug(\"acquired cached database connection to {}\".format(name))\n return db\n\n except Exception as e:\n logging.info(\"possibly lost cached connection to database {}: {} ({})\".format(name, e, type(e)))\n try:\n db.close()\n except Exception as e:\n logging.error(\"unable to close cached database connection to {}: {}\".format(name, e))\n\n try:\n with _global_db_cache_lock:\n del _global_db_cache[db_identifier]\n except Exception as e:\n logging.error(\"unable to delete cached db {}: {}\".format(db_identifier, e))\n\n #return _get_db_connection(name)\n\n except KeyError:\n pass\n\n try:\n logging.info(\"opening new cached database connection to {}\".format(name))\n\n with _global_db_cache_lock:\n _global_db_cache[db_identifier] = _get_db_connection(name)\n\n logging.debug(\"opened cached database connection {}\".format(db_identifier))\n return _global_db_cache[db_identifier]\n\n except Exception as e:\n logging.error(\"unable to connect to database {}: {}\".format(name, e))\n report_exception()\n raise e","def create_master_connection(self):\n self.cwd = os.getcwd()\n self.pullerdir = self.cwd + \"\\\\Puller Data\\\\\"\n self.inputloc = self.pullerdir + self.iteration_input\n try:\n self.conn_master = sqlite3.connect(self.inputloc)\n return self.conn_master\n except Error as e:\n print(e)\n\n return None","def _connection(self) -> dropbox.Dropbox:\n if not hasattr(self._per_thread, \"connection\"):\n self._per_thread.connection = self._token.connect()\n return self._per_thread.connection","def connection():\n global _connection\n if _connection is None:\n _connection = StrictRedis.from_url(REDIS_URL)\n return _connection","def _get_db_connection(name='ace'):\n\n if name is None:\n name = 'ace'\n\n #if _cached_db_connections_enabled():\n #return _get_cached_db_connection(name)\n\n config_section = 'ace'\n if name:\n config_section = 'database_{}'.format(name)\n\n if config_section not in saq.CONFIG:\n raise ValueError(\"invalid database {}\".format(name))\n\n _section = saq.CONFIG[config_section]\n kwargs = {\n 'db': _section['database'],\n 'user': _section['username'],\n 'passwd': _section['password'],\n 'charset': 'utf8'\n }\n\n if 'hostname' in _section:\n kwargs['host'] = _section['hostname']\n\n if 'port' in _section:\n kwargs['port'] = _section.getint('port')\n \n if 'unix_socket' in _section:\n kwargs['unix_socket'] = _section['unix_socket']\n\n if 'ssl_ca' in _section or 'ssl_key' in _section or 'ssl_cert' in _section:\n kwargs['ssl'] = {}\n\n if 'ssl_ca' in _section and _section['ssl_ca']:\n path = abs_path(_section['ssl_ca'])\n if not os.path.exists(path):\n logging.error(\"ssl_ca file {} does not exist (specified in {})\".format(path, config_section))\n else:\n kwargs['ssl']['ca'] = path\n\n if 'ssl_key' in _section and _section['ssl_key']:\n path = abs_path(_section['ssl_key'])\n if not os.path.exists(path):\n logging.error(\"ssl_key file {} does not exist (specified in {})\".format(path, config_section))\n else:\n kwargs['ssl']['key'] = path\n\n if 'ssl_cert' in _section and _section['ssl_cert']:\n path = _section['ssl_cert']\n if not os.path.exists(path):\n logging.error(\"ssl_cert file {} does not exist (specified in {})\".format(path, config_section))\n else:\n kwargs['ssl']['cert'] = path\n\n logging.debug(\"opening database connection {}\".format(name))\n return pymysql.connect(**kwargs)\n #return pymysql.connect(host=_section['hostname'] if 'hostname' in _section else None,\n #port=3306 if 'port' not in _section else _section.getint('port'),\n #unix_socket=_section['unix_socket'] if 'unix_socket' in _section else None,\n #db=_section['database'],\n #user=_section['username'],\n #passwd=_section['password'],\n #charset='utf8')","def __get_connection():\n # 根据配置文件创建连接池\n if not Mysql.__mysql_pool:\n Mysql.__mysql_pool = PooledDB(\n creator=MySQLdb,\n use_unicode=False,\n cursorclass=DictCursor,\n db=sqlconf.MysqlConfig['db'],\n host=sqlconf.MysqlConfig['host'],\n port=sqlconf.MysqlConfig['port'],\n user=sqlconf.MysqlConfig['user'],\n passwd=sqlconf.MysqlConfig['passwd'],\n charset=sqlconf.MysqlConfig['charset'],\n mincached=sqlconf.MysqlConfig['mincached'],\n maxcached=sqlconf.MysqlConfig['maxcached'],\n maxconnections=sqlconf.MysqlConfig['maxconnections'])\n # 返回连接池中连接对象\n return Mysql.__mysql_pool.connection()","def get_connection(db_url=None):\n return engine(db_url).connect()","def get_conn(cls):\n\n if not cls.conn or not cls.conn.open:\n cls.connect()\n\n try:\n cls.conn.ping() # ping to test if the current conn is working\n except MySQLdb.OperationalError:\n cls.connect()\n\n return cls.conn","def get_connection(self):\n\t\tfrom pymongo import MongoClient\n\n\t\tif self._connection is None:\n\t\t\tself._connection = MongoClient(host=self.url, max_pool_size=10)\n\n\t\treturn self._connection","def get_connection(self):\n return self.connection","def get_connection(self):\n return self.connection","def _get_connection(self, conf):\n return get_session()","def obtainDatabaseConnection(self):\n\t\tself.databaseConnector = DatabaseConnector()","def GetConnectionForShard(self, shard_id):\n if shard_id not in self.sql_cnxns:\n physical_shard_id = shard_id % settings.num_logical_shards\n\n replica_name = settings.db_replica_names[\n physical_shard_id % len(settings.db_replica_names)]\n shard_instance_name = (\n settings.physical_db_name_format % replica_name)\n self.unavailable_shards[shard_id] = int(time.time())\n self.sql_cnxns[shard_id] = cnxn_pool.get(\n shard_instance_name, settings.db_database_name)\n del self.unavailable_shards[shard_id]\n logging.info('created a replica connection for shard %d', shard_id)\n\n return self.sql_cnxns[shard_id]","def _get_outer_connection(self):\n if self._data['data_fetch_method'] == 'sql':\n if not self._data['source_database_connection_id']:\n raise Exception(\"No source_database_connection_id specified\")\n res = self._db.Query(\"\"\"SELECT source_database_connection.*, jdbc_driver.current_time_sql_stmt\n FROM source_database_connection\n LEFT JOIN jdbc_driver ON jdbc_driver.jdbc_driver_id = source_database_connection.jdbc_driver_id \n WHERE \n `source_database_connection_id`=%s\"\"\",(self._data['source_database_connection_id']))\n if not res:\n raise Exception(\"No source database record for source_database_connection_id=%s\", (self._data['source_database_connection_id']))\n outer_connection = self._db.record[0]\n conn = JCollectorConn(outer_connection)\n return conn\n\n elif self._data['data_fetch_method'] == 'web service':\n res = self._db.Query(\"\"\"SELECT web_service_credentials.*\n FROM web_service_credentials\n WHERE\n `web_service_credentials_id`=%s\"\"\",(self._data['web_service_credentials_id']))\n if not res:\n raise Exception(\"no source web service record\")\n self.web_service = self._db.record[0]\n self.web_service['url'] = self._data['data_fetch_command']\n conn = WebServiceConn(self.web_service)\n return conn\n\n return False","def get_connection(self):\n if self.conn is None or self.conn.closed != 0:\n self._connect()\n logger.debug(f'The connection object is: {self.conn}.')\n return self.conn","def connection(self, connection=None):\n if connection is None:\n return self.engine.acquire()\n return ConnectionProxy(connection=connection)","async def database():\n db = await Database.connect_pool()\n return db","async def connection():\n return await r.connect(db='main_db')","def _GetNewConnection(self):\n l_logger.debug(\"Creating a db connection\")\n return mdb.connect(host=self.host,\n user=self.user, \n password=self.passwd, \n database=self.db_name,\n port=self.port\n )","def _get_db_connection():\n conn = sqlite3.connect(str(DB_FILE_PATH))\n c = conn.cursor()\n\n return conn, c","def create_connection(db_file):\n conn = None\n try:\n conn = sqlite3.connect(db_file, check_same_thread=False)\n return conn\n except Error as e:\n print(e)\n\n return conn","def get_database_connection(dbfile='../data/localities.db'):\n\n global connection\n if not connection:\n connection = sqlite3.connect(dbfile)\n \n return connection","def set_connection(con):\n _thread_local.connection = con","def _db_connection(self):\n pass","def get_connection(self):\n return self._connection","def get_connection(self):\n return self._connection","def get_connection(self):\n from pymongo.connection import Connection\n \n if self._connection is None:\n self._connection = Connection(self.host, self.port)\n return self._connection","def __get_database_connection(self, reuse=True):\n if not self.__database_connection or not reuse:\n if self.__database_connection:\n self.__database_connection.close()\n self.__database_connection = None\n\n self.__database_connection = http.client.HTTPConnection(self.__DATABASE_HOST,\n port=self.__DATABASE_PORT,\n timeout=self.__TIMEOUT)\n\n return self.__database_connection","def get_connection(self):\n if self.__connection is None:\n from pymongo import MongoClient\n from ir_config import IRConfig\n self.__connection = MongoClient(\n IRConfig.get_instance().get('db_host', self.__default_host), \n IRConfig.get_instance().get_int('db_port', self.__default_port))\n return self.__connection","def get_connection(self, session_cls=None):\n # If this connection has to be created within an existing session,\n # ``session_cls`` will be provided as an argument.\n # Otherwise, fetch a new ``session_cls`` from ``get_session()``\n if session_cls is None:\n session_cls = self.get_session()\n\n conn = session_cls()\n conn = self._execute_database_specific_connection_statements(conn)\n\n return conn","def conn(self):\n return self._queue.conn","def get_connection(self, params):\r\n return Redis(connection_pool=self.get_or_create_connection_pool(params))","def connect() -> sqlite3.Connection:\n if not os.path.isfile(DATABASE):\n connection = init()\n else:\n connection = sqlite3.connect(DATABASE, check_same_thread=False)\n return connection","def make_connection(self):\n if self._created_connections() >= self.max_connections:\n raise ConnPoolException(\"Too many connections.\")\n connection = self.connection_class(**self.connection_kwargs)\n connection.connect()\n return connection","def connection(self):\n return self.get_connection()","def get_db_client(self, connection_name: str) -> BaseDBAsyncClient:\n return self._db_client_map[connection_name]","def db(request):\n connection = request.param\n return connection","def __init__(self, dbapi, maxconnections, *args, **kwargs):\n try:\n threadsafety = dbapi.threadsafety\n except Exception:\n threadsafety = None\n if threadsafety == 0:\n raise NotSupportedError(\n \"Database module does not support any level of threading.\")\n if threadsafety == 1:\n # If there is no connection level safety, build\n # the pool using the synchronized queue class\n # that implements all the required locking semantics.\n from queue import Queue\n self._queue = Queue(maxconnections) # create the queue\n self.connection = self._unthreadsafe_get_connection\n self.addConnection = self._unthreadsafe_add_connection\n self.returnConnection = self._unthreadsafe_return_connection\n elif threadsafety in (2, 3):\n # If there is connection level safety, implement the\n # pool with an ordinary list used as a circular buffer.\n # We only need a minimum of locking in this case.\n from threading import Lock\n self._lock = Lock() # create a lock object to be used later\n self._nextConnection = 0 # index of the next connection to be used\n self._connections = [] # the list of connections\n self.connection = self._threadsafe_get_connection\n self.addConnection = self._threadsafe_add_connection\n self.returnConnection = self._threadsafe_return_connection\n else:\n raise NotSupportedError(\n \"Database module threading support cannot be determined.\")\n # Establish all database connections (it would be better to\n # only establish a part of them now, and the rest on demand).\n for _i in range(maxconnections):\n self.addConnection(dbapi.connect(*args, **kwargs))","def get_connection(self, simple_rows=False):\n return self.open(simple_rows)","def create_connection():\r\n try:\r\n conn = sq.connect(DBClass.db_name)\r\n except sq.Error as e:\r\n raise e\r\n \r\n return conn","def get_connection(self):\n return self.application.get_connection()","def connection(self):\n\n ctx = _app_ctx_stack.top\n if ctx is not None:\n if not hasattr(ctx, 'mysql_db'):\n ctx.mysql_db = self.connect\n return ctx.mysql_db","def get(self, instance, database):\n key = instance + '/' + database\n\n if not key in self.queues:\n queue = Queue(self.poolsize)\n self.queues[key] = queue\n\n queue = self.queues[key]\n\n if queue.empty():\n cnxn = cnxn_ctor(instance, database)\n else:\n cnxn = queue.get()\n # Make sure the connection is still good.\n cnxn.ping()\n cnxn.commit()\n\n return cnxn","def get_db_connection(uri):\n client = pymongo.MongoClient(uri)\n return client.cryptongo","def single_threaded_session():\n return make_session(num_cpu=1)","def get_db():\n if not hasattr(g, 'db_conn'):\n g.db_conn = sqlite3.connect(\"pypatch.sqlite\")\n g.db_conn.row_factory = sqlite3.Row\n \n return g.db_conn","def __enter__(self) -> cx_Oracle.connect:\n self.db_connection = cx_Oracle.connect(\n self.config['oracle']['ora_user'],\n self.config['oracle']['ora_pass'],\n f\"{self.config['oracle']['ora_host']}/{self.config['oracle']['ora_sid']}\")\n return self.db_connection","def __get_open_connection(self, connection_hash):\n db = MySQLdb.connect(\n host=connection_hash[\"host\"],\n user=connection_hash[\"user\"],\n passwd=connection_hash[\"password\"],\n db=connection_hash[\"dbname\"]\n )\n return db","def get_db(self):\n db = getattr(g, '_database', None)\n if db is None:\n db = g._database = connect(DATABASE)\n return db","def get_pool(self):\n try:\n return self._pool\n except AttributeError:\n db_url = getattr(settings, self.name)\n self._pool = PostgresConnectionPool.for_url(db_url)\n return self._pool","def get_new_connection(self, conn_params):\r\n self.__connection_string = conn_params.get('connection_string', '')\r\n conn = Database.connect(**conn_params)\r\n return conn","async def get(self):\n if self._connect_kwargs == None:\n raise IllegalAccessError(\"DB connection parameters not set yet\")\n\n if not hasattr(self._tl, \"conn\"):\n self._tl.conn = await r.connect(**self._connect_kwargs)\n\n return self._tl.conn","def get_db():\n if ( g.get( 'db' ) is None ):\n g.db = connect_db()\n\n return g.db.connect()","def getDbConnection(self):\n return self._oDb;","def connect():\n global db_name\n con = sqlite3.connect(db_name)\n return con","def __enter__(self):\n try:\n self.conn = sqlite3.connect(self.database_configuration)\n self.cursor = self.conn.cursor()\n\n return self.cursor\n except Exception as error:\n print(f\"DBCM::__enter__::{error}\")","def getconn(self):\n #hdbport = int('3%s15' % Settings.hdbinstancenum)\n con = dbapi.connect(address = self.host, \\\n port = self.port, \\\n user = self.username, \\\n password = self.password, \\\n autocommit = True)\n if self.schema:\n cur = con.cursor()\n try:\n cur.execute('ALTER SESSION SET CURRENT_SCHEMA = %s' % self.schema)\n return con\n except dbapi.Error, err:\n cur.close()\n con.close()\n cur = None\n raise err\n finally:\n if cur:\n cur.close()\n else:\n return con","def dbsession(cls):\n sqlahelper = cls.dbsqlahelper\n return sqlahelper.getmake_session()","def get_con(s_name, auth_path=None, db=None):\n con=None\n auth_path = os.path.dirname(os.path.abspath(__file__)) + '/db.csv' if auth_path is None else auth_path\n csv_path=util.format_path(auth_path)\n t_db=pd.read_csv(csv_path)\n #t_db.fillna(None, inplace=True)\n t_db=t_db[t_db['ID']==s_name]\n if len(t_db)==0:\n util.error_msg('Database %s is not defined!' % s_name)\n one=t_db.iloc[0]\n s_db=db or one['DB']\n if one['TYPE']=='MYSQL':\n import MySQLdb as mysql\n #print one['HOST'], one['USR'], one['PWD'], s_db\n if not one['PORT'] or pd.isnull(one['PORT']):\n con=mysql.connect(one['HOST'], one['USR'], one['PWD'], s_db, port=3306, charset='utf8')\n else:\n con=mysql.connect(one['HOST'], one['USR'], one['PWD'], s_db, port=int(one['PORT']), charset='utf8')\n elif one['TYPE']=='POSTGRES':\n import pgdb\n # make sure you do:\n #module load postgresql/9.2.4\n #export LD_LIBRARY_PATH=.:/tools/GNU/postgresql/9.2.4/lib/\n con=pgdb.connect(one['CONNECT'])\n elif one['TYPE']=='ORACLE':\n import cx_Oracle as oracle\n con=oracle.connect(one['CONNECT'])\n else:\n util.error_msg('Unsupported database engine: %s' % one['TYPE'])\n return con","def get_db(server_id):\n DATABASE = \"DATABASE\" + str(server_id)\n print(DATABASE)\n tracktop = _app_ctx_stack.top\n if not hasattr(tracktop, 'track_db0') and server_id == 0:\n tracktop.track_db0 = sqlite3.connect(app.config[DATABASE], detect_types=sqlite3.PARSE_DECLTYPES)\n tracktop.track_db0.row_factory = sqlite3.Row\n if not hasattr(tracktop, 'track_db1') and server_id == 1:\n tracktop.track_db1 = sqlite3.connect(app.config[DATABASE], detect_types=sqlite3.PARSE_DECLTYPES)\n tracktop.track_db1.row_factory = sqlite3.Row\n if not hasattr(tracktop, 'track_db2') and server_id == 2:\n tracktop.track_db2 = sqlite3.connect(app.config[DATABASE], detect_types=sqlite3.PARSE_DECLTYPES)\n tracktop.track_db2.row_factory = sqlite3.Row\n\n if server_id == 0:\n return tracktop.track_db0\n elif server_id == 1:\n return tracktop.track_db1\n else:\n return tracktop.track_db2","def _get_db(reconnect=False):\n global _db, _connection\n identity = get_identity()\n # Connect if not already connected\n if _connection.get(identity) is None or reconnect:\n _connection[identity] = _get_connection(reconnect=reconnect)\n\n if _db.get(identity) is None or reconnect:\n # _db_name will be None if the user hasn't called connect()\n if _db_name is None:\n raise ConnectionError('Not connected to the database')\n\n # Get DB from current connection and authenticate if necessary\n _db[identity] = _connection[identity][_db_name]\n if _db_username and _db_password:\n _db[identity].authenticate(_db_username, _db_password)\n\n return _db[identity]","def __connect(host):\n global pg_pool\n pg_config['host'] = host\n pg_pool = SimpleConnectionPool(1, 1, **pg_config)","def _get_conn(self):\n return redis.Redis(connection_pool=self.pool)","def get_client(conn):\n # No database indicates a cluster connection\n if not conn.get('db', None):\n conn.pop('db', None)\n return connect_redis_cluster(conn)\n\n # Otherwise it's a regular redis connection\n return connect_redis(conn)","def get(self, conn_alias: str) -> \"BaseDBAsyncClient\":\n storage: Dict[str, \"BaseDBAsyncClient\"] = self._get_storage()\n try:\n return storage[conn_alias]\n except KeyError:\n connection: BaseDBAsyncClient = self._create_connection(conn_alias)\n storage[conn_alias] = connection\n return connection","def __make_connection(self, path):\n try:\n connection = sqlite3.connect(path)\n return connection\n except sqlite3.Error as e:\n pass\n return None","def get_db():\n db = getattr(g, '_database', None)\n if db is None:\n db = g._database = sqlite3.connect(DATABASE)\n db.row_factory = sqlite3.Row\n return db","def _get_pool(self, *args, **kwargs):\n\n pool_name = '_pool_%s' % getattr(self, 'alias', 'common')\n\n if not hasattr (self.__class__, pool_name):\n lock = thread.allocate_lock()\n lock.acquire()\n\n try:\n pool = cx_Oracle.SessionPool(\n user=self.user,\n password=self.password,\n dsn=self.tns,\n min=CX_POOL_SESSION_MIN,\n max=CX_POOL_SESSION_MAX,\n increment=CX_POOL_SESSION_INCREMENT,\n connectiontype=cx_Oracle.Connection,\n threaded=CX_POOL_THREADED,\n getmode=cx_Oracle.SPOOL_ATTRVAL_NOWAIT,\n homogeneous=True)\n except Exception as err:\n pool = None\n\n if pool:\n pool.timeout = CX_POOL_CONNECT_TIMEOUT\n setattr(self.__class__, pool_name, pool)\n else:\n msg = \"\"\" ### Database login failed or database not found ### \"\"\"\n raise self.Database_Error, ('%s') %(msg)\n\n lock.release()\n\n return getattr(self.__class__, pool_name)","def get_db():\r\n if not hasattr(g, 'sqlite_db'):\r\n g.sqlite_db = connect_db()\r\n return g.sqlite_db","def connect_thread():\n return factory.connect_thread(SlaveService, remote_service = SlaveService)"],"string":"[\n \"def _get_connection(self) -> Connection:\\n # TODO(101) is there a problem with having just one db connection?\\n # Will this cause bugs with failed commits?\\n curr_thread = threading.get_ident()\\n if curr_thread not in self.conn or self.conn[curr_thread] is None:\\n try:\\n conn = sqlite3.connect(self.db_path)\\n conn.row_factory = StringIDRow\\n self.conn[curr_thread] = conn\\n except sqlite3.Error as e:\\n raise MephistoDBException(e)\\n return self.conn[curr_thread]\",\n \"def connection(self, name=None):\\n if not name:\\n name = threading.currentThread().getName()\\n if name in self:\\n return self[name]\\n self[name] = self.database.connection()\\n return self[name]\",\n \"def _threadsafe_get_connection(self):\\n with self._lock:\\n next_con = self._nextConnection\\n con = PooledDBConnection(self, self._connections[next_con])\\n next_con += 1\\n if next_con >= len(self._connections):\\n next_con = 0\\n self._nextConnection = next_con\\n return con\",\n \"def _unthreadsafe_get_connection(self):\\n return PooledDBConnection(self, self._queue.get())\",\n \"def connection(self):\\n try:\\n con = self.thread.connection\\n except AttributeError:\\n con = self.steady_connection()\\n self.thread.connection = con\\n return con\",\n \"def GetMasterConnection(self):\\n if MASTER_CNXN not in self.sql_cnxns:\\n self.sql_cnxns[MASTER_CNXN] = cnxn_pool.get(\\n settings.db_instance, settings.db_database_name)\\n logging.info(\\n 'created a master connection %r', self.sql_cnxns[MASTER_CNXN])\\n\\n return self.sql_cnxns[MASTER_CNXN]\",\n \"def get_connection(cls):\\n return cls.database.connection\",\n \"def _get_connection(reconnect=False):\\n global _connection\\n identity = get_identity()\\n # Connect to the database if not already connected\\n if _connection.get(identity) is None or reconnect:\\n try:\\n _connection[identity] = Connection(**_connection_settings)\\n except Exception, e:\\n raise ConnectionError(\\\"Cannot connect to the database:\\\\n%s\\\" % e)\\n return _connection[identity]\",\n \"def get_connection(path: str):\\r\\n\\treturn sqlite3.connect(path, check_same_thread=False)\",\n \"def __enter__(self):\\n self.conn = sqlite3.connect(self.db_name)\\n return self.conn\",\n \"def get_conn(self):\\n return self.get_connection(self.mssql_conn_id)\",\n \"def get_connection():\\n\\t# flask.g documentation: http://flask.pocoo.org/docs/0.12/api/#flask.g\\n\\ttry:\\n\\t\\tconn = flask.g._database_connection\\n\\texcept AttributeError:\\n\\t\\tconn = flask.g._database_connection = sqlite3.connect(config.PATH_DATABASE,\\n\\t\\t\\t\\tdetect_types=sqlite3.PARSE_DECLTYPES) # allows storing datetime, etc.\\n\\t\\tconn.row_factory = sqlite3.Row\\n\\treturn conn\",\n \"def get_conn(self, *args, **kwargs):\\n connections = self.__connections_for('get_conn', args=args, kwargs=kwargs)\\n\\n if len(connections) == 1:\\n return connections[0]\\n else:\\n return connections\",\n \"def get_conn(self):\\n conn = sqlite3.connect(self.uri)\\n conn.row_factory = sqlite3.Row\\n return conn\",\n \"def get_db_connection():\\n db = sqlite3.connect(config.PERSISTENCE_LOCATION, check_same_thread=False)\\n db.isolation_level = None\\n db.row_factory = sqlite3.Row\\n return db\",\n \"def get_db():\\n if not hasattr(g, 'db_connection'):\\n g.db_connection = connect_db()\\n return g.db_connection\",\n \"def conn(self):\\n if self._sentinel:\\n return self._sentinel.master_for(self._sentinel_name)\\n if not self._conn:\\n self._conn = self.__redis_mod.StrictRedis(\\n host=self._host, port=self._port, **self._conn_kwargs\\n )\\n return self._conn\",\n \"def _get_cached_connection(connection_hash):\\n global _CONNECTIONS\\n\\n # If we've not initialized the _CONNECTIONS global yet, do so\\n if not _CONNECTIONS:\\n _CONNECTIONS = dict()\\n\\n # If our connection_hash is in our global connection pool return it\\n if connection_hash in _CONNECTIONS:\\n\\n # Increment our use counter\\n _CONNECTIONS[connection_hash]['connections'] += 1\\n\\n # Return the active connection\\n return _CONNECTIONS[connection_hash]['connection']\\n\\n # Return None, we don't have it in the pool\\n return None\",\n \"def get_connection():\\n\\n return MongoClientManager().client.__getattr__(MONGODB_SETTINGS['db'])\",\n \"def connection_for_db(db) -> sqlite3.Connection:\\n\\n # Make database return dicts instead of tuples.\\n # From: https://stackoverflow.com/questions/3300464/how-can-i-get-dict-from-sqlite-query\\n def dict_factory(cursor, row):\\n d = {}\\n for idx, col in enumerate(cursor.description):\\n d[col[0]] = row[idx]\\n return d\\n\\n # If appending then we expect there to be an existing connection, or it's the first time\\n global DB_CONNECTIONS\\n con = DB_CONNECTIONS.get(db, None)\\n if con is None:\\n con = sqlite3.connect(db, check_same_thread=False)\\n con.row_factory = dict_factory\\n DB_CONNECTIONS[db] = con\\n\\n return con\",\n \"def db_connection():\\n global dbconnection\\n try:\\n conn = dbconnection\\n except:\\n dbconnection = psycopg2.connect(user = dbuser,\\n password = dbpass,\\n host = dbserver,\\n port = \\\"5432\\\",\\n database = dbname)\\n conn = dbconnection\\n return conn\",\n \"def get_connection(self):\\n\\n\\t\\treturn dbapi.connect(credentials.SERVER,\\\\\\n\\t\\t\\t\\t\\t\\t\\t credentials.PORT,\\\\\\n\\t\\t\\t\\t\\t\\t\\t credentials.USER,\\\\\\n\\t\\t\\t\\t\\t\\t\\t credentials.PASSWORD)\",\n \"def get_connection():\\n con = psycopg2.connect(**DB_CONFIG)\\n return con\",\n \"def __enter__(self):\\n fp = os.path.abspath(self.db_name)\\n if self.read_only:\\n self.conn = sqlite3.connect('file:/{}?mode=ro'.format(fp), uri=True)\\n else:\\n self.conn = sqlite3.connect(fp)\\n return self.conn\",\n \"def get_db():\\n conn = g.get('sqlite_db', None)\\n if conn is None:\\n conn = g.sqlite_db = connect_db()\\n return conn\",\n \"def create_connection(db_file):\\r\\n try:\\r\\n #don't check for same thread (to use multithreading)\\r\\n conn = sqlite3.connect(db_file, check_same_thread=False) \\r\\n return conn\\r\\n except Error as e:\\r\\n print(e)\\r\\n \\r\\n return None\",\n \"def get_dbapi20_connection ():\\n return cherrypy.engine.pool.connect ()\",\n \"def __enter__(self) -> sqlite3.Connection:\\n self.conn = sqlite3.connect(self.path_db)\\n return self.conn\",\n \"async def _get_db_connection():\\n return await gino.Gino(get_database_dsn())\",\n \"def _get_cached_db_connection(name='ace'):\\n if name is None:\\n name = 'ace'\\n\\n config_section = 'database_{}'.format(name)\\n\\n if config_section not in saq.CONFIG:\\n raise ValueError(\\\"invalid database {}\\\".format(name))\\n\\n try:\\n db_identifier = _get_cached_db_identifier(name)\\n with _global_db_cache_lock:\\n logging.debug(\\\"aquiring existing cached database connection {}\\\".format(db_identifier))\\n db = _global_db_cache[db_identifier]\\n\\n try:\\n db.rollback()\\n #logging.debug(\\\"acquired cached database connection to {}\\\".format(name))\\n return db\\n\\n except Exception as e:\\n logging.info(\\\"possibly lost cached connection to database {}: {} ({})\\\".format(name, e, type(e)))\\n try:\\n db.close()\\n except Exception as e:\\n logging.error(\\\"unable to close cached database connection to {}: {}\\\".format(name, e))\\n\\n try:\\n with _global_db_cache_lock:\\n del _global_db_cache[db_identifier]\\n except Exception as e:\\n logging.error(\\\"unable to delete cached db {}: {}\\\".format(db_identifier, e))\\n\\n #return _get_db_connection(name)\\n\\n except KeyError:\\n pass\\n\\n try:\\n logging.info(\\\"opening new cached database connection to {}\\\".format(name))\\n\\n with _global_db_cache_lock:\\n _global_db_cache[db_identifier] = _get_db_connection(name)\\n\\n logging.debug(\\\"opened cached database connection {}\\\".format(db_identifier))\\n return _global_db_cache[db_identifier]\\n\\n except Exception as e:\\n logging.error(\\\"unable to connect to database {}: {}\\\".format(name, e))\\n report_exception()\\n raise e\",\n \"def create_master_connection(self):\\n self.cwd = os.getcwd()\\n self.pullerdir = self.cwd + \\\"\\\\\\\\Puller Data\\\\\\\\\\\"\\n self.inputloc = self.pullerdir + self.iteration_input\\n try:\\n self.conn_master = sqlite3.connect(self.inputloc)\\n return self.conn_master\\n except Error as e:\\n print(e)\\n\\n return None\",\n \"def _connection(self) -> dropbox.Dropbox:\\n if not hasattr(self._per_thread, \\\"connection\\\"):\\n self._per_thread.connection = self._token.connect()\\n return self._per_thread.connection\",\n \"def connection():\\n global _connection\\n if _connection is None:\\n _connection = StrictRedis.from_url(REDIS_URL)\\n return _connection\",\n \"def _get_db_connection(name='ace'):\\n\\n if name is None:\\n name = 'ace'\\n\\n #if _cached_db_connections_enabled():\\n #return _get_cached_db_connection(name)\\n\\n config_section = 'ace'\\n if name:\\n config_section = 'database_{}'.format(name)\\n\\n if config_section not in saq.CONFIG:\\n raise ValueError(\\\"invalid database {}\\\".format(name))\\n\\n _section = saq.CONFIG[config_section]\\n kwargs = {\\n 'db': _section['database'],\\n 'user': _section['username'],\\n 'passwd': _section['password'],\\n 'charset': 'utf8'\\n }\\n\\n if 'hostname' in _section:\\n kwargs['host'] = _section['hostname']\\n\\n if 'port' in _section:\\n kwargs['port'] = _section.getint('port')\\n \\n if 'unix_socket' in _section:\\n kwargs['unix_socket'] = _section['unix_socket']\\n\\n if 'ssl_ca' in _section or 'ssl_key' in _section or 'ssl_cert' in _section:\\n kwargs['ssl'] = {}\\n\\n if 'ssl_ca' in _section and _section['ssl_ca']:\\n path = abs_path(_section['ssl_ca'])\\n if not os.path.exists(path):\\n logging.error(\\\"ssl_ca file {} does not exist (specified in {})\\\".format(path, config_section))\\n else:\\n kwargs['ssl']['ca'] = path\\n\\n if 'ssl_key' in _section and _section['ssl_key']:\\n path = abs_path(_section['ssl_key'])\\n if not os.path.exists(path):\\n logging.error(\\\"ssl_key file {} does not exist (specified in {})\\\".format(path, config_section))\\n else:\\n kwargs['ssl']['key'] = path\\n\\n if 'ssl_cert' in _section and _section['ssl_cert']:\\n path = _section['ssl_cert']\\n if not os.path.exists(path):\\n logging.error(\\\"ssl_cert file {} does not exist (specified in {})\\\".format(path, config_section))\\n else:\\n kwargs['ssl']['cert'] = path\\n\\n logging.debug(\\\"opening database connection {}\\\".format(name))\\n return pymysql.connect(**kwargs)\\n #return pymysql.connect(host=_section['hostname'] if 'hostname' in _section else None,\\n #port=3306 if 'port' not in _section else _section.getint('port'),\\n #unix_socket=_section['unix_socket'] if 'unix_socket' in _section else None,\\n #db=_section['database'],\\n #user=_section['username'],\\n #passwd=_section['password'],\\n #charset='utf8')\",\n \"def __get_connection():\\n # 根据配置文件创建连接池\\n if not Mysql.__mysql_pool:\\n Mysql.__mysql_pool = PooledDB(\\n creator=MySQLdb,\\n use_unicode=False,\\n cursorclass=DictCursor,\\n db=sqlconf.MysqlConfig['db'],\\n host=sqlconf.MysqlConfig['host'],\\n port=sqlconf.MysqlConfig['port'],\\n user=sqlconf.MysqlConfig['user'],\\n passwd=sqlconf.MysqlConfig['passwd'],\\n charset=sqlconf.MysqlConfig['charset'],\\n mincached=sqlconf.MysqlConfig['mincached'],\\n maxcached=sqlconf.MysqlConfig['maxcached'],\\n maxconnections=sqlconf.MysqlConfig['maxconnections'])\\n # 返回连接池中连接对象\\n return Mysql.__mysql_pool.connection()\",\n \"def get_connection(db_url=None):\\n return engine(db_url).connect()\",\n \"def get_conn(cls):\\n\\n if not cls.conn or not cls.conn.open:\\n cls.connect()\\n\\n try:\\n cls.conn.ping() # ping to test if the current conn is working\\n except MySQLdb.OperationalError:\\n cls.connect()\\n\\n return cls.conn\",\n \"def get_connection(self):\\n\\t\\tfrom pymongo import MongoClient\\n\\n\\t\\tif self._connection is None:\\n\\t\\t\\tself._connection = MongoClient(host=self.url, max_pool_size=10)\\n\\n\\t\\treturn self._connection\",\n \"def get_connection(self):\\n return self.connection\",\n \"def get_connection(self):\\n return self.connection\",\n \"def _get_connection(self, conf):\\n return get_session()\",\n \"def obtainDatabaseConnection(self):\\n\\t\\tself.databaseConnector = DatabaseConnector()\",\n \"def GetConnectionForShard(self, shard_id):\\n if shard_id not in self.sql_cnxns:\\n physical_shard_id = shard_id % settings.num_logical_shards\\n\\n replica_name = settings.db_replica_names[\\n physical_shard_id % len(settings.db_replica_names)]\\n shard_instance_name = (\\n settings.physical_db_name_format % replica_name)\\n self.unavailable_shards[shard_id] = int(time.time())\\n self.sql_cnxns[shard_id] = cnxn_pool.get(\\n shard_instance_name, settings.db_database_name)\\n del self.unavailable_shards[shard_id]\\n logging.info('created a replica connection for shard %d', shard_id)\\n\\n return self.sql_cnxns[shard_id]\",\n \"def _get_outer_connection(self):\\n if self._data['data_fetch_method'] == 'sql':\\n if not self._data['source_database_connection_id']:\\n raise Exception(\\\"No source_database_connection_id specified\\\")\\n res = self._db.Query(\\\"\\\"\\\"SELECT source_database_connection.*, jdbc_driver.current_time_sql_stmt\\n FROM source_database_connection\\n LEFT JOIN jdbc_driver ON jdbc_driver.jdbc_driver_id = source_database_connection.jdbc_driver_id \\n WHERE \\n `source_database_connection_id`=%s\\\"\\\"\\\",(self._data['source_database_connection_id']))\\n if not res:\\n raise Exception(\\\"No source database record for source_database_connection_id=%s\\\", (self._data['source_database_connection_id']))\\n outer_connection = self._db.record[0]\\n conn = JCollectorConn(outer_connection)\\n return conn\\n\\n elif self._data['data_fetch_method'] == 'web service':\\n res = self._db.Query(\\\"\\\"\\\"SELECT web_service_credentials.*\\n FROM web_service_credentials\\n WHERE\\n `web_service_credentials_id`=%s\\\"\\\"\\\",(self._data['web_service_credentials_id']))\\n if not res:\\n raise Exception(\\\"no source web service record\\\")\\n self.web_service = self._db.record[0]\\n self.web_service['url'] = self._data['data_fetch_command']\\n conn = WebServiceConn(self.web_service)\\n return conn\\n\\n return False\",\n \"def get_connection(self):\\n if self.conn is None or self.conn.closed != 0:\\n self._connect()\\n logger.debug(f'The connection object is: {self.conn}.')\\n return self.conn\",\n \"def connection(self, connection=None):\\n if connection is None:\\n return self.engine.acquire()\\n return ConnectionProxy(connection=connection)\",\n \"async def database():\\n db = await Database.connect_pool()\\n return db\",\n \"async def connection():\\n return await r.connect(db='main_db')\",\n \"def _GetNewConnection(self):\\n l_logger.debug(\\\"Creating a db connection\\\")\\n return mdb.connect(host=self.host,\\n user=self.user, \\n password=self.passwd, \\n database=self.db_name,\\n port=self.port\\n )\",\n \"def _get_db_connection():\\n conn = sqlite3.connect(str(DB_FILE_PATH))\\n c = conn.cursor()\\n\\n return conn, c\",\n \"def create_connection(db_file):\\n conn = None\\n try:\\n conn = sqlite3.connect(db_file, check_same_thread=False)\\n return conn\\n except Error as e:\\n print(e)\\n\\n return conn\",\n \"def get_database_connection(dbfile='../data/localities.db'):\\n\\n global connection\\n if not connection:\\n connection = sqlite3.connect(dbfile)\\n \\n return connection\",\n \"def set_connection(con):\\n _thread_local.connection = con\",\n \"def _db_connection(self):\\n pass\",\n \"def get_connection(self):\\n return self._connection\",\n \"def get_connection(self):\\n return self._connection\",\n \"def get_connection(self):\\n from pymongo.connection import Connection\\n \\n if self._connection is None:\\n self._connection = Connection(self.host, self.port)\\n return self._connection\",\n \"def __get_database_connection(self, reuse=True):\\n if not self.__database_connection or not reuse:\\n if self.__database_connection:\\n self.__database_connection.close()\\n self.__database_connection = None\\n\\n self.__database_connection = http.client.HTTPConnection(self.__DATABASE_HOST,\\n port=self.__DATABASE_PORT,\\n timeout=self.__TIMEOUT)\\n\\n return self.__database_connection\",\n \"def get_connection(self):\\n if self.__connection is None:\\n from pymongo import MongoClient\\n from ir_config import IRConfig\\n self.__connection = MongoClient(\\n IRConfig.get_instance().get('db_host', self.__default_host), \\n IRConfig.get_instance().get_int('db_port', self.__default_port))\\n return self.__connection\",\n \"def get_connection(self, session_cls=None):\\n # If this connection has to be created within an existing session,\\n # ``session_cls`` will be provided as an argument.\\n # Otherwise, fetch a new ``session_cls`` from ``get_session()``\\n if session_cls is None:\\n session_cls = self.get_session()\\n\\n conn = session_cls()\\n conn = self._execute_database_specific_connection_statements(conn)\\n\\n return conn\",\n \"def conn(self):\\n return self._queue.conn\",\n \"def get_connection(self, params):\\r\\n return Redis(connection_pool=self.get_or_create_connection_pool(params))\",\n \"def connect() -> sqlite3.Connection:\\n if not os.path.isfile(DATABASE):\\n connection = init()\\n else:\\n connection = sqlite3.connect(DATABASE, check_same_thread=False)\\n return connection\",\n \"def make_connection(self):\\n if self._created_connections() >= self.max_connections:\\n raise ConnPoolException(\\\"Too many connections.\\\")\\n connection = self.connection_class(**self.connection_kwargs)\\n connection.connect()\\n return connection\",\n \"def connection(self):\\n return self.get_connection()\",\n \"def get_db_client(self, connection_name: str) -> BaseDBAsyncClient:\\n return self._db_client_map[connection_name]\",\n \"def db(request):\\n connection = request.param\\n return connection\",\n \"def __init__(self, dbapi, maxconnections, *args, **kwargs):\\n try:\\n threadsafety = dbapi.threadsafety\\n except Exception:\\n threadsafety = None\\n if threadsafety == 0:\\n raise NotSupportedError(\\n \\\"Database module does not support any level of threading.\\\")\\n if threadsafety == 1:\\n # If there is no connection level safety, build\\n # the pool using the synchronized queue class\\n # that implements all the required locking semantics.\\n from queue import Queue\\n self._queue = Queue(maxconnections) # create the queue\\n self.connection = self._unthreadsafe_get_connection\\n self.addConnection = self._unthreadsafe_add_connection\\n self.returnConnection = self._unthreadsafe_return_connection\\n elif threadsafety in (2, 3):\\n # If there is connection level safety, implement the\\n # pool with an ordinary list used as a circular buffer.\\n # We only need a minimum of locking in this case.\\n from threading import Lock\\n self._lock = Lock() # create a lock object to be used later\\n self._nextConnection = 0 # index of the next connection to be used\\n self._connections = [] # the list of connections\\n self.connection = self._threadsafe_get_connection\\n self.addConnection = self._threadsafe_add_connection\\n self.returnConnection = self._threadsafe_return_connection\\n else:\\n raise NotSupportedError(\\n \\\"Database module threading support cannot be determined.\\\")\\n # Establish all database connections (it would be better to\\n # only establish a part of them now, and the rest on demand).\\n for _i in range(maxconnections):\\n self.addConnection(dbapi.connect(*args, **kwargs))\",\n \"def get_connection(self, simple_rows=False):\\n return self.open(simple_rows)\",\n \"def create_connection():\\r\\n try:\\r\\n conn = sq.connect(DBClass.db_name)\\r\\n except sq.Error as e:\\r\\n raise e\\r\\n \\r\\n return conn\",\n \"def get_connection(self):\\n return self.application.get_connection()\",\n \"def connection(self):\\n\\n ctx = _app_ctx_stack.top\\n if ctx is not None:\\n if not hasattr(ctx, 'mysql_db'):\\n ctx.mysql_db = self.connect\\n return ctx.mysql_db\",\n \"def get(self, instance, database):\\n key = instance + '/' + database\\n\\n if not key in self.queues:\\n queue = Queue(self.poolsize)\\n self.queues[key] = queue\\n\\n queue = self.queues[key]\\n\\n if queue.empty():\\n cnxn = cnxn_ctor(instance, database)\\n else:\\n cnxn = queue.get()\\n # Make sure the connection is still good.\\n cnxn.ping()\\n cnxn.commit()\\n\\n return cnxn\",\n \"def get_db_connection(uri):\\n client = pymongo.MongoClient(uri)\\n return client.cryptongo\",\n \"def single_threaded_session():\\n return make_session(num_cpu=1)\",\n \"def get_db():\\n if not hasattr(g, 'db_conn'):\\n g.db_conn = sqlite3.connect(\\\"pypatch.sqlite\\\")\\n g.db_conn.row_factory = sqlite3.Row\\n \\n return g.db_conn\",\n \"def __enter__(self) -> cx_Oracle.connect:\\n self.db_connection = cx_Oracle.connect(\\n self.config['oracle']['ora_user'],\\n self.config['oracle']['ora_pass'],\\n f\\\"{self.config['oracle']['ora_host']}/{self.config['oracle']['ora_sid']}\\\")\\n return self.db_connection\",\n \"def __get_open_connection(self, connection_hash):\\n db = MySQLdb.connect(\\n host=connection_hash[\\\"host\\\"],\\n user=connection_hash[\\\"user\\\"],\\n passwd=connection_hash[\\\"password\\\"],\\n db=connection_hash[\\\"dbname\\\"]\\n )\\n return db\",\n \"def get_db(self):\\n db = getattr(g, '_database', None)\\n if db is None:\\n db = g._database = connect(DATABASE)\\n return db\",\n \"def get_pool(self):\\n try:\\n return self._pool\\n except AttributeError:\\n db_url = getattr(settings, self.name)\\n self._pool = PostgresConnectionPool.for_url(db_url)\\n return self._pool\",\n \"def get_new_connection(self, conn_params):\\r\\n self.__connection_string = conn_params.get('connection_string', '')\\r\\n conn = Database.connect(**conn_params)\\r\\n return conn\",\n \"async def get(self):\\n if self._connect_kwargs == None:\\n raise IllegalAccessError(\\\"DB connection parameters not set yet\\\")\\n\\n if not hasattr(self._tl, \\\"conn\\\"):\\n self._tl.conn = await r.connect(**self._connect_kwargs)\\n\\n return self._tl.conn\",\n \"def get_db():\\n if ( g.get( 'db' ) is None ):\\n g.db = connect_db()\\n\\n return g.db.connect()\",\n \"def getDbConnection(self):\\n return self._oDb;\",\n \"def connect():\\n global db_name\\n con = sqlite3.connect(db_name)\\n return con\",\n \"def __enter__(self):\\n try:\\n self.conn = sqlite3.connect(self.database_configuration)\\n self.cursor = self.conn.cursor()\\n\\n return self.cursor\\n except Exception as error:\\n print(f\\\"DBCM::__enter__::{error}\\\")\",\n \"def getconn(self):\\n #hdbport = int('3%s15' % Settings.hdbinstancenum)\\n con = dbapi.connect(address = self.host, \\\\\\n port = self.port, \\\\\\n user = self.username, \\\\\\n password = self.password, \\\\\\n autocommit = True)\\n if self.schema:\\n cur = con.cursor()\\n try:\\n cur.execute('ALTER SESSION SET CURRENT_SCHEMA = %s' % self.schema)\\n return con\\n except dbapi.Error, err:\\n cur.close()\\n con.close()\\n cur = None\\n raise err\\n finally:\\n if cur:\\n cur.close()\\n else:\\n return con\",\n \"def dbsession(cls):\\n sqlahelper = cls.dbsqlahelper\\n return sqlahelper.getmake_session()\",\n \"def get_con(s_name, auth_path=None, db=None):\\n con=None\\n auth_path = os.path.dirname(os.path.abspath(__file__)) + '/db.csv' if auth_path is None else auth_path\\n csv_path=util.format_path(auth_path)\\n t_db=pd.read_csv(csv_path)\\n #t_db.fillna(None, inplace=True)\\n t_db=t_db[t_db['ID']==s_name]\\n if len(t_db)==0:\\n util.error_msg('Database %s is not defined!' % s_name)\\n one=t_db.iloc[0]\\n s_db=db or one['DB']\\n if one['TYPE']=='MYSQL':\\n import MySQLdb as mysql\\n #print one['HOST'], one['USR'], one['PWD'], s_db\\n if not one['PORT'] or pd.isnull(one['PORT']):\\n con=mysql.connect(one['HOST'], one['USR'], one['PWD'], s_db, port=3306, charset='utf8')\\n else:\\n con=mysql.connect(one['HOST'], one['USR'], one['PWD'], s_db, port=int(one['PORT']), charset='utf8')\\n elif one['TYPE']=='POSTGRES':\\n import pgdb\\n # make sure you do:\\n #module load postgresql/9.2.4\\n #export LD_LIBRARY_PATH=.:/tools/GNU/postgresql/9.2.4/lib/\\n con=pgdb.connect(one['CONNECT'])\\n elif one['TYPE']=='ORACLE':\\n import cx_Oracle as oracle\\n con=oracle.connect(one['CONNECT'])\\n else:\\n util.error_msg('Unsupported database engine: %s' % one['TYPE'])\\n return con\",\n \"def get_db(server_id):\\n DATABASE = \\\"DATABASE\\\" + str(server_id)\\n print(DATABASE)\\n tracktop = _app_ctx_stack.top\\n if not hasattr(tracktop, 'track_db0') and server_id == 0:\\n tracktop.track_db0 = sqlite3.connect(app.config[DATABASE], detect_types=sqlite3.PARSE_DECLTYPES)\\n tracktop.track_db0.row_factory = sqlite3.Row\\n if not hasattr(tracktop, 'track_db1') and server_id == 1:\\n tracktop.track_db1 = sqlite3.connect(app.config[DATABASE], detect_types=sqlite3.PARSE_DECLTYPES)\\n tracktop.track_db1.row_factory = sqlite3.Row\\n if not hasattr(tracktop, 'track_db2') and server_id == 2:\\n tracktop.track_db2 = sqlite3.connect(app.config[DATABASE], detect_types=sqlite3.PARSE_DECLTYPES)\\n tracktop.track_db2.row_factory = sqlite3.Row\\n\\n if server_id == 0:\\n return tracktop.track_db0\\n elif server_id == 1:\\n return tracktop.track_db1\\n else:\\n return tracktop.track_db2\",\n \"def _get_db(reconnect=False):\\n global _db, _connection\\n identity = get_identity()\\n # Connect if not already connected\\n if _connection.get(identity) is None or reconnect:\\n _connection[identity] = _get_connection(reconnect=reconnect)\\n\\n if _db.get(identity) is None or reconnect:\\n # _db_name will be None if the user hasn't called connect()\\n if _db_name is None:\\n raise ConnectionError('Not connected to the database')\\n\\n # Get DB from current connection and authenticate if necessary\\n _db[identity] = _connection[identity][_db_name]\\n if _db_username and _db_password:\\n _db[identity].authenticate(_db_username, _db_password)\\n\\n return _db[identity]\",\n \"def __connect(host):\\n global pg_pool\\n pg_config['host'] = host\\n pg_pool = SimpleConnectionPool(1, 1, **pg_config)\",\n \"def _get_conn(self):\\n return redis.Redis(connection_pool=self.pool)\",\n \"def get_client(conn):\\n # No database indicates a cluster connection\\n if not conn.get('db', None):\\n conn.pop('db', None)\\n return connect_redis_cluster(conn)\\n\\n # Otherwise it's a regular redis connection\\n return connect_redis(conn)\",\n \"def get(self, conn_alias: str) -> \\\"BaseDBAsyncClient\\\":\\n storage: Dict[str, \\\"BaseDBAsyncClient\\\"] = self._get_storage()\\n try:\\n return storage[conn_alias]\\n except KeyError:\\n connection: BaseDBAsyncClient = self._create_connection(conn_alias)\\n storage[conn_alias] = connection\\n return connection\",\n \"def __make_connection(self, path):\\n try:\\n connection = sqlite3.connect(path)\\n return connection\\n except sqlite3.Error as e:\\n pass\\n return None\",\n \"def get_db():\\n db = getattr(g, '_database', None)\\n if db is None:\\n db = g._database = sqlite3.connect(DATABASE)\\n db.row_factory = sqlite3.Row\\n return db\",\n \"def _get_pool(self, *args, **kwargs):\\n\\n pool_name = '_pool_%s' % getattr(self, 'alias', 'common')\\n\\n if not hasattr (self.__class__, pool_name):\\n lock = thread.allocate_lock()\\n lock.acquire()\\n\\n try:\\n pool = cx_Oracle.SessionPool(\\n user=self.user,\\n password=self.password,\\n dsn=self.tns,\\n min=CX_POOL_SESSION_MIN,\\n max=CX_POOL_SESSION_MAX,\\n increment=CX_POOL_SESSION_INCREMENT,\\n connectiontype=cx_Oracle.Connection,\\n threaded=CX_POOL_THREADED,\\n getmode=cx_Oracle.SPOOL_ATTRVAL_NOWAIT,\\n homogeneous=True)\\n except Exception as err:\\n pool = None\\n\\n if pool:\\n pool.timeout = CX_POOL_CONNECT_TIMEOUT\\n setattr(self.__class__, pool_name, pool)\\n else:\\n msg = \\\"\\\"\\\" ### Database login failed or database not found ### \\\"\\\"\\\"\\n raise self.Database_Error, ('%s') %(msg)\\n\\n lock.release()\\n\\n return getattr(self.__class__, pool_name)\",\n \"def get_db():\\r\\n if not hasattr(g, 'sqlite_db'):\\r\\n g.sqlite_db = connect_db()\\r\\n return g.sqlite_db\",\n \"def connect_thread():\\n return factory.connect_thread(SlaveService, remote_service = SlaveService)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79301536","0.74529684","0.7043397","0.7013358","0.6935523","0.6571063","0.65294355","0.6474125","0.64452714","0.64002967","0.6362195","0.63587844","0.6348218","0.634644","0.63254464","0.6292941","0.62925506","0.62602526","0.6254633","0.6221707","0.6212537","0.62088245","0.6197586","0.61897254","0.6164786","0.61397916","0.61362994","0.61328065","0.61266893","0.612527","0.61213166","0.6114418","0.61137503","0.61009747","0.60988694","0.60983974","0.6094874","0.60829943","0.6036253","0.6036253","0.60340834","0.6020051","0.6016561","0.59985554","0.59914637","0.59863824","0.59753674","0.59599507","0.595758","0.5955427","0.59526515","0.5949246","0.59298193","0.59197533","0.59080577","0.59080577","0.590554","0.5902147","0.59003174","0.5898807","0.5894435","0.5881689","0.5878066","0.5867002","0.5843805","0.58352935","0.58321244","0.5831663","0.5823161","0.5811552","0.5796398","0.5795344","0.57945216","0.57944864","0.5794095","0.5776141","0.5769748","0.5760117","0.57558495","0.57544667","0.5750075","0.5733549","0.5729784","0.5716188","0.5714847","0.57111186","0.57014626","0.5688704","0.56883854","0.56830674","0.56786126","0.56779546","0.56719047","0.5662935","0.56588966","0.5655586","0.5655109","0.56543505","0.5654193","0.5651629"],"string":"[\n \"0.79301536\",\n \"0.74529684\",\n \"0.7043397\",\n \"0.7013358\",\n \"0.6935523\",\n \"0.6571063\",\n \"0.65294355\",\n \"0.6474125\",\n \"0.64452714\",\n \"0.64002967\",\n \"0.6362195\",\n \"0.63587844\",\n \"0.6348218\",\n \"0.634644\",\n \"0.63254464\",\n \"0.6292941\",\n \"0.62925506\",\n \"0.62602526\",\n \"0.6254633\",\n \"0.6221707\",\n \"0.6212537\",\n \"0.62088245\",\n \"0.6197586\",\n \"0.61897254\",\n \"0.6164786\",\n \"0.61397916\",\n \"0.61362994\",\n \"0.61328065\",\n \"0.61266893\",\n \"0.612527\",\n \"0.61213166\",\n \"0.6114418\",\n \"0.61137503\",\n \"0.61009747\",\n \"0.60988694\",\n \"0.60983974\",\n \"0.6094874\",\n \"0.60829943\",\n \"0.6036253\",\n \"0.6036253\",\n \"0.60340834\",\n \"0.6020051\",\n \"0.6016561\",\n \"0.59985554\",\n \"0.59914637\",\n \"0.59863824\",\n \"0.59753674\",\n \"0.59599507\",\n \"0.595758\",\n \"0.5955427\",\n \"0.59526515\",\n \"0.5949246\",\n \"0.59298193\",\n \"0.59197533\",\n \"0.59080577\",\n \"0.59080577\",\n \"0.590554\",\n \"0.5902147\",\n \"0.59003174\",\n \"0.5898807\",\n \"0.5894435\",\n \"0.5881689\",\n \"0.5878066\",\n \"0.5867002\",\n \"0.5843805\",\n \"0.58352935\",\n \"0.58321244\",\n \"0.5831663\",\n \"0.5823161\",\n \"0.5811552\",\n \"0.5796398\",\n \"0.5795344\",\n \"0.57945216\",\n \"0.57944864\",\n \"0.5794095\",\n \"0.5776141\",\n \"0.5769748\",\n \"0.5760117\",\n \"0.57558495\",\n \"0.57544667\",\n \"0.5750075\",\n \"0.5733549\",\n \"0.5729784\",\n \"0.5716188\",\n \"0.5714847\",\n \"0.57111186\",\n \"0.57014626\",\n \"0.5688704\",\n \"0.56883854\",\n \"0.56830674\",\n \"0.56786126\",\n \"0.56779546\",\n \"0.56719047\",\n \"0.5662935\",\n \"0.56588966\",\n \"0.5655586\",\n \"0.5655109\",\n \"0.56543505\",\n \"0.5654193\",\n \"0.5651629\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8007835"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92096,"cells":{"query":{"kind":"string","value":"Update the last Study mapping time to mark a change to the Study mappings table and allow dependents to invalidate caches"},"document":{"kind":"string","value":"def _mark_study_mapping_update(self, unit_id: str) -> None:\n self._last_study_mapping_update_times[unit_id] = time.monotonic()"},"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 mapper_updated(self):\n self.invalidate()\n return","def memoryMapChanged(self, mem: ghidra.program.database.mem.MemoryMapDB) -> None:\n ...","def is_study_mapping_in_sync(self, unit_id: str, compare_time: float):\n return compare_time > self._last_study_mapping_update_times[unit_id]","def updateDateIndexAUTOR(map, line):\n artista = line[\"artist_id\"]\n \n entry = om.get(map, artista)\n\n \n if entry is None:\n datentry = newDataEntryAUTOR(line)\n om.put(map, artista, datentry)\n lt.addLast(datentry['lstevents'],line)\n else:\n datentry = me.getValue(entry)\n \n #addDateIndexAUTOR(datentry, line)\n return map","def updateDateIndex(map, accident):\n occurreddate = accident['Start_Time']\n accidentdate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\n entry = om.get(map, accidentdate.date())\n if entry is None:\n datentry = newDataEntry2(accident)\n om.put(map, accidentdate.date(), datentry)\n else:\n datentry = me.getValue(entry)\n addDateIndex(datentry, accident)\n\n return map","def updateDateIndex(map, accident):\n occurreddate = accident['End_Time']\n accidentdate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\n entry = om.get(map, accidentdate.date())\n if entry is None:\n datentry = newDataEntry(accident)\n om.put(map, accidentdate.date(), datentry)\n else:\n datentry = me.getValue(entry)\n addDateIndex(datentry, accident)\n return map","def order_after_update(mapper, connection, target):\n cache_manager.refresh(target)\n for assignment in target.assignments:\n cache_manager.refresh(assignment)","def test_partial_updates(self):\r\n now = datetime.now()\r\n #derez it a bit\r\n now = datetime(*now.timetuple()[:-3])\r\n early = now - timedelta(minutes=30)\r\n earlier = early - timedelta(minutes=30)\r\n later = now + timedelta(minutes=30)\r\n\r\n initial = {'now': now, 'early': earlier}\r\n final = {'later': later, 'early': early}\r\n\r\n m1 = TestMapModel.create(text_map=initial)\r\n\r\n m1.text_map = final\r\n m1.save()\r\n\r\n m2 = TestMapModel.get(partition=m1.partition)\r\n assert m2.text_map == final","def updateDateIndex(map, accidente):\n occurreddate = accidente['Start_Time']\n accidentedate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\n entry = om.get(map, accidentedate.date())\n if entry is None:\n datentry = newDataEntry(accidente)\n om.put(map, accidentedate.date(), datentry)\n else:\n datentry = me.getValue(entry)\n addDateIndex(datentry, accidente)\n return map","def updateDateIndex(map, crime):\n occurreddate = crime[\"created_at\"]\n crimedate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\n entry = om.get(map, crimedate.date())\n if entry is None:\n datentry = newDataEntry(crime)\n om.put(map, crimedate.date(), datentry)\n else:\n datentry = me.getValue(entry)\n \n addDateIndex(datentry, crime)\n return map","def update(self):\n self.send_tf_msg()\n super(Map).update()","def is_map_updated(self):\r\n self.old_obs_len =0\r\n if len(self.obs_ls[0])!= self.old_obs_len:\r\n self.old_obs_len =len(self.obs_ls[0])\r\n return True\r\n return False","def _update_modified_data_sources(self):\n new_last_imported = datetime.utcnow()\n self._update_modified_since(self.last_imported)\n self.last_imported = new_last_imported","def test_update_discovery_map__changed(self) -> None:\n with open(self._old_file, 'w') as f:\n json.dump({\n 'schema-version': 'v1',\n 'document-version': 'old',\n 'namespaces': [],\n }, f)\n expected = {\n 'schema-version': 'v1',\n 'document-version': 'new',\n 'namespaces': [],\n }\n self._config.discovery_map_exec = self._get_runnable_cmd(0, None, expected)\n self._config.data_store_exec = self._get_runnable_cmd(0, None, {})\n gen = generate.GenerateDataImpl(self._config)\n res = gen.update_discovery_map()\n self.assertEqual(0, res)\n self.assertTrue(os.path.isfile(self._old_file))\n with open(self._old_file, 'r') as f:\n self.assertEqual(expected, json.load(f))","def resetConflictList(self):\n return\n #self.conflict_list = PersistentMapping()","def update_satellite_state(self, current_date):\n pass","def _update_tracker(self, changes):\n for change in changes:\n indx = change[0]\n old_symb = change[1]\n new_symb = change[2]\n self.atoms_indx[old_symb].remove(indx)\n self.atoms_indx[new_symb].add(indx)","def update_time(self):\n pass # Do nothing","def _idx_changed(self, idx):\n self.refresh_memory()","def finalize_mapping(self, asset, piece, uses_svg):\n try:\n old_asset = AssetMap.objects.get(piece=piece)\n if old_asset.folder != asset.folder:\n logging.info('Renaming asset, %s -> %s' % (old_asset,asset))\n old_asset.delete()\n except AssetMap.DoesNotExist:\n pass\n\n asset.piece = piece\n asset.published = True\n asset.uses_svg = uses_svg\n asset.save()","def update_isolation(self, time: int):","def _update_farness_map(self,ind):","def rebuild_index_old(self):\n logging.debug(\"updating detailed information for {}\".format(self))\n\n with get_db_connection() as db:\n c = db.cursor()\n c.execute(\"\"\"DELETE FROM observable_mapping WHERE alert_id = %s\"\"\", ( self.id, ))\n c.execute(\"\"\"DELETE FROM tag_mapping WHERE alert_id = %s\"\"\", ( self.id, ))\n db.commit()\n\n self.build_index()","def update(self, dt):\n self.level.update(self.keys, dt)","def sync_update(self):\n for rec in self:\n if rec.ks_last_exported_date and rec.ks_sync_date:\n ks_reduced_ks_sync_time = rec.ks_last_exported_date - datetime.timedelta(seconds=30)\n ks_increased_ks_sync_time = rec.ks_last_exported_date + datetime.timedelta(seconds=30)\n if rec.ks_sync_date > ks_reduced_ks_sync_time and rec.ks_sync_date < ks_increased_ks_sync_time:\n rec.ks_sync_status = True\n else:\n rec.ks_sync_status = False\n else:\n rec.ks_sync_status = False","def at_db_location_postsave(self, new):\n if not hasattr(self, \"_safe_contents_update\"):\n # changed/set outside of the location handler\n if new:\n # if new, there is no previous location to worry about\n if self.db_location:\n self.db_location.contents_cache.add(self)\n else:\n # Since we cannot know at this point was old_location was, we\n # trigger a full-on contents_cache update here.\n logger.log_warn(\n \"db_location direct save triggered contents_cache.init() for all objects!\"\n )\n [o.contents_cache.init() for o in self.__dbclass__.get_all_cached_instances()]","def update_time(self):\n time_metrics = self._fetch_time_metrics_and_clear()\n self._logger.info('update_time. time_metrics = %s', build_metrics_times_data(time_metrics))","def _observe_time_constrained(self, change):\n if change['value']:\n link_vars = self.linkable_vars[:]\n link_vars.insert(0, 'sequence_end')\n self.linkable_vars = link_vars\n elif 'sequence_end' in self.linkable_vars:\n link_vars = self.linkable_vars[:]\n link_vars.remove('sequence_end')\n self.linkable_vars = link_vars","def update(self, time):\n raise NotImplementedError","def update(self, time):\n raise NotImplementedError","def update_time(cls, key):\n key.put()","def mapToolChanged(self):\n \n if (isinstance(self.iface.mapCanvas().mapTool(), GetRcl) == False and\n isinstance(self.iface.mapCanvas().mapTool(), UpdateReviewPosition) == False): \n self._currentMapTool = self.iface.mapCanvas().mapTool()\n #self.highlighter.hideAll()\n # logging \n uilog.info('*** TOOL CHANGE *** {0} started'.format(self.iface.mapCanvas().mapTool()))","def update_regrets(self, timepoint, regret):\r\n self.regrets[timepoint] = regret","def update(self,new_time_dt):\n\n # If first step, just record state then return\n if self._first_step:\n if new_time_dt != self._curr_time_dt:\n raise RuntimeWarning('Saw wrong initial time')\n self.state_recorder.add_DS_hist(self._curr_time_dt,self.DS_state)\n self._first_step = False\n return\n\n self._curr_time_dt = new_time_dt\n\n ##############################\n # update state recorder\n \n self.state_recorder.add_DS_hist(self._curr_time_dt,self.DS_state)","def _update_use(self, key):\n\t\tif (self._replace_pol == Cache.LRU):\n\t\t\tself.cache[key]= self.hashmap[key]\n\t\tif (self._replace_pol == Cache.LRU_S):\n\t\t\tself.cache[key] = self.hashmap[key]","def update_tlm(self):","def mark_dirty(self, chunk, coords):\n\n chunk.dirty = True","def test_update_saved_app_map_search(self):\n pass","def update_versioned_target(self, vt):\n self._cache_manager.update(vt.cache_key)","def update_afferents_ap(self,time):\n\t\t# Iterate over all dictionaries\n\t\tfor muscle in self.cells:\n\t\t\tfor cellName in self.cells[muscle]:\n\t\t\t\tif cellName in self._afferentsNames:\n\t\t\t\t\tfor cell in self.cells[muscle][cellName]:\n\t\t\t\t\t\tcell.update(time)","def update(tango_address, ts):\n\ts = Session()\n\n\ttry:\n\t\tquery = s.query(Lookup).filter_by(tango_addr=tango_address).first()\n\t\tquery.timestamp = ts\n\n\t\ts.commit()\n\t\ts.close()\n\t\treturn 0\n\texcept:\n\t\treturn -1","def sync_mark_dirty(self, chunk, coords):\n\n chunk.dirty = True","def lvar_mapping_changed(self, *args):\n return _ida_hexrays.Hexrays_Hooks_lvar_mapping_changed(self, *args)","def timestamp_one(self, path):\n stat = path.stat()\n sde = self.manager.source_date_epoch\n if stat.st_mtime > sde:\n cls = self.__class__.__name__\n self.log.debug(\n f\"[lite][base] <{cls}> set time to source_date_epoch {sde} on {path}\"\n )\n os.utime(path, (sde, sde))\n return\n return","def timestamp_one(self, path):\n stat = path.stat()\n sde = self.manager.source_date_epoch\n if stat.st_mtime > sde:\n cls = self.__class__.__name__\n self.log.debug(\n f\"[lite][base] <{cls}> set time to source_date_epoch {sde} on {path}\"\n )\n os.utime(path, (sde, sde))\n return\n return","def finish_translation_list_update():\n\n with _conn.cursor() as cur:\n cur.execute(\"ALTER TABLE translation_stats ENABLE TRIGGER update_translation_stats_timestamp;\")\n _conn.commit()","def refreshMTimes(self):\n del self.mtimesReset[:]\n for fileName, fileInfo in self.data.items():\n oldMTime = self.mtimes.get(fileName,fileInfo.mtime)\n self.mtimes[fileName] = oldMTime\n #--Reset mtime?\n if fileInfo.mtime != oldMTime and oldMTime != -1:\n fileInfo.setMTime(oldMTime)\n self.mtimesReset.append(fileName)","def change_map_up(self):\n if self.current_map_idx > 0:\n self.change_map(self.current_map_idx + 1)","def update_dict(new,old):","def project_changed(self, day_idx):\n self.is_modified = True\n self.fire_project_changed(ChartProject.CHANGED)","def update_households_contact_traced(self, time: int):","def save(self, *args, **kwargs):\n super(ColumnMapping, self).save(*args, **kwargs)\n # Because we need to have saved our ColumnMapping in order to have M2M,\n # We must create it before we prune older references.\n self.remove_duplicates(self.column_raw.all())","def save_model(self, request, obj, form, *args, **kwargs):\n super().save_model(request, obj, form, *args, **kwargs)\n if form.changed_data:\n qs = Work.objects.filter(writerinwork__writer=obj)\n qs.update(last_change=now())","def touch(self):\n self._timestamps['last_seen'] = rospy.get_rostime()","def reset_loc_changes(self) -> None:\n raise NotImplementedError('not implemented')","def pre_route_table_update(self, resource_id, resource_dict):\n pass","def __changeMarkersUpdated(self, editor):\n if editor.hasChangeMarkers():\n self.changeNextAct.setEnabled(True)\n self.changePreviousAct.setEnabled(True)\n else:\n self.changeNextAct.setEnabled(False)\n self.changePreviousAct.setEnabled(False)","def update_last_started_at(self, timestamp: int) -> None:\n assert self.indexes is not None\n self.set_last_started_at(timestamp)\n for index in self.indexes.iter_all_indexes():\n index_db_name = index.get_db_name()\n if index_db_name is None:\n continue\n self.set_index_last_started_at(index_db_name, timestamp)","def OnUpdatePlantCtrl(self, _):\n self.saveTexts()\n self.updateMarkers()","def updateTimeStep(self, newDt):\n self.timeStep = newDt","def test_update_study(self):\n study_spec = sample_study_spec()\n study_id = self.storage.create_study(study_spec)\n self.assertEqual(study_pb2.StudySpec.STATE_ENABLED, study_spec.state)\n self.assertEqual('test', study_spec.name)\n creation_time = study_spec.creation_time.ToDatetime()\n\n study_spec.name = 'changed test'\n study_spec.state = study_pb2.StudySpec.STATE_DISABLED\n study_spec.creation_time.GetCurrentTime()\n self.storage.update_study(study_spec)\n\n study_spec = self.storage.get_study(study_id)\n self.assertIsNotNone(study_spec)\n assert study_spec # To disable attribute-error\n self.assertEqual('changed test', study_spec.name)\n # Creation time and status should not change.\n self.assertEqual(study_pb2.StudySpec.STATE_ENABLED, study_spec.state)\n self.assertEqual(creation_time, study_spec.creation_time.ToDatetime())","def updated_if_changed(attr, t_list, first=False):\n existing = getattr(self, attr)\n new = get_transition_date_from_history(\n t_list, state_history, first=first\n )\n if new != existing:\n setattr(self, attr, new)","def update_timestamp(self):\n self._timestamp = datetime.datetime.now()","def updatemark(self):\n trans = {'A':'1','1':'1','C':'2','2':'2','G':'3','3':'3','T':'4','4':'4'}\n lmark = self.mark['marklist']\n for mark in lmark:\n self.mark[mark]['a1'] = trans.get(self.mark[mark]['a1'],'0')\n self.mark[mark]['a2'] = trans.get(self.mark[mark]['a2'],'0')","def _updateLastChange(self, result):\n if self.target.lastChange is None:\n # hacky but always save _lastConfigChange the first time to\n # distinguish this from a brand new resource\n self.target._lastConfigChange = self.changeId\n if result.modified or self._resourceChanges.getAttributeChanges(\n self.target.key\n ):\n self.target._lastStateChange = self.changeId","def _update_active_rides_fast(self, time: datetime) -> None:\n pass","def _update_modified_since(self, timestamp):\n for data_source in self.data_source_provider.get_data_sources_modified_since(timestamp):\n pillow_logging.info(f'updating modified registry data source: {data_source.domain}: {data_source._id}')\n self._add_or_update_data_source(data_source)","def update_tree_map_one():\n global DATA_FRAME_ADS_LIBRARY\n\n start_date = request.args.get('start_date')\n end_date = request.args.get('end_date')\n\n start_arr = [int(x) for x in start_date.split(\"/\")]\n end_arr = [int(x) for x in end_date.split(\"/\")]\n t_start = datetime(start_arr[2], start_arr[1], start_arr[0], 0, 0, 0)\n t_end = datetime(end_arr[2], end_arr[1], end_arr[0], 0, 0, 0)\n\n # Create timeseries index\n df_raw_timed = create_timestamp_indexes(DATA_FRAME_ADS_LIBRARY,\n column=\"ad_delivery_start_time\",\n format_date=\"%Y-%m-%d\")\n\n # Split the data by time invervals\n df_timed_splited = create_time_splits(df=df_raw_timed,\n t_start=t_start,\n t_end=t_end)\n\n df_ads_by_party = get_df_ads_by_party(df=df_timed_splited)\n\n df_ads_by_party.reset_index(inplace=True)\n\n # fig = create_tree_map_plot(df=df_ads_by_party,\n # values=\"Count\",\n # columns=[\"page_name\"],\n # title='Total Anuncios por Página de Facebook',\n # width=None,\n # height=None)\n\n return df_ads_by_party.to_json()","def save(self, *args, **kwargs):\n self.modify_ts = datetime.now()\n super(ModelBase, self).save(*args, **kwargs)","def change_map_down(self):\n self.change_map(self.current_map_idx + 1)","def _refresh_cache(self, data_dict):\r\n pass","def at_idmapper_flush(self):\n return True","def mark_no_changes(self):","def updateG(self, dt):\n\t\tself.tissue.G.project( (self.initial * dt + Identity(3)) * self.tissue.G )","def post_route_table_update(self, resource_id, resource_dict):\n pass","def test_update_discovery_map__no_change(self) -> None:\n expected = {\n 'schema-version': 'v1',\n 'document-version': 'z',\n 'namespaces': [],\n }\n with open(self._old_file, 'w') as f:\n json.dump(expected, f)\n self._config.discovery_map_exec = self._get_runnable_cmd(0, None, expected)\n # data-store should not run, so have it generate an error if it does.\n self._config.data_store_exec = self._get_runnable_cmd(1, None, {})\n gen = generate.GenerateDataImpl(self._config)\n res = gen.update_discovery_map()\n self.assertEqual(0, res)","def save_model(self, request, obj, form, *args, **kwargs):\n super().save_model(request, obj, form, *args, **kwargs)\n if form.changed_data:\n qs = Work.objects.filter(\n models.Q(recordings__record_label=obj))\n qs.update(last_change=now())","def save(self, *args, **kwargs) -> None:\n self.last_updated_time = get_now()\n super(AbstractLayer, self).save(*args, **kwargs)","def update(self, dt):\n\n self.collecting(dt)","def _mark_as_saved(self, message):\n sensor_type = message.get('sensor_type', 'default')\n self.last_written_for_sensor_type[sensor_type] = time.time()\n self.log(\"Updated last_saved for sensor type %s -> %r\" % (sensor_type,\n self.last_written_for_sensor_type))","def test_map_update_updates(self):\r\n partition = uuid4()\r\n cluster = 1\r\n TestQueryUpdateModel.objects.create(\r\n partition=partition, cluster=cluster,\r\n text_map={\"foo\": '1', \"bar\": '2'})\r\n TestQueryUpdateModel.objects(\r\n partition=partition, cluster=cluster).update(\r\n text_map__update={\"bar\": '3', \"baz\": '4'})\r\n obj = TestQueryUpdateModel.objects.get(partition=partition, cluster=cluster)\r\n self.assertEqual(obj.text_map, {\"foo\": '1', \"bar\": '3', \"baz\": '4'})","def cron_refresh_spacetrack_cache():\n s = SpaceTrackApi()\n updated_tles_str = s.get_all_tles()\n storage.save_tle_cache(updated_tles_str)\n last_updated[0] = int(time.time())\n metadata = {\n 'last_updated': last_updated[0],\n }\n storage.save_metadata(metadata)","def test_map_update_updates(self):\n partition = uuid4()\n cluster = 1\n TestQueryUpdateModel.objects.create(\n partition=partition, cluster=cluster,\n text_map={\"foo\": '1', \"bar\": '2'})\n TestQueryUpdateModel.objects(\n partition=partition, cluster=cluster).update(\n text_map__update={\"bar\": '3', \"baz\": '4'})\n obj = TestQueryUpdateModel.objects.get(partition=partition, cluster=cluster)\n self.assertEqual(obj.text_map, {\"foo\": '1', \"bar\": '3', \"baz\": '4'})","def _update_last_meas_time(self, meas_time):\n self._db.Query(\"\"\"INSERT INTO last_dashboard_element_segment_value\n SET last_measurement_time = %s,\n element_id = %s,\n segment_value_id = %s\n ON DUPLICATE KEY UPDATE \n last_measurement_time = %s\"\"\",(meas_time, self._id, self._segment_value_id, meas_time))","def test_dictionary_inplace_update(self):\r\n vm = Dictionary.value_manager(None, None, {1:2, 3:4})\r\n assert not vm.changed\r\n vm.value[4] = 5\r\n assert vm.changed","def _update_proxy(self, change):\n # The superclass implementation is sufficient.\n super(MapView, self)._update_proxy(change)","def _reset_changes(self):\r\n self._original = {}\r\n if self.last_updated is not None:\r\n self._original['last_updated'] = self.last_updated","def mark_assembly_as_modified(self):\n self._assemblyIsModified = True","def testDirtyRefresh(self):\n \n pass","def update_freqdict(seq, freqdict):\n return","def save_model(self, request, obj, form, *args, **kwargs):\n super().save_model(request, obj, form, *args, **kwargs)\n if form.changed_data:\n qs = Work.objects.filter(library_release=obj)\n qs.update(last_change=now())","def _add_clock_to_map(self, model_key, clock_dict):\n # Only allow one clock.\n if len(self.model_map['clock']) > 0:\n raise ItemExistsError('The model already has a clock!')\n\n # Map it.\n self.model_map['clock'] = [model_key, clock_dict]","def setLastModified(when):","def update(self, record):\n record[self.UPDATED_AT] = strftime(\"%Y-%m-%d %H:%M:%S\", gmtime())\n super(self.__class__, self).update(record)","def change_map(self, map_name):\n cmd = '{}changeMap {}'.format(self.console, map_name)\n self.write_command(cmd)","def save_model(self, request, obj, form, *args, **kwargs):\n super().save_model(request, obj, form, *args, **kwargs)\n if form.changed_data:\n qs = Work.objects.filter(\n models.Q(artistinwork__artist=obj) |\n models.Q(recordings__artist=obj))\n qs.update(last_change=now())","def _update_metadata_date(self, properties):\n if \"core\" not in properties:\n properties.core = Struct()\n properties.core.metadata_date = self._backend.server_time_utc()","def current_mapping(self, current_mapping):\n self._current_mapping = current_mapping","def bm_update(self,dt,delta):\n curr_coord = self.Coord\n self.History.append(curr_coord)\n change = self.bm_change(dt,delta)\n self.Coord = curr_coord + change","def restart(self):\n self.setMap(self.manualBaseMap())"],"string":"[\n \"def mapper_updated(self):\\n self.invalidate()\\n return\",\n \"def memoryMapChanged(self, mem: ghidra.program.database.mem.MemoryMapDB) -> None:\\n ...\",\n \"def is_study_mapping_in_sync(self, unit_id: str, compare_time: float):\\n return compare_time > self._last_study_mapping_update_times[unit_id]\",\n \"def updateDateIndexAUTOR(map, line):\\n artista = line[\\\"artist_id\\\"]\\n \\n entry = om.get(map, artista)\\n\\n \\n if entry is None:\\n datentry = newDataEntryAUTOR(line)\\n om.put(map, artista, datentry)\\n lt.addLast(datentry['lstevents'],line)\\n else:\\n datentry = me.getValue(entry)\\n \\n #addDateIndexAUTOR(datentry, line)\\n return map\",\n \"def updateDateIndex(map, accident):\\n occurreddate = accident['Start_Time']\\n accidentdate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\\n entry = om.get(map, accidentdate.date())\\n if entry is None:\\n datentry = newDataEntry2(accident)\\n om.put(map, accidentdate.date(), datentry)\\n else:\\n datentry = me.getValue(entry)\\n addDateIndex(datentry, accident)\\n\\n return map\",\n \"def updateDateIndex(map, accident):\\n occurreddate = accident['End_Time']\\n accidentdate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\\n entry = om.get(map, accidentdate.date())\\n if entry is None:\\n datentry = newDataEntry(accident)\\n om.put(map, accidentdate.date(), datentry)\\n else:\\n datentry = me.getValue(entry)\\n addDateIndex(datentry, accident)\\n return map\",\n \"def order_after_update(mapper, connection, target):\\n cache_manager.refresh(target)\\n for assignment in target.assignments:\\n cache_manager.refresh(assignment)\",\n \"def test_partial_updates(self):\\r\\n now = datetime.now()\\r\\n #derez it a bit\\r\\n now = datetime(*now.timetuple()[:-3])\\r\\n early = now - timedelta(minutes=30)\\r\\n earlier = early - timedelta(minutes=30)\\r\\n later = now + timedelta(minutes=30)\\r\\n\\r\\n initial = {'now': now, 'early': earlier}\\r\\n final = {'later': later, 'early': early}\\r\\n\\r\\n m1 = TestMapModel.create(text_map=initial)\\r\\n\\r\\n m1.text_map = final\\r\\n m1.save()\\r\\n\\r\\n m2 = TestMapModel.get(partition=m1.partition)\\r\\n assert m2.text_map == final\",\n \"def updateDateIndex(map, accidente):\\n occurreddate = accidente['Start_Time']\\n accidentedate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\\n entry = om.get(map, accidentedate.date())\\n if entry is None:\\n datentry = newDataEntry(accidente)\\n om.put(map, accidentedate.date(), datentry)\\n else:\\n datentry = me.getValue(entry)\\n addDateIndex(datentry, accidente)\\n return map\",\n \"def updateDateIndex(map, crime):\\n occurreddate = crime[\\\"created_at\\\"]\\n crimedate = datetime.datetime.strptime(occurreddate, '%Y-%m-%d %H:%M:%S')\\n entry = om.get(map, crimedate.date())\\n if entry is None:\\n datentry = newDataEntry(crime)\\n om.put(map, crimedate.date(), datentry)\\n else:\\n datentry = me.getValue(entry)\\n \\n addDateIndex(datentry, crime)\\n return map\",\n \"def update(self):\\n self.send_tf_msg()\\n super(Map).update()\",\n \"def is_map_updated(self):\\r\\n self.old_obs_len =0\\r\\n if len(self.obs_ls[0])!= self.old_obs_len:\\r\\n self.old_obs_len =len(self.obs_ls[0])\\r\\n return True\\r\\n return False\",\n \"def _update_modified_data_sources(self):\\n new_last_imported = datetime.utcnow()\\n self._update_modified_since(self.last_imported)\\n self.last_imported = new_last_imported\",\n \"def test_update_discovery_map__changed(self) -> None:\\n with open(self._old_file, 'w') as f:\\n json.dump({\\n 'schema-version': 'v1',\\n 'document-version': 'old',\\n 'namespaces': [],\\n }, f)\\n expected = {\\n 'schema-version': 'v1',\\n 'document-version': 'new',\\n 'namespaces': [],\\n }\\n self._config.discovery_map_exec = self._get_runnable_cmd(0, None, expected)\\n self._config.data_store_exec = self._get_runnable_cmd(0, None, {})\\n gen = generate.GenerateDataImpl(self._config)\\n res = gen.update_discovery_map()\\n self.assertEqual(0, res)\\n self.assertTrue(os.path.isfile(self._old_file))\\n with open(self._old_file, 'r') as f:\\n self.assertEqual(expected, json.load(f))\",\n \"def resetConflictList(self):\\n return\\n #self.conflict_list = PersistentMapping()\",\n \"def update_satellite_state(self, current_date):\\n pass\",\n \"def _update_tracker(self, changes):\\n for change in changes:\\n indx = change[0]\\n old_symb = change[1]\\n new_symb = change[2]\\n self.atoms_indx[old_symb].remove(indx)\\n self.atoms_indx[new_symb].add(indx)\",\n \"def update_time(self):\\n pass # Do nothing\",\n \"def _idx_changed(self, idx):\\n self.refresh_memory()\",\n \"def finalize_mapping(self, asset, piece, uses_svg):\\n try:\\n old_asset = AssetMap.objects.get(piece=piece)\\n if old_asset.folder != asset.folder:\\n logging.info('Renaming asset, %s -> %s' % (old_asset,asset))\\n old_asset.delete()\\n except AssetMap.DoesNotExist:\\n pass\\n\\n asset.piece = piece\\n asset.published = True\\n asset.uses_svg = uses_svg\\n asset.save()\",\n \"def update_isolation(self, time: int):\",\n \"def _update_farness_map(self,ind):\",\n \"def rebuild_index_old(self):\\n logging.debug(\\\"updating detailed information for {}\\\".format(self))\\n\\n with get_db_connection() as db:\\n c = db.cursor()\\n c.execute(\\\"\\\"\\\"DELETE FROM observable_mapping WHERE alert_id = %s\\\"\\\"\\\", ( self.id, ))\\n c.execute(\\\"\\\"\\\"DELETE FROM tag_mapping WHERE alert_id = %s\\\"\\\"\\\", ( self.id, ))\\n db.commit()\\n\\n self.build_index()\",\n \"def update(self, dt):\\n self.level.update(self.keys, dt)\",\n \"def sync_update(self):\\n for rec in self:\\n if rec.ks_last_exported_date and rec.ks_sync_date:\\n ks_reduced_ks_sync_time = rec.ks_last_exported_date - datetime.timedelta(seconds=30)\\n ks_increased_ks_sync_time = rec.ks_last_exported_date + datetime.timedelta(seconds=30)\\n if rec.ks_sync_date > ks_reduced_ks_sync_time and rec.ks_sync_date < ks_increased_ks_sync_time:\\n rec.ks_sync_status = True\\n else:\\n rec.ks_sync_status = False\\n else:\\n rec.ks_sync_status = False\",\n \"def at_db_location_postsave(self, new):\\n if not hasattr(self, \\\"_safe_contents_update\\\"):\\n # changed/set outside of the location handler\\n if new:\\n # if new, there is no previous location to worry about\\n if self.db_location:\\n self.db_location.contents_cache.add(self)\\n else:\\n # Since we cannot know at this point was old_location was, we\\n # trigger a full-on contents_cache update here.\\n logger.log_warn(\\n \\\"db_location direct save triggered contents_cache.init() for all objects!\\\"\\n )\\n [o.contents_cache.init() for o in self.__dbclass__.get_all_cached_instances()]\",\n \"def update_time(self):\\n time_metrics = self._fetch_time_metrics_and_clear()\\n self._logger.info('update_time. time_metrics = %s', build_metrics_times_data(time_metrics))\",\n \"def _observe_time_constrained(self, change):\\n if change['value']:\\n link_vars = self.linkable_vars[:]\\n link_vars.insert(0, 'sequence_end')\\n self.linkable_vars = link_vars\\n elif 'sequence_end' in self.linkable_vars:\\n link_vars = self.linkable_vars[:]\\n link_vars.remove('sequence_end')\\n self.linkable_vars = link_vars\",\n \"def update(self, time):\\n raise NotImplementedError\",\n \"def update(self, time):\\n raise NotImplementedError\",\n \"def update_time(cls, key):\\n key.put()\",\n \"def mapToolChanged(self):\\n \\n if (isinstance(self.iface.mapCanvas().mapTool(), GetRcl) == False and\\n isinstance(self.iface.mapCanvas().mapTool(), UpdateReviewPosition) == False): \\n self._currentMapTool = self.iface.mapCanvas().mapTool()\\n #self.highlighter.hideAll()\\n # logging \\n uilog.info('*** TOOL CHANGE *** {0} started'.format(self.iface.mapCanvas().mapTool()))\",\n \"def update_regrets(self, timepoint, regret):\\r\\n self.regrets[timepoint] = regret\",\n \"def update(self,new_time_dt):\\n\\n # If first step, just record state then return\\n if self._first_step:\\n if new_time_dt != self._curr_time_dt:\\n raise RuntimeWarning('Saw wrong initial time')\\n self.state_recorder.add_DS_hist(self._curr_time_dt,self.DS_state)\\n self._first_step = False\\n return\\n\\n self._curr_time_dt = new_time_dt\\n\\n ##############################\\n # update state recorder\\n \\n self.state_recorder.add_DS_hist(self._curr_time_dt,self.DS_state)\",\n \"def _update_use(self, key):\\n\\t\\tif (self._replace_pol == Cache.LRU):\\n\\t\\t\\tself.cache[key]= self.hashmap[key]\\n\\t\\tif (self._replace_pol == Cache.LRU_S):\\n\\t\\t\\tself.cache[key] = self.hashmap[key]\",\n \"def update_tlm(self):\",\n \"def mark_dirty(self, chunk, coords):\\n\\n chunk.dirty = True\",\n \"def test_update_saved_app_map_search(self):\\n pass\",\n \"def update_versioned_target(self, vt):\\n self._cache_manager.update(vt.cache_key)\",\n \"def update_afferents_ap(self,time):\\n\\t\\t# Iterate over all dictionaries\\n\\t\\tfor muscle in self.cells:\\n\\t\\t\\tfor cellName in self.cells[muscle]:\\n\\t\\t\\t\\tif cellName in self._afferentsNames:\\n\\t\\t\\t\\t\\tfor cell in self.cells[muscle][cellName]:\\n\\t\\t\\t\\t\\t\\tcell.update(time)\",\n \"def update(tango_address, ts):\\n\\ts = Session()\\n\\n\\ttry:\\n\\t\\tquery = s.query(Lookup).filter_by(tango_addr=tango_address).first()\\n\\t\\tquery.timestamp = ts\\n\\n\\t\\ts.commit()\\n\\t\\ts.close()\\n\\t\\treturn 0\\n\\texcept:\\n\\t\\treturn -1\",\n \"def sync_mark_dirty(self, chunk, coords):\\n\\n chunk.dirty = True\",\n \"def lvar_mapping_changed(self, *args):\\n return _ida_hexrays.Hexrays_Hooks_lvar_mapping_changed(self, *args)\",\n \"def timestamp_one(self, path):\\n stat = path.stat()\\n sde = self.manager.source_date_epoch\\n if stat.st_mtime > sde:\\n cls = self.__class__.__name__\\n self.log.debug(\\n f\\\"[lite][base] <{cls}> set time to source_date_epoch {sde} on {path}\\\"\\n )\\n os.utime(path, (sde, sde))\\n return\\n return\",\n \"def timestamp_one(self, path):\\n stat = path.stat()\\n sde = self.manager.source_date_epoch\\n if stat.st_mtime > sde:\\n cls = self.__class__.__name__\\n self.log.debug(\\n f\\\"[lite][base] <{cls}> set time to source_date_epoch {sde} on {path}\\\"\\n )\\n os.utime(path, (sde, sde))\\n return\\n return\",\n \"def finish_translation_list_update():\\n\\n with _conn.cursor() as cur:\\n cur.execute(\\\"ALTER TABLE translation_stats ENABLE TRIGGER update_translation_stats_timestamp;\\\")\\n _conn.commit()\",\n \"def refreshMTimes(self):\\n del self.mtimesReset[:]\\n for fileName, fileInfo in self.data.items():\\n oldMTime = self.mtimes.get(fileName,fileInfo.mtime)\\n self.mtimes[fileName] = oldMTime\\n #--Reset mtime?\\n if fileInfo.mtime != oldMTime and oldMTime != -1:\\n fileInfo.setMTime(oldMTime)\\n self.mtimesReset.append(fileName)\",\n \"def change_map_up(self):\\n if self.current_map_idx > 0:\\n self.change_map(self.current_map_idx + 1)\",\n \"def update_dict(new,old):\",\n \"def project_changed(self, day_idx):\\n self.is_modified = True\\n self.fire_project_changed(ChartProject.CHANGED)\",\n \"def update_households_contact_traced(self, time: int):\",\n \"def save(self, *args, **kwargs):\\n super(ColumnMapping, self).save(*args, **kwargs)\\n # Because we need to have saved our ColumnMapping in order to have M2M,\\n # We must create it before we prune older references.\\n self.remove_duplicates(self.column_raw.all())\",\n \"def save_model(self, request, obj, form, *args, **kwargs):\\n super().save_model(request, obj, form, *args, **kwargs)\\n if form.changed_data:\\n qs = Work.objects.filter(writerinwork__writer=obj)\\n qs.update(last_change=now())\",\n \"def touch(self):\\n self._timestamps['last_seen'] = rospy.get_rostime()\",\n \"def reset_loc_changes(self) -> None:\\n raise NotImplementedError('not implemented')\",\n \"def pre_route_table_update(self, resource_id, resource_dict):\\n pass\",\n \"def __changeMarkersUpdated(self, editor):\\n if editor.hasChangeMarkers():\\n self.changeNextAct.setEnabled(True)\\n self.changePreviousAct.setEnabled(True)\\n else:\\n self.changeNextAct.setEnabled(False)\\n self.changePreviousAct.setEnabled(False)\",\n \"def update_last_started_at(self, timestamp: int) -> None:\\n assert self.indexes is not None\\n self.set_last_started_at(timestamp)\\n for index in self.indexes.iter_all_indexes():\\n index_db_name = index.get_db_name()\\n if index_db_name is None:\\n continue\\n self.set_index_last_started_at(index_db_name, timestamp)\",\n \"def OnUpdatePlantCtrl(self, _):\\n self.saveTexts()\\n self.updateMarkers()\",\n \"def updateTimeStep(self, newDt):\\n self.timeStep = newDt\",\n \"def test_update_study(self):\\n study_spec = sample_study_spec()\\n study_id = self.storage.create_study(study_spec)\\n self.assertEqual(study_pb2.StudySpec.STATE_ENABLED, study_spec.state)\\n self.assertEqual('test', study_spec.name)\\n creation_time = study_spec.creation_time.ToDatetime()\\n\\n study_spec.name = 'changed test'\\n study_spec.state = study_pb2.StudySpec.STATE_DISABLED\\n study_spec.creation_time.GetCurrentTime()\\n self.storage.update_study(study_spec)\\n\\n study_spec = self.storage.get_study(study_id)\\n self.assertIsNotNone(study_spec)\\n assert study_spec # To disable attribute-error\\n self.assertEqual('changed test', study_spec.name)\\n # Creation time and status should not change.\\n self.assertEqual(study_pb2.StudySpec.STATE_ENABLED, study_spec.state)\\n self.assertEqual(creation_time, study_spec.creation_time.ToDatetime())\",\n \"def updated_if_changed(attr, t_list, first=False):\\n existing = getattr(self, attr)\\n new = get_transition_date_from_history(\\n t_list, state_history, first=first\\n )\\n if new != existing:\\n setattr(self, attr, new)\",\n \"def update_timestamp(self):\\n self._timestamp = datetime.datetime.now()\",\n \"def updatemark(self):\\n trans = {'A':'1','1':'1','C':'2','2':'2','G':'3','3':'3','T':'4','4':'4'}\\n lmark = self.mark['marklist']\\n for mark in lmark:\\n self.mark[mark]['a1'] = trans.get(self.mark[mark]['a1'],'0')\\n self.mark[mark]['a2'] = trans.get(self.mark[mark]['a2'],'0')\",\n \"def _updateLastChange(self, result):\\n if self.target.lastChange is None:\\n # hacky but always save _lastConfigChange the first time to\\n # distinguish this from a brand new resource\\n self.target._lastConfigChange = self.changeId\\n if result.modified or self._resourceChanges.getAttributeChanges(\\n self.target.key\\n ):\\n self.target._lastStateChange = self.changeId\",\n \"def _update_active_rides_fast(self, time: datetime) -> None:\\n pass\",\n \"def _update_modified_since(self, timestamp):\\n for data_source in self.data_source_provider.get_data_sources_modified_since(timestamp):\\n pillow_logging.info(f'updating modified registry data source: {data_source.domain}: {data_source._id}')\\n self._add_or_update_data_source(data_source)\",\n \"def update_tree_map_one():\\n global DATA_FRAME_ADS_LIBRARY\\n\\n start_date = request.args.get('start_date')\\n end_date = request.args.get('end_date')\\n\\n start_arr = [int(x) for x in start_date.split(\\\"/\\\")]\\n end_arr = [int(x) for x in end_date.split(\\\"/\\\")]\\n t_start = datetime(start_arr[2], start_arr[1], start_arr[0], 0, 0, 0)\\n t_end = datetime(end_arr[2], end_arr[1], end_arr[0], 0, 0, 0)\\n\\n # Create timeseries index\\n df_raw_timed = create_timestamp_indexes(DATA_FRAME_ADS_LIBRARY,\\n column=\\\"ad_delivery_start_time\\\",\\n format_date=\\\"%Y-%m-%d\\\")\\n\\n # Split the data by time invervals\\n df_timed_splited = create_time_splits(df=df_raw_timed,\\n t_start=t_start,\\n t_end=t_end)\\n\\n df_ads_by_party = get_df_ads_by_party(df=df_timed_splited)\\n\\n df_ads_by_party.reset_index(inplace=True)\\n\\n # fig = create_tree_map_plot(df=df_ads_by_party,\\n # values=\\\"Count\\\",\\n # columns=[\\\"page_name\\\"],\\n # title='Total Anuncios por Página de Facebook',\\n # width=None,\\n # height=None)\\n\\n return df_ads_by_party.to_json()\",\n \"def save(self, *args, **kwargs):\\n self.modify_ts = datetime.now()\\n super(ModelBase, self).save(*args, **kwargs)\",\n \"def change_map_down(self):\\n self.change_map(self.current_map_idx + 1)\",\n \"def _refresh_cache(self, data_dict):\\r\\n pass\",\n \"def at_idmapper_flush(self):\\n return True\",\n \"def mark_no_changes(self):\",\n \"def updateG(self, dt):\\n\\t\\tself.tissue.G.project( (self.initial * dt + Identity(3)) * self.tissue.G )\",\n \"def post_route_table_update(self, resource_id, resource_dict):\\n pass\",\n \"def test_update_discovery_map__no_change(self) -> None:\\n expected = {\\n 'schema-version': 'v1',\\n 'document-version': 'z',\\n 'namespaces': [],\\n }\\n with open(self._old_file, 'w') as f:\\n json.dump(expected, f)\\n self._config.discovery_map_exec = self._get_runnable_cmd(0, None, expected)\\n # data-store should not run, so have it generate an error if it does.\\n self._config.data_store_exec = self._get_runnable_cmd(1, None, {})\\n gen = generate.GenerateDataImpl(self._config)\\n res = gen.update_discovery_map()\\n self.assertEqual(0, res)\",\n \"def save_model(self, request, obj, form, *args, **kwargs):\\n super().save_model(request, obj, form, *args, **kwargs)\\n if form.changed_data:\\n qs = Work.objects.filter(\\n models.Q(recordings__record_label=obj))\\n qs.update(last_change=now())\",\n \"def save(self, *args, **kwargs) -> None:\\n self.last_updated_time = get_now()\\n super(AbstractLayer, self).save(*args, **kwargs)\",\n \"def update(self, dt):\\n\\n self.collecting(dt)\",\n \"def _mark_as_saved(self, message):\\n sensor_type = message.get('sensor_type', 'default')\\n self.last_written_for_sensor_type[sensor_type] = time.time()\\n self.log(\\\"Updated last_saved for sensor type %s -> %r\\\" % (sensor_type,\\n self.last_written_for_sensor_type))\",\n \"def test_map_update_updates(self):\\r\\n partition = uuid4()\\r\\n cluster = 1\\r\\n TestQueryUpdateModel.objects.create(\\r\\n partition=partition, cluster=cluster,\\r\\n text_map={\\\"foo\\\": '1', \\\"bar\\\": '2'})\\r\\n TestQueryUpdateModel.objects(\\r\\n partition=partition, cluster=cluster).update(\\r\\n text_map__update={\\\"bar\\\": '3', \\\"baz\\\": '4'})\\r\\n obj = TestQueryUpdateModel.objects.get(partition=partition, cluster=cluster)\\r\\n self.assertEqual(obj.text_map, {\\\"foo\\\": '1', \\\"bar\\\": '3', \\\"baz\\\": '4'})\",\n \"def cron_refresh_spacetrack_cache():\\n s = SpaceTrackApi()\\n updated_tles_str = s.get_all_tles()\\n storage.save_tle_cache(updated_tles_str)\\n last_updated[0] = int(time.time())\\n metadata = {\\n 'last_updated': last_updated[0],\\n }\\n storage.save_metadata(metadata)\",\n \"def test_map_update_updates(self):\\n partition = uuid4()\\n cluster = 1\\n TestQueryUpdateModel.objects.create(\\n partition=partition, cluster=cluster,\\n text_map={\\\"foo\\\": '1', \\\"bar\\\": '2'})\\n TestQueryUpdateModel.objects(\\n partition=partition, cluster=cluster).update(\\n text_map__update={\\\"bar\\\": '3', \\\"baz\\\": '4'})\\n obj = TestQueryUpdateModel.objects.get(partition=partition, cluster=cluster)\\n self.assertEqual(obj.text_map, {\\\"foo\\\": '1', \\\"bar\\\": '3', \\\"baz\\\": '4'})\",\n \"def _update_last_meas_time(self, meas_time):\\n self._db.Query(\\\"\\\"\\\"INSERT INTO last_dashboard_element_segment_value\\n SET last_measurement_time = %s,\\n element_id = %s,\\n segment_value_id = %s\\n ON DUPLICATE KEY UPDATE \\n last_measurement_time = %s\\\"\\\"\\\",(meas_time, self._id, self._segment_value_id, meas_time))\",\n \"def test_dictionary_inplace_update(self):\\r\\n vm = Dictionary.value_manager(None, None, {1:2, 3:4})\\r\\n assert not vm.changed\\r\\n vm.value[4] = 5\\r\\n assert vm.changed\",\n \"def _update_proxy(self, change):\\n # The superclass implementation is sufficient.\\n super(MapView, self)._update_proxy(change)\",\n \"def _reset_changes(self):\\r\\n self._original = {}\\r\\n if self.last_updated is not None:\\r\\n self._original['last_updated'] = self.last_updated\",\n \"def mark_assembly_as_modified(self):\\n self._assemblyIsModified = True\",\n \"def testDirtyRefresh(self):\\n \\n pass\",\n \"def update_freqdict(seq, freqdict):\\n return\",\n \"def save_model(self, request, obj, form, *args, **kwargs):\\n super().save_model(request, obj, form, *args, **kwargs)\\n if form.changed_data:\\n qs = Work.objects.filter(library_release=obj)\\n qs.update(last_change=now())\",\n \"def _add_clock_to_map(self, model_key, clock_dict):\\n # Only allow one clock.\\n if len(self.model_map['clock']) > 0:\\n raise ItemExistsError('The model already has a clock!')\\n\\n # Map it.\\n self.model_map['clock'] = [model_key, clock_dict]\",\n \"def setLastModified(when):\",\n \"def update(self, record):\\n record[self.UPDATED_AT] = strftime(\\\"%Y-%m-%d %H:%M:%S\\\", gmtime())\\n super(self.__class__, self).update(record)\",\n \"def change_map(self, map_name):\\n cmd = '{}changeMap {}'.format(self.console, map_name)\\n self.write_command(cmd)\",\n \"def save_model(self, request, obj, form, *args, **kwargs):\\n super().save_model(request, obj, form, *args, **kwargs)\\n if form.changed_data:\\n qs = Work.objects.filter(\\n models.Q(artistinwork__artist=obj) |\\n models.Q(recordings__artist=obj))\\n qs.update(last_change=now())\",\n \"def _update_metadata_date(self, properties):\\n if \\\"core\\\" not in properties:\\n properties.core = Struct()\\n properties.core.metadata_date = self._backend.server_time_utc()\",\n \"def current_mapping(self, current_mapping):\\n self._current_mapping = current_mapping\",\n \"def bm_update(self,dt,delta):\\n curr_coord = self.Coord\\n self.History.append(curr_coord)\\n change = self.bm_change(dt,delta)\\n self.Coord = curr_coord + change\",\n \"def restart(self):\\n self.setMap(self.manualBaseMap())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6335052","0.58112735","0.56721526","0.54929096","0.5459769","0.5457291","0.5452044","0.54163307","0.54032046","0.5332193","0.52810687","0.52514476","0.52494526","0.52186","0.520193","0.51904476","0.5174565","0.5160427","0.51492006","0.5144736","0.51364726","0.51356053","0.512257","0.50872326","0.508627","0.5027872","0.49962986","0.4993492","0.49868074","0.49868074","0.498427","0.49792668","0.49697506","0.49684468","0.49469072","0.4946567","0.49442062","0.49426997","0.49423477","0.49417377","0.49385574","0.49357173","0.49345782","0.4924793","0.4924793","0.49036768","0.49008974","0.49004525","0.4898014","0.48950633","0.48905373","0.4871571","0.4868051","0.48629022","0.4861761","0.4861482","0.48586464","0.485701","0.48474884","0.4841194","0.48380148","0.48312598","0.48310712","0.4831053","0.48245504","0.4810633","0.48013058","0.48004857","0.47913346","0.47837734","0.47806495","0.4777425","0.47759598","0.47722834","0.47664982","0.4765758","0.4761227","0.4760699","0.47600216","0.47552213","0.4754286","0.47505966","0.47503865","0.47416583","0.47360578","0.47338465","0.4732629","0.47290307","0.47277594","0.47275338","0.47261125","0.47252136","0.4724056","0.47165552","0.47144434","0.47144207","0.47113863","0.47077355","0.4701891","0.46927845"],"string":"[\n \"0.6335052\",\n \"0.58112735\",\n \"0.56721526\",\n \"0.54929096\",\n \"0.5459769\",\n \"0.5457291\",\n \"0.5452044\",\n \"0.54163307\",\n \"0.54032046\",\n \"0.5332193\",\n \"0.52810687\",\n \"0.52514476\",\n \"0.52494526\",\n \"0.52186\",\n \"0.520193\",\n \"0.51904476\",\n \"0.5174565\",\n \"0.5160427\",\n \"0.51492006\",\n \"0.5144736\",\n \"0.51364726\",\n \"0.51356053\",\n \"0.512257\",\n \"0.50872326\",\n \"0.508627\",\n \"0.5027872\",\n \"0.49962986\",\n \"0.4993492\",\n \"0.49868074\",\n \"0.49868074\",\n \"0.498427\",\n \"0.49792668\",\n \"0.49697506\",\n \"0.49684468\",\n \"0.49469072\",\n \"0.4946567\",\n \"0.49442062\",\n \"0.49426997\",\n \"0.49423477\",\n \"0.49417377\",\n \"0.49385574\",\n \"0.49357173\",\n \"0.49345782\",\n \"0.4924793\",\n \"0.4924793\",\n \"0.49036768\",\n \"0.49008974\",\n \"0.49004525\",\n \"0.4898014\",\n \"0.48950633\",\n \"0.48905373\",\n \"0.4871571\",\n \"0.4868051\",\n \"0.48629022\",\n \"0.4861761\",\n \"0.4861482\",\n \"0.48586464\",\n \"0.485701\",\n \"0.48474884\",\n \"0.4841194\",\n \"0.48380148\",\n \"0.48312598\",\n \"0.48310712\",\n \"0.4831053\",\n \"0.48245504\",\n \"0.4810633\",\n \"0.48013058\",\n \"0.48004857\",\n \"0.47913346\",\n \"0.47837734\",\n \"0.47806495\",\n \"0.4777425\",\n \"0.47759598\",\n \"0.47722834\",\n \"0.47664982\",\n \"0.4765758\",\n \"0.4761227\",\n \"0.4760699\",\n \"0.47600216\",\n \"0.47552213\",\n \"0.4754286\",\n \"0.47505966\",\n \"0.47503865\",\n \"0.47416583\",\n \"0.47360578\",\n \"0.47338465\",\n \"0.4732629\",\n \"0.47290307\",\n \"0.47277594\",\n \"0.47275338\",\n \"0.47261125\",\n \"0.47252136\",\n \"0.4724056\",\n \"0.47165552\",\n \"0.47144434\",\n \"0.47144207\",\n \"0.47113863\",\n \"0.47077355\",\n \"0.4701891\",\n \"0.46927845\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77558404"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":92097,"cells":{"query":{"kind":"string","value":"Run all the table creation SQL queries to ensure the expected tables exist"},"document":{"kind":"string","value":"def init_tables(self) -> None:\n with self.table_access_condition:\n conn = self._get_connection()\n conn.execute(\"PRAGMA foreign_keys = 1\")\n c = conn.cursor()\n c.execute(tables.CREATE_STUDIES_TABLE)\n c.execute(tables.CREATE_SUBMISSIONS_TABLE)\n c.execute(tables.CREATE_REQUESTERS_TABLE)\n c.execute(tables.CREATE_UNITS_TABLE)\n c.execute(tables.CREATE_WORKERS_TABLE)\n c.execute(tables.CREATE_RUNS_TABLE)\n c.execute(tables.CREATE_RUN_MAP_TABLE)\n c.execute(tables.CREATE_PARTICIPANT_GROUPS_TABLE)\n c.execute(tables.CREATE_PARTICIPANT_GROUP_QUALIFICATIONS_MAPPING_TABLE)\n conn.commit()"},"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 create_tables(self):\n for query in table_create_sql:\n self.cursor.execute(query)\n\n self.commit()","def create_tables():\n db.create_all()","def create_tables():\n db.create_all()","def createTables():\n conn = getConnection()\n try:\n cur = conn.cursor()\n for table, query in tables.items():\n cur.execute(query)\n conn.commit()\n except Exception as ex:\n print(\"Failed to create tables:\" )\n print(ex)\n sys.exit(1)","def create_tables(self):\n con = self.connect()\n cursor = con.cursor()\n queries = self.tables()\n for query in queries:\n cursor.execute(query)\n cursor.close()\n con.commit()\n con.close()","def create_all_tables():\n\tcommon_db.create_all_tables()","def create_tables(session):\n \n for query in create_table_queries:\n try:\n session.execute(query)\n except Exception as e:\n print(e)","def create_tables() -> None:\n print(\"Creating database tables using SQLAlchemy ORM\")\n Base.metadata.create_all(engine)\n print(\"Done creating tables\")","def create_all_tables(self):\n pass","def create_tables():\n db.create_all()","def create_tables(session):\n for query in create_table_queries:\n session.execute(query)","def create_tables(cur, conn):\n \n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()\n \n print('Tables created.')","def create_tables_and_apply_patches(self):\n\n if self.authorized and not self.db_tables_initiated:\n with self.connection.cursor() as cursor:\n for statement in self.parse_mysql_sql_file():\n cursor.execute(statement)\n\n PyFunceble.LOGGER.info(\n \"Created the missing tables. Applied all patched\"\n )\n\n self.db_tables_initiated = True","def create_db_tables():\n\n try:\n webapp.dbsql.create_all()\n webapp.dbsql.session.commit()\n except Exception as e:\n # TODO: melhorar o informe do erro\n raise e","def init_tables(self) -> None:\n # TODO(#93) maybe raise flag when the schema of existing tables isn't what we expect\n # it to be?\n # \"How to know that schema changes?\"\n # logger.warning(\"some message\")\n with self.table_access_condition:\n conn = self._get_connection()\n conn.execute(\"PRAGMA foreign_keys = 1\")\n with conn:\n c = conn.cursor()\n c.execute(CREATE_PROJECTS_TABLE)\n c.execute(CREATE_TASKS_TABLE)\n c.execute(CREATE_REQUESTERS_TABLE)\n c.execute(CREATE_TASK_RUNS_TABLE)\n c.execute(CREATE_ASSIGNMENTS_TABLE)\n c.execute(CREATE_UNITS_TABLE)\n c.execute(CREATE_WORKERS_TABLE)\n c.execute(CREATE_AGENTS_TABLE)\n c.execute(CREATE_QUALIFICATIONS_TABLE)\n c.execute(CREATE_GRANTED_QUALIFICATIONS_TABLE)\n c.execute(CREATE_ONBOARDING_AGENTS_TABLE)","def create_tables(cur, conn):\n for query in create_table_queries:\n try:\n cur.execute(query)\n conn.commit()\n except Exception as e:\n print(e)","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn) -> None:\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(session):\n\n for query in create_table_queries:\n session.execute(query)","def create_tables(cur, conn): \n for query in create_table_queries:\n cur.execute(query)\n conn.commit()","def create_tables(cur, conn):\n for query in create_table_queries:\n cur.execute(query)\n conn.commit()\n print(f\"\\nRunning: {query}\")","def create_tables (cls, env=os.environ):\n\n cur = cls.pri_table_read_cursor (env=env)\n cur.execute ('SPECIALCASE gettablelist')\n ret = cur.fetchall ()\n \n existingtables = set ([x[0].lower() for x in ret])\n\n for tabname in (set (cls.table_desc.keys ()) - existingtables):\n sql, lsd = cls.table_desc[tabname]\n epls, desls, sqlprefix = lsd.get_create_labeling (savels=True)\n\n conn = get_labeled_conn (epls, desls)\n cur = conn.cursor ()\n cur.execute (sql)\n conn.close ()\n lsd.pop_labelset ()\n\n \n import psycopg2\n for sql in cls.sql_createindex:\n conn = get_labeled_conn ()\n cur = conn.cursor ()\n # XXX It would be better to check which indices exist as we do for tables.\n try:\n cur.execute (sql)\n except psycopg2.ProgrammingError, e: \n pass\n conn.close ()","def create_tables(self, script):\n for query in script:\n try:\n self.cursor.execute(query)\n except:\n print(\"\\n Une erreur s'est produite lors \"\n \"de la création des tables \\n\")\n print(\"\\n Les tables ont bien été créées \"\n f\"dans la base de données |{DB_NAME}| \\n\")","def create_tables():\n # Depending on your local settings, you may need to specify a user and password, e.g.\n # conn = psycopg2.connect(dbname=DBNAME, user=\"postgres\", password=\"password\")\n conn = psycopg2.connect(dbname=DBNAME)\n\n create_train_table(conn)\n create_questions_table(conn)\n create_lectures_table(conn)\n create_example_test_table(conn)\n create_example_test_table(conn)\n\n conn.close()","def create_tables(cur, conn):\n for query in create_table_queries:\n try:\n cur.execute(query)\n conn.commit()\n except psycopg2.Error as e:\n print(\"Error: Could not create table from query: {}\".format(query))\n print(e)","def create_tables(self, conn, cur, *sql_queries):\n check_creation_tables = []\n\n for query in sql_queries:\n try:\n cur.execute(query)\n except Exception as e:\n self.logger.error(f\"{type(e).__name__}: {e}\")\n conn.rollback()\n cur.execute(f\"DROP TABLE IF EXISTS {self.tables[0]} CASCADE\")\n else:\n conn.commit() \n for name in self.table_names: \n cur.execute(\"SELECT COUNT(*) FROM information_schema.tables \" \\\n \"WHERE table_schema='public';\")\n check_creation_tables = cur.fetchone()[0]\n \n cur.close()\n \n check_creation_tables = True if check_creation_tables == 2 else False\n \n return check_creation_tables","def createDbTables():\n logger.info(\"creating required DB table if it does not already exist\")\n try:\n with db.connect() as conn:\n conn.execute(\n \"CREATE TABLE IF NOT EXISTS birthdays \"\n \"( username VARCHAR(255) NOT NULL, birthday DATE NOT NULL, \"\n \"PRIMARY KEY (username) );\"\n )\n return OK\n except Exception as e:\n logger.info(\"Error creating table: %s\" % e)\n return ERR","async def create_tables():\n text_create_citizens_table = queries.CREATE_CITIZENS\n text_create_relative_table = queries.CREATE_RELATIVES\n text_create_consts_table = queries.CREATE_CONSTS\n text_insert_base_import_id = queries.INSERT_IMPORT_ID_0\n text_create_index_citizens = queries.CREATE_INDEX_CITIZENS\n text_create_index_relatives = queries.CREATE_INDEX_RELATIVES\n\n queries_list = [text_create_citizens_table, text_create_relative_table,\n text_create_consts_table, text_insert_base_import_id,\n text_create_index_citizens,text_create_index_relatives]\n\n connection = await sql.connect()\n async with connection.transaction():\n for query in queries_list:\n await sql.execute_query(connection, query)\n await sql.close(connection)","def _create_tables():\n from Model.DataAccessor.DbAccessor.DbOrmAccessor import db\n db.create_tables([SubjectType, SubjectRegion, Subject])","def imp_create_tables():\n config = configparser.ConfigParser()\n config.read('dwh.cfg')\n\n conn = psycopg2.connect(\"host={} dbname={} user={} password={} port={}\".format(*config['CLUSTER'].values()))\n cur = conn.cursor()\n \n # Drop the tables (uncomment if necessary)\n #drop_tables(cur, conn)\n\n # Create the tables\n create_tables(cur, conn)\n\n conn.close()","def check_and_create_table(self) -> None:\n table_ids = [t.table_id for t in self.instance.list_tables()]\n\n if not self.table_id in table_ids:\n self.table.create()\n f = self.table.column_family(self.family_id)\n f.create()\n\n f_inc = self.table.column_family(self.incrementer_family_id,\n gc_rule=MaxVersionsGCRule(1))\n f_inc.create()\n\n f_log = self.table.column_family(self.log_family_id)\n f_log.create()\n\n f_ce = self.table.column_family(self.cross_edge_family_id,\n gc_rule=MaxVersionsGCRule(1))\n f_ce.create()\n\n print(\"Table created\")","def create_database_tables():\n with APP.app_context():\n DB.create_all()","def _init_db(self):\n cursor = self._main_connection.cursor()\n cursor.execute(self.sql[\"create_table\"])\n self._main_connection.commit()","def create_tables (self):\n cursor = self.cur()\n cursor.execute('DROP TABLE IF EXISTS person')\n cursor.execute('DROP TABLE IF EXISTS room')\n cursor.execute('DROP TABLE IF EXISTS allocation')\n cursor.execute(\n 'CREATE TABLE IF NOT EXISTS person (person_id INTEGER PRIMARY KEY, name TEXT, role TEXT)WITHOUT ROWID')\n cursor.execute(\n 'CREATE TABLE IF NOT EXISTS room (name TEXT , no_of_members INTEGER, room_type TEXT)')\n cursor.execute(\n 'CREATE TABLE IF NOT EXISTS allocation (room_name TEXT , person_id INTEGER)')","def create_tables(self):\n if not self.is_enabled(Subsystem.database):\n raise RuntimeError(\"Database subsystem was not enabled\")\n\n Base.metadata.create_all(self.engine)","def createTables ( c ) :\n assert str(type(c)) == \"<type '_mysql.connection'>\"\n sqlQuery ( c, \"drop table if exists Crises;\" )\n sqlQuery ( c, \"drop table if exists Organizations;\" )\n sqlQuery ( c, \"drop table if exists People;\" )\n sqlQuery ( c, \"drop table if exists CrisisLocations;\" )\n sqlQuery ( c, \"drop table if exists PeopleLocations;\" )\n sqlQuery ( c, \"drop table if exists OrganizationLocations;\" )\n sqlQuery ( c, \"drop table if exists HumanImpact;\" )\n sqlQuery ( c, \"drop table if exists ResourceNeeded;\" )\n sqlQuery ( c, \"drop table if exists WaysToHelp;\" )\n sqlQuery ( c, \"drop table if exists PersonExternalResources;\" )\n sqlQuery ( c, \"drop table if exists OrganizationExternalResources;\" )\n sqlQuery ( c, \"drop table if exists CrisisExternalResources;\" )\n sqlQuery ( c, \"drop table if exists PeopleToOrganizations;\" )\n sqlQuery ( c, \"drop table if exists OrganizationsToCrises;\" )\n sqlQuery ( c, \"drop table if exists CrisesToPeople;\" )\n sqlQuery ( c, \"drop table if exists OrganizationKind;\" )\n sqlQuery ( c, \"drop table if exists PersonKind;\" )\n sqlQuery ( c, \"drop table if exists CrisisKind;\" )\n \n sqlQuery ( c, \"create table Crises ( crisisID text, name text, crisisKindID text, startDate date, startTime time, endDate date, endTime time, economicImpact text );\" )\n sqlQuery ( c, \"create table Organizations ( orgID text, name text, orgKindID text, history text, phone bigint, fax bigint, email text, address text, locality text, region text, postalCode text, country text );\" )\n sqlQuery ( c, \"create table People ( personID text, firstName text, middleName text, lastName text, suffix text, personKindID text );\" )\n sqlQuery ( c, \"create table CrisisLocations ( crisisID text, locality text, region text, country text );\" )\n sqlQuery ( c, \"create table PeopleLocations ( personID text, locality text, region text, country text );\" )\n sqlQuery ( c, \"create table OrganizationLocations ( orgID text, locality text, region text, country text );\" )\n sqlQuery ( c, \"create table HumanImpact ( crisisID text, type text, number int );\" )\n sqlQuery ( c, \"create table ResourceNeeded ( crisisID text, resource text );\" )\n sqlQuery ( c, \"create table WaysToHelp ( crisisID text, helpType text );\" )\n sqlQuery ( c, \"create table PersonExternalResources ( personID text, type text, url text );\" )\n sqlQuery ( c, \"create table OrganizationExternalResources ( orgID text, type text, url text );\" )\n sqlQuery ( c, \"create table CrisisExternalResources ( crisisID text, type text, url text );\" )\n sqlQuery ( c, \"create table PeopleToOrganizations ( personID text, orgID text );\" )\n sqlQuery ( c, \"create table OrganizationsToCrises ( orgID text, crisisID text );\" )\n sqlQuery ( c, \"create table CrisesToPeople ( crisisID text, personID text );\" )\n sqlQuery ( c, \"create table OrganizationKind ( orgKindID text, name text, description text );\" )\n sqlQuery ( c, \"create table PersonKind ( personKindID text, name text, description text );\" )\n sqlQuery ( c, \"create table CrisisKind ( crisisKindID text, name text, description text );\" )\n sqlQuery ( c, \"show tables;\" )","def setup_tables(self):\n try:\n self.cursor.execute('CREATE SCHEMA sandbox')\n self.cursor.execute(\"DROP TABLE sandbox.dvds_rdbhdb_super;\")\n except (db.ProgrammingError, db.OperationalError), e:\n # sandbox may not exist\n pass #raise\n\n try:\n self.cursor.execute(\n \"\"\"CREATE TABLE sandbox.dvds_rdbhdb_super(\n id SERIAL PRIMARY KEY,\n name varchar(40) NOT NULL,\n rating float,\n UNIQUE(name)\n );\n \"\"\" )\n except db.ProgrammingError, e:\n if e[0] != '42P07':\n raise","def test_create_tables_cmd_success(self):\n self.runner.invoke(cli,\n args=['create-tables'],\n env={'OS_ELASTICSEARCH_ADDRESS': LOCAL_ELASTICSEARCH})\n engine = config.get_engine()\n inspector = Inspector.from_engine(engine)\n self.assertTrue('models' not in inspector.get_table_names())","def __new_tables_statement(self):\n new_tables = self.__new_tables()\n for table in new_tables:\n with open('./update/create_tables.sql', 'a') as f:\n create_statement = self.source.query_create_table_statement(table.name)\n f.write(create_statement)\n f.write('\\n')","def create_tables(self, tables=None):\n LOG.debug(f\"Creating table subset {tables}\")\n Base.metadata.create_all(self.engine, tables, checkfirst=False)","def _do_action_tables_create(self):\n\n schema_shell = os.path.join(self.bento_home, \"schema-shell\", \"bin\", \"kiji-schema-shell\")\n assert os.path.isfile(schema_shell), schema_shell\n\n # Delete the table first!\n cmd = (\n \"kiji delete --target={kiji_uri} --interactive=false; \" +\n \"kiji install --kiji={kiji_uri}\" ).format(kiji_uri=self.kiji_uri)\n self._run_kiji_job(cmd)\n\n for ddl in self.ddls:\n ddl_full_path = os.path.join(self.movie_advisor_home, ddl)\n assert os.path.isfile(ddl_full_path)\n cmd = \"{schema_shell} --kiji={kiji_uri} --file={ddl_full_path}\".format(\n schema_shell=schema_shell,\n kiji_uri=self.kiji_uri,\n ddl_full_path=ddl_full_path)\n self._run_kiji_job(cmd)","def test_db_schema(client):\n table_names = [\"user\", \"house\", \"user_role\", \"model_param\"]\n with db.engine.connect() as connexion:\n for table_name in table_names:\n assert db.engine.dialect.has_table(connexion, table_name) == True","def createTables(self):\n metadata = Base.metadata\n metadata.create_all(self._engine)\n return","def init_tables(self):\n\n settings.Base.metadata.tables[\n 'session_master'].drop(bind=settings.engine)\n settings.Base.metadata.tables['uurl'].drop(bind=settings.engine)\n\n settings.Base.metadata.tables[\n 'session_master'].create(bind=settings.engine)\n settings.Base.metadata.tables['uurl'].create(bind=settings.engine)\n\n logging.info(\"Sessionization Tables created\")","def create_db_execute(self):\n self.execute(query=self.db_create_schema.format(self.db_name))","def create_tables():\n inf(\"Creating tables\")\n \n pinners = Table('pinners', metadata,\n Column('pinner_id', Integer, primary_key=True),\n Column('name', String(40)),\n Column('email', String(40))\n )\n pinners.create()\n \n contents = Table('contents', metadata,\n Column('content_id', Integer, primary_key=True),\n Column('url', String(80)),\n Column('display_status', String(20)), # good, objectionable, copyright\n Column('pinner_id', Integer, ForeignKey('pinners.pinner_id'))\n )\n contents.create()\n\n reviewers = Table('reviewers', metadata,\n Column('reviewer_id', Integer, primary_key=True),\n Column('name', String(40)),\n Column('email', String(40))\n )\n reviewers.create()\n\n complaints = Table('complaints', metadata,\n Column('complaint_id', Integer, primary_key=True),\n Column('complaint_timestamp', DateTime), # when the complaint was filed\n Column('complaint_type', String(80)), # objectionable, copyright\n Column('process_status', String(20)), # complaint, review, done\n Column('display_status', String(20)), # good, objectionable, copyright\n Column('review_timestamp', DateTime), # when the compliant was resolved\n Column('pinner_id', Integer, ForeignKey('pinners.pinner_id')),\n Column('reviewer_id', Integer, ForeignKey('reviewers.reviewer_id')),\n Column('content_id', Integer, ForeignKey('contents.content_id'))\n )\n complaints.create()\n \n # could create a table of \"near by\" images and/or near by features and \n # include these in the review","def create_tables(engine):\n BASE.metadata.create_all(engine)","def create_tables(self):\n if self.mock:\n mock_dynamodb2(self._create_tables())\n else:\n self._create_tables()","def create_tables(c, drop_all = False):\n\tprint \"create_tables [status]: create tables triggered.\"\n\tautoincrement = \" autoincrement\"\n\tglobal Options, Database\n\tif drop_all:\n\t\tprint \"create_tables [status]: dropping tables initiated.\"\n\t\tif Database.type == DatabaseTypes.SQLITE:\n\t\t\tdrop_sql = open(mk_drop(\"sqlite\")).read()\n\t\telif Database.type == DatabaseTypes.MYSQL:\n\t\t\tdrop_sql = open(mk_drop(\"mysql\")).read()\n\t\telif Database.type == DatabaseTypes.POSTGRES:\n\t\t\tdrop_sql = open(mk_drop(\"postgres\")).read()\n\t\tdrop_list = drop_sql.split(\";\")\n\t\tfor line in drop_list:\n\t\t\tquery = line.strip()\n\t\t\tif query:\n\t\t\t\tc.execute(line)\n\t\tprint \"create_tables [status]: dropping tables complete.\"\n\tif Database.type == DatabaseTypes.SQLITE:\n\t\tdbf = open(mk_schema(\"sqlite\", Options.use_dict))\n\t\tquery_list = dbf.read()\n\t\tc.executescript(query_list)\n\telif Database.type == DatabaseTypes.MYSQL:\n\t\tdbf = open(mk_schema(\"mysql\", Options.use_dict))\n\t\texecutescript(c, dbf)\n\telif Database.type == DatabaseTypes.POSTGRES:\n\t\tdbf = open(mk_schema(\"postgres\", Options.use_dict))\n\t\texecutescript(c, dbf)","def CheckTables():\n cursor.execute(\"SELECT name FROM sqlite_master WHERE type='table'\")\n tables = [row[0] for row in cursor.fetchall()]\n if not tables or not \"master\" in tables:\n cursor.execute('''CREATE TABLE master (\n hit TEXT,\n logfile TEXT,\n count INTEGER,\n date TEXT)''')\n con.commit()\n if not tables or not \"rotate\" in tables:\n cursor.execute('''CREATE TABLE rotate (\n logfile TEXT,\n hash TEXT,\n date TEXT)''')\n con.commit()","def create_table(create_table_sql):\n conn = DbUtil.connection\n try:\n c = conn.cursor()\n c.execute(create_table_sql)\n except Error as e:\n print(e)","def create_database():\n with connection:\n connection.execute(CREATE_MOVIE_TABLE)\n connection.execute(CREATE_USER_TABLE)\n connection.execute(CREATE_WATCHED_TABLE)","def create_fact_tables(cur,conn):\n\tfor query in create_fact_queries:\n\t\tcur.execute(query)\n\t\tconn.commit()","def test_create_tables(self):\n conn_object = ParentConnection()\n conn_object.create_tables()\n conn = psycopg2.connect(**{\"host\": \"localhost\",\n \"database\": \"test\",\n \"user\": \"test\",\n \"password\": \"test\"})\n cur = conn.cursor()\n cur.execute(\"SELECT * from information_schema.tables \"\n \"WHERE table_schema = 'public' \"\n \"AND table_type = 'BASE TABLE';\")\n result = cur.fetchall()\n result = [x[2] for x in result]\n self.assertCountEqual(result,\n ['bioms', 'counts', 'networks',\n 'taxonomy', 'edges', 'samples', 'meta']\n )\n cur.close()\n conn.close()\n conn_object.delete_tables()","def clean_up():\n drop_all_tables()\n create_all()","def _create_tables_classic(self, engine, metadata):\n if engine and metadata:\n with (yield from engine) as conn:\n for x in self._models.values():\n try:\n yield from conn.execute(CreateTable(x))\n except ProgrammingError as error:\n if hasattr(self.app, 'log') and self.app.log:\n if self.app.debug:\n self.app.log.info(\"[PostgressPlugin] [ `{}` already exists]\".format(x))\n else:\n if self.app.debug:\n print(\"[PostgressPlugin] [ `{}` already exists]\".format(x))\n return","def init_tables(database_url, _metadata, checkfirst=True):\n import dpds.storages.db.tables.operations\n import dpds.storages.db.tables.block\n import dpds.storages.db.tables.meta\n with isolated_nullpool_engine(database_url) as engine:\n _metadata.create_all(bind=engine, checkfirst=checkfirst)","def create_table(self, create_table_sql):\n connection = self.__create_connection()\n try:\n c = connection.cursor()\n c.execute(create_table_sql)\n except Error as e:\n print(e)","def create_tables(self):\n for name, attribute in self.__dict__.items():\n if hasattr(attribute, 'create_table_in_sqlite_db'):\n attribute.create_table_in_sqlite_db()","def check_db_schema(self):\n if not self.db.get_tables():\n self.create_db_schema()","def _create_table(self) :\n\n cur = self.con.cursor()\n delete_sql = 'DROP TABLE IF EXISTS \"%s\"' % self.name\n cur.execute(delete_sql)\n\n col_sql = ','.join(['\"%s\" %s' % (self.cols[i], self.types[i])\n for i in range(len(self.cols))])\n create_sql = 'CREATE TABLE \"%s\" ( %s );' % (self.name, col_sql)\n cur.execute(create_sql)","def _ensure_tables(self, db):\n\n # NOTE(kgriffs): Create tables all together rather\n # than separately in each controller, since some queries\n # in the individual controllers actually require the\n # presence of more than one table.\n\n # NOTE(flaper87): Consider moving tables definition\n # outside this method.\n\n db.execute('''\n create table\n if not exists\n Messages (\n id INTEGER,\n qid INTEGER,\n ttl INTEGER,\n content DOCUMENT,\n client UUID,\n created DATETIME, -- seconds since the Julian day\n PRIMARY KEY(id),\n FOREIGN KEY(qid) references Queues(id) on delete cascade\n )\n ''')\n\n db.execute('''\n create table\n if not exists\n Queues (\n id INTEGER,\n project TEXT,\n name TEXT,\n metadata DOCUMENT,\n PRIMARY KEY(id),\n UNIQUE(project, name)\n )\n ''')\n\n db.execute('''\n create table\n if not exists\n Claims (\n id INTEGER PRIMARY KEY AUTOINCREMENT,\n qid INTEGER,\n ttl INTEGER,\n created DATETIME, -- seconds since the Julian day\n FOREIGN KEY(qid) references Queues(id) on delete cascade\n )\n ''')\n\n db.execute('''\n create table\n if not exists\n Locked (\n cid INTEGER,\n msgid INTEGER,\n FOREIGN KEY(cid) references Claims(id) on delete cascade,\n FOREIGN KEY(msgid) references Messages(id) on delete cascade\n )\n ''')","def createTable(self):\n results = self.db.table_create(self.entity).run(self.r)\n time.sleep(5)\n return results","def create_tables(): \n \n pk_contraint = \"CONSTRAINT {}_pk PRIMARY KEY ({})\"\n uq_contraint = \"CONSTRAINT {}_uq UNIQUE ({})\"\n fk_query = \"\"\"CONSTRAINT {}_fk_{} \n FOREIGN KEY ({}) \n REFERENCES {}({}) \n ON UPDATE CASCADE \n ON DELETE RESTRICT\n \"\"\"\n \n create_dict = {}\n index = 1\n\n\n ############################## public SCHEMA ##############################\n \n schema = 'public'\n create_schema(schema)\n\n #################### site ####################\n table_name = 'site'\n pk_id = 'site_id'\n uq_list = ['site_code']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_code CHAR(3),\n purok VARCHAR,\n sitio VARCHAR,\n barangay VARCHAR,\n municipality VARCHAR,\n province VARCHAR,\n region VARCHAR,\n psgc INTEGER,\n active BOOLEAN NOT NULL DEFAULT TRUE,\n season SMALLINT,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n\n ############################## spatial SCHEMA ##############################\n \n schema = 'spatial'\n create_schema(schema)\n \n #################### exposure ####################\n table_name = 'exposure'\n pk_id = 'exp_id'\n uq_list = ['exp_name']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n exp_name VARCHAR,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n \n #################### site_exposure ####################\n table_name = 'site_exposure'\n pk_id = 'se_id'\n uq_list = ['site_id', 'exp_id', 'geom']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\n 'exp_id': {'ref_schema': 'spatial', 'ref_table': 'exposure'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n exp_id INTEGER,\n label_name VARCHAR,\n geom GEOMETRY,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n deactivated DATE,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n \n #################### feature ####################\n table_name = 'feature'\n pk_id = 'feat_id'\n uq_list = ['feat_name']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n feat_name VARCHAR,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### site_feature ####################\n table_name = 'site_feature'\n pk_id = 'sf_id'\n uq_list = ['site_id', 'feat_id', 'geom']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\n 'feat_id': {'ref_schema': 'spatial', 'ref_table': 'feature'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n feat_id INTEGER,\n geom GEOMETRY,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n deactivated DATE,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### hazard_zone ####################\n table_name = 'hazard_zone'\n pk_id = 'hz_id'\n uq_list = ['site_id, geom']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n geom GEOMETRY,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n deactivated DATE,\n {}, {} {}\n );\n \"\"\"\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### monitoring ####################\n table_name = 'monitoring'\n pk_id = 'mon_id'\n uq_list = ['mon_name']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n mon_name VARCHAR,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### site_monitoring ####################\n table_name = 'site_monitoring'\n pk_id = 'sm_id'\n uq_list = ['site_id', 'mon_id', 'geom']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\n 'mon_id': {'ref_schema': 'spatial', 'ref_table': 'monitoring'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n mon_id INTEGER,\n label_name VARCHAR,\n geom GEOMETRY,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n deactivated DATE,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n\n ############################### comm SCHEMA ###############################\n \n schema = 'comm'\n create_schema(schema)\n\n #################### gsm_server ####################\n table_name = 'gsm_server'\n pk_id = 'server_id'\n uq_list = ['server_name']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n server_name VARCHAR,\n platform_type VARCHAR,\n version SMALLINT,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### server_port ####################\n table_name = 'server_port'\n pk_id = 'port_id'\n uq_list = ['server_id', 'port']\n fk_dict = {'server_id': {'ref_schema': 'comm', 'ref_table': 'gsm_server'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n server_id INTEGER,\n port BOOLEAN,\n ser_port VARCHAR,\n pwr_on_pin SMALLINT,\n ring_pin SMALLINT,\n module_type SMALLINT,\n {}, {} {}\n );\n \"\"\"\n query += \"\"\" COMMENT ON TABLE {}.{} IS \n '0- left\n 1- right'\n ;\"\"\".format(schema, table_name)\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### network_type ####################\n table_name = 'network_type'\n pk_id = 'prefix'\n uq_list = ['prefix']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} VARCHAR(3), \n carrier SMALLINT,\n {}, {} {}\n );\n \"\"\"\n query += \"\"\" COMMENT ON TABLE {}.{} IS \n '1- globe\n 2- smart\n 3- landline'\n ;\"\"\".format(schema, table_name)\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### gsm_module ####################\n table_name = 'gsm_module'\n pk_id = 'gsm_id'\n uq_list = ['prefix', 'num', 'activated']\n fk_dict = {'prefix': {'ref_schema': 'comm', 'ref_table': 'network_type'},\n 'port_id': {'ref_schema': 'comm', 'ref_table': 'server_port'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n prefix VARCHAR(3),\n num CHAR(7),\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n port_id INTEGER,\n {}, {} {}\n );\n \"\"\"\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n\n ############################# temporal SCHEMA #############################\n \n schema = 'temporal'\n create_schema(schema)\n\n #################### marker_observation ####################\n table_name = 'marker_observation'\n pk_id = 'mo_id'\n uq_list = ['site_id', 'ts']\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n site_id INTEGER,\n ts TIMESTAMP,\n meas_type VARCHAR(7),\n weather VARCHAR,\n observer_name VARCHAR,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### marker_history ####################\n table_name = 'marker_history'\n pk_id = 'hist_id'\n uq_list = ['sm_id', 'ts', 'event']\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL,\n sm_id BIGINT,\n ts TIMESTAMP,\n event BOOLEAN,\n label_name VARCHAR,\n {}, {} {}\n );\n \"\"\"\n query += \"\"\" COMMENT ON TABLE {}.{} IS \n '0- rename\n 1- reposition'\n ;\"\"\".format(schema, table_name)\n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### marker_data ####################\n table_name = 'marker_data'\n pk_id = 'data_id'\n uq_list = ['sm_id', 'mo_id']\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'},\n 'mo_id': {'ref_schema': 'temporal', 'ref_table': 'marker_observation'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL,\n mo_id BIGINT,\n sm_id BIGINT,\n measurement NUMERIC(5,1),\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### marker_alert ####################\n table_name = 'marker_alert'\n pk_id = 'alert_id'\n uq_list = ['data_id']\n fk_dict = {'data_id': {'ref_schema': 'temporal', 'ref_table': 'marker_data'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL,\n data_id BIGINT,\n displacement NUMERIC(4,1),\n time_delta FLOAT,\n alert_level SMALLINT,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### logger_model ####################\n table_name = 'logger_model'\n pk_id = 'model_id'\n uq_list = ['has_tilt', 'has_rain', 'has_piezo', 'has_soms', 'logger_type']\n fk_dict = {}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n has_tilt BOOLEAN,\n has_rain BOOLEAN,\n has_piezo BOOLEAN,\n has_soms BOOLEAN,\n logger_type SMALLINT,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n #################### logger ####################\n table_name = 'logger'\n pk_id = 'logger_id'\n uq_list = ['sm_id']\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'},\n 'model_id': {'ref_schema': 'temporal', 'ref_table': 'logger_model'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL, \n sm_id BIGINT,\n model_id INTEGER,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n \n #################### logger_mobile ####################\n table_name = 'logger_mobile'\n pk_id = 'mobile_id'\n uq_list = ['logger_id', 'activated']\n fk_dict = {'logger_id': {'ref_schema': 'temporal', 'ref_table': 'logger'},\n 'gsm_id': {'ref_schema': 'comm', 'ref_table': 'gsm_module'}}\n query = \"\"\"CREATE TABLE IF NOT EXISTS {}.{} (\n {} SERIAL,\n logger_id INTEGER,\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\n sim_num VARCHAR(12),\n gsm_id INTEGER,\n {}, {} {}\n );\n \"\"\" \n create_dict[index] = {'schema': schema,\n 'table_name': table_name,\n 'query': query,\n 'pk_id': pk_id,\n 'uq_list': uq_list,\n 'fk_dict': fk_dict}\n index += 1\n\n\n #################### EXECUTE QUERY TO CREATE TABLES ####################\n for index in create_dict.keys():\n dct = create_dict[index]\n schema = dct['schema']\n table_name = dct['table_name']\n query = dct['query']\n pk_id = dct['pk_id']\n uq_list = dct['uq_list']\n fk_dict = dct['fk_dict']\n if len(fk_dict.keys()) == 0:\n fk_constraint = ''\n else:\n fk_constraint_list = ['']\n for fk_id in fk_dict.keys():\n ref_schema = fk_dict.get(fk_id)['ref_schema']\n ref_table = fk_dict.get(fk_id)['ref_table']\n fk_part = fk_query.format(table_name, ref_table, fk_id,\n \"{}.{}\".format(ref_schema, ref_table),\n fk_id)\n fk_constraint_list.append(fk_part)\n fk_constraint = ', '.join(fk_constraint_list)\n \n query = query.format(schema, table_name, pk_id, \n pk_contraint.format(table_name, pk_id),\n uq_contraint.format(table_name, ', '.join(uq_list)),\n \"{}\".format(fk_constraint))\n qdb.execute(query)","async def _create_tables_declarative(self, base, engine):\n if hasattr(base, 'metadata'):\n base.metadata.create_all(bind=engine, checkfirst=True)\n return","def create_tables(cursor):\n cursor.execute(\"\"\"\n CREATE TABLE users(\n userid INTEGER PRIMARY KEY,\n username TEXT NOT NULL,\n password TEXT NOT NULL,\n email TEXT NOT NULL\n );\n \"\"\")\n cursor.execute(\"\"\"\n CREATE TABLE groups(\n groupid INTEGER PRIMARY KEY,\n name TEXT NOT NULL\n );\n \"\"\")\n cursor.execute(\"\"\"\n CREATE TABLE usergroups(\n userid INTEGER,\n groupid INTEGER,\n PRIMARY KEY (userid, groupid)\n FOREIGN KEY (userid) REFERENCES users (userid)\n ON DELETE CASCADE ON UPDATE NO ACTION\n FOREIGN KEY (groupid) REFERENCES groups (groupid)\n ON DELETE CASCADE ON UPDATE NO ACTION\n );\n \"\"\")\n cursor.execute(\"\"\"\n CREATE TABLE settings(\n key TEXT PRIMARY KEY,\n value\n );\n \"\"\")\n cursor.execute(\"\"\"\n CREATE TABLE sessions(\n userid INTEGER PRIMARY KEY,\n key TEXT NOT NULL,\n started TEXT DEFAULT (datetime('now')),\n FOREIGN KEY (userid) REFERENCES users (userid)\n ON DELETE CASCADE ON UPDATE NO ACTION\n );\n \"\"\")\n cursor.execute(\"CREATE UNIQUE INDEX idx_groups_name ON groups (name)\")\n cursor.execute(\n \"CREATE UNIQUE INDEX idx_users_username ON users (username)\"\n )","def main():\n print(\"Creating tables\")\n config = configparser.ConfigParser()\n config.read('dwh.cfg')\n\n connection_string = get_redshift_connection_string(config=config)\n conn = psycopg2.connect(connection_string)\n cur = conn.cursor()\n\n drop_tables(cur, conn)\n create_tables(cur, conn)\n\n conn.close()\n\n print(\"Tables have been successfully created\")","def setUp(self):\n db.drop_all() # clean up the last tests\n db.create_all() # make our sqlalchemy tables","def create_table_statements() -> [str]:\n pass","def create_tables(db_engine):\n\n with db_engine.connect() as conn:\n create_table_stmts = []\n\n create_drugs_table = \"\"\"\n DROP TABLE IF EXISTS drugs CASCADE; \n CREATE TABLE drugs (\n drugbank_id char(7) PRIMARY KEY,\n name varchar NOT NULL, -- Something “Human Readable”,\n smiles varchar\n );\n \"\"\"\n\n create_table_stmts.append(create_drugs_table)\n\n create_drug_id_types_table = \"\"\"\n DROP TABLE IF EXISTS drug_identifier_types CASCADE; \n CREATE TABLE drug_identifier_types (\n identifier_type_id SERIAL UNIQUE, \n identifier_type_name varchar UNIQUE\n ); \n \"\"\"\n create_table_stmts.append(create_drug_id_types_table)\n\n create_drug_identifiers_table = \"\"\"\n DROP TABLE IF EXISTS drug_identifiers CASCADE;\n CREATE TABLE drug_identifiers (\n drugbank_id char(7) references drugs(drugbank_id),\n alt_identifier_value varchar NOT NULL,\n alt_identifier_type_id int references drug_identifier_types(identifier_type_id) NOT NULL,\n alt_identifier_url varchar\n );\n \"\"\"\n create_table_stmts.append(create_drug_identifiers_table)\n\n create_drug_action_types = \"\"\"\n DROP TABLE IF EXISTS drug_action_types CASCADE;\n CREATE TABLE drug_action_types (\n action_type_id SERIAL UNIQUE, \n action_type varchar UNIQUE\n );\n \"\"\"\n create_table_stmts.append(create_drug_action_types)\n\n create_drug_targets_table = \"\"\"\n DROP TABLE IF EXISTS drug_targets CASCADE;\n CREATE TABLE drug_targets (\n drugbank_id char(7) references drugs(drugbank_id),\n gene_name varchar NOT NULL, \n action_type_id int references drug_action_types(action_type_id),\n UNIQUE(drugbank_id, gene_name, action_type_id)\n );\n \"\"\"\n create_table_stmts.append(create_drug_targets_table)\n\n logger.info(\"Creating %d tables\", len(create_table_stmts))\n for stmt in tqdm(create_table_stmts):\n conn.execute(stmt)","def create_tables():\r\n db = connect_database()\r\n table_wait = \"waiting\"\r\n table_helped = \"helped\"\r\n table_help = \"help\"\r\n param_name = ['cus_num', 'name', 'username', 'ru_id', 'os_platform', 'description']\r\n param_type1 = ['INTEGER PRIMARY KEY AUTOINCREMENT', 'TEXT', 'TEXT', 'TEXT', 'TEXT', 'TEXT']\r\n param_type2 = ['INTEGER PRIMARY KEY', 'TEXT', 'TEXT', 'TEXT', 'TEXT', 'TEXT']\r\n with db:\r\n create_table(db, table_wait, param_name, param_type1)\r\n create_table(db, table_helped, param_name, param_type2)\r\n create_table(db, table_help, param_name, param_type2)\r\n db.close()","def create_tables(self):\n users_tb = \"\"\"CREATE TABLE IF NOT EXISTS Users(\n user_id serial PRIMARY KEY,\n email varchar(30) NOT NULL,\n username varchar(15) NOT NULL,\n password varchar(250) NOT NULL,\n role varchar(10) DEFAULT 'User'\n );\"\"\"\n\n meals_tb = \"\"\"CREATE TABLE IF NOT EXISTS Meals(\n meal_id serial PRIMARY KEY,\n meal_name varchar(25) NOT NULL,\n image varchar(150) NOT NULL,\n description varchar(250) NOT NULL,\n unit_price decimal(5,2) NOT NULL\n );\"\"\"\n\n orders_tb = \"\"\"CREATE TABLE IF NOT EXISTS Orders(\n order_id serial PRIMARY KEY,\n user_id integer NOT NULL,\n meal_id integer NOT NULL,\n address varchar(50),\n quantity int NOT NULL,\n order_date timestamp NOT NULL,\n status varchar(15),\n FOREIGN KEY (user_id) REFERENCES users(user_id)\n ON DELETE CASCADE ON UPDATE CASCADE,\n FOREIGN KEY (meal_id) REFERENCES meals(meal_id)\n ON DELETE CASCADE ON UPDATE CASCADE\n );\"\"\"\n return [users_tb, meals_tb, orders_tb]","def process(self):\n try:\n # self.alter_columns()\n self.collect_drop_fk()\n self.update_table()\n self.create_tables()\n self.db_operations.create_fk_constraint(self.fk_constraints, self.contraints_columns)\n return True\n except Exception as err:\n logger.error(\"create_tables [error] -> %s\" % err)","def create_db_tables(self):\n self.releases = Table(\n RELEASES,\n self.metadata,\n Column(\"id\", Integer, primary_key=True, autoincrement=True),\n Column(\"repo\", String),\n Column(\"tag_name\", String),\n Column(\"release_name\", String),\n Column(\"created\", DateTime, default=datetime.datetime.now()),\n extend_existing=True,\n )\n self.commits = Table(\n COMMITS,\n self.metadata,\n Column(\"id\", Integer, primary_key=True, autoincrement=True),\n Column(\"repo\", String),\n Column(\"branch\", String),\n Column(\"sha\", String),\n Column(\"created\", DateTime, default=datetime.datetime.now()),\n extend_existing=True,\n )\n self.tags = Table(\n TAGS,\n self.metadata,\n Column(\"id\", Integer, primary_key=True, autoincrement=True),\n Column(\"repo\", String),\n Column(\"tag_name\", String),\n Column(\"sha\", String),\n Column(\"created\", DateTime, default=datetime.datetime.now()),\n extend_existing=True,\n )\n try:\n self.metadata.create_all()\n log.info(\"Tables created\")\n except Exception as e:\n log.error(\"Error occurred during Table creation!\")\n log.exception(e)","def create_table(self, conn, create_table_sql):\n try:\n c = conn.cursor()\n c.execute(create_table_sql)\n except Error as e:\n print(e)","def create_tables(self):\n\n self.cur.execute('''CREATE TABLE IF NOT EXISTS my_business_entry\n (\n id SERIAL PRIMARY KEY,\n url_yes_no boolean,\n url TEXT,\n phone_yes_no boolean,\n phone TEXT,\n rating TEXT,\n nr_of_ratings TEXT,\n myBusiness boolean,\n company TEXT\n );''')\n\n self.connection.commit()","def create_table(conn, create_table_sql):\r\n try:\r\n c = conn.cursor()\r\n c.execute(create_table_sql)\r\n except Error as e:\r\n print(e)","def _CreateTable(db_conn, create_table_sql):\r\n try:\r\n c = db_conn.cursor()\r\n c.execute(create_table_sql)\r\n except Error as e:\r\n print(e)","def create_table(cursor, TABLES):\n for t_name,t_desc in TABLES.items():\n try:\n print(f\"Creating table '{t_name}'...\")\n cursor.execute(t_desc)\n except mysql.connector.Error as err:\n if err.errno == errorcode.ER_TABLE_EXISTS_ERROR:\n print(f\"{t_name} already exists, moving on...\")\n pass\n else:\n print(err.msg+\".\")\n exit(1)\n else:\n print(\"OK\")\n return None","def create_example_test_table(conn):\n execute_sql_script(conn, \"06_create_example_test_table.sql\")","def refresh_tables(db):\r\n try:\r\n c = db.cursor()\r\n c.execute(\"DROP TABLE waiting\")\r\n c.execute(\"DROP TABLE help\")\r\n c.execute(\"DROP TABLE helped\")\r\n create_tables()\r\n except Error as e:\r\n print(e)","def create_tables(args):\n\n from bob.db.base.utils import create_engine_try_nolock\n\n engine = create_engine_try_nolock(args.type, args.files[0], echo=(args.verbose >= 2));\n Client.metadata.create_all(engine)\n File.metadata.create_all(engine) \n Annotation.metadata.create_all(engine)\n #Protocol_File_Association.metadata.create_all(engine)","def run():\r\n table_names = [\"ram\", \"cpu\", \"ssd\", \"gpu\"]\r\n for table_name in table_names:\r\n create_table(table_name)\r\n page_data: List[str] = get_page_data(table_name=table_name)\r\n processed_data: List[Tuple] = process_page_data(page_data=page_data)\r\n insert_data(processed_data, table_name)\r\n print(\"Complete.\")\r\n\r\n conn.commit()\r\n conn.close()","def create_table(conn, create_table_sql):\r\n try:\r\n c = conn.cursor()\r\n c.execute(create_table_sql)\r\n except Error as e:\r\n print(e)","def create_tables( self ) :\n return self._create_tables","def init_db():\n db = get_db()\n Page.create_table(db)\n PageVersion.create_table(db)\n User.create_table(db)","def _create_schema(self): \n q = (\"CREATE TABLE IF NOT EXISTS \" + \\\n \"profiles (username text, body text, epoch numeric)\",)\n for x in q: self.cursor.execute(x)\n self.conn.commit()","def setup(self):\n #print \"Creating test database...\"\n files = glob.glob(os.path.join(self.home_dir, 'sqlFiles', '*.sql'))\n for fls in files:\n loc = fls.rfind('/')\n #print(\" \" + fls.replace('.sql', '')[loc + 1:])\n flh = open(fls, 'r')\n curs = self.cursor()\n curs.executescript(flh.read())\n self.commit()\n curs.close()\n flh.close()\n for fls in ['INSERTS', 'TRIGGERS']:\n #print(fls)\n flh = open(os.path.join(self.home_dir, 'sqlFiles', fls), 'r')\n curs = self.cursor()\n curs.executescript(flh.read())\n self.commit()\n curs.close()\n flh.close()","def create_table(conn, create_table_sql):\r\n try:\r\n c = conn.cursor()\r\n c.execute(create_table_sql)\r\n conn.commit()\r\n except Error as e:\r\n print(e)","def insert_db():\n populate_tables()","def test_db_table_creation_check(self):\n mock_cursor = Mock()\n mock_cursor.configure_mock(**{\"cursor.return_value.fetchone.return_value\": (\"vnf_table_2\")})\n status = misshtbtd.db_table_creation_check(mock_cursor, \"vnf_table_2\")\n self.assertEqual(status, True)"],"string":"[\n \"def create_tables(self):\\n for query in table_create_sql:\\n self.cursor.execute(query)\\n\\n self.commit()\",\n \"def create_tables():\\n db.create_all()\",\n \"def create_tables():\\n db.create_all()\",\n \"def createTables():\\n conn = getConnection()\\n try:\\n cur = conn.cursor()\\n for table, query in tables.items():\\n cur.execute(query)\\n conn.commit()\\n except Exception as ex:\\n print(\\\"Failed to create tables:\\\" )\\n print(ex)\\n sys.exit(1)\",\n \"def create_tables(self):\\n con = self.connect()\\n cursor = con.cursor()\\n queries = self.tables()\\n for query in queries:\\n cursor.execute(query)\\n cursor.close()\\n con.commit()\\n con.close()\",\n \"def create_all_tables():\\n\\tcommon_db.create_all_tables()\",\n \"def create_tables(session):\\n \\n for query in create_table_queries:\\n try:\\n session.execute(query)\\n except Exception as e:\\n print(e)\",\n \"def create_tables() -> None:\\n print(\\\"Creating database tables using SQLAlchemy ORM\\\")\\n Base.metadata.create_all(engine)\\n print(\\\"Done creating tables\\\")\",\n \"def create_all_tables(self):\\n pass\",\n \"def create_tables():\\n db.create_all()\",\n \"def create_tables(session):\\n for query in create_table_queries:\\n session.execute(query)\",\n \"def create_tables(cur, conn):\\n \\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\\n \\n print('Tables created.')\",\n \"def create_tables_and_apply_patches(self):\\n\\n if self.authorized and not self.db_tables_initiated:\\n with self.connection.cursor() as cursor:\\n for statement in self.parse_mysql_sql_file():\\n cursor.execute(statement)\\n\\n PyFunceble.LOGGER.info(\\n \\\"Created the missing tables. Applied all patched\\\"\\n )\\n\\n self.db_tables_initiated = True\",\n \"def create_db_tables():\\n\\n try:\\n webapp.dbsql.create_all()\\n webapp.dbsql.session.commit()\\n except Exception as e:\\n # TODO: melhorar o informe do erro\\n raise e\",\n \"def init_tables(self) -> None:\\n # TODO(#93) maybe raise flag when the schema of existing tables isn't what we expect\\n # it to be?\\n # \\\"How to know that schema changes?\\\"\\n # logger.warning(\\\"some message\\\")\\n with self.table_access_condition:\\n conn = self._get_connection()\\n conn.execute(\\\"PRAGMA foreign_keys = 1\\\")\\n with conn:\\n c = conn.cursor()\\n c.execute(CREATE_PROJECTS_TABLE)\\n c.execute(CREATE_TASKS_TABLE)\\n c.execute(CREATE_REQUESTERS_TABLE)\\n c.execute(CREATE_TASK_RUNS_TABLE)\\n c.execute(CREATE_ASSIGNMENTS_TABLE)\\n c.execute(CREATE_UNITS_TABLE)\\n c.execute(CREATE_WORKERS_TABLE)\\n c.execute(CREATE_AGENTS_TABLE)\\n c.execute(CREATE_QUALIFICATIONS_TABLE)\\n c.execute(CREATE_GRANTED_QUALIFICATIONS_TABLE)\\n c.execute(CREATE_ONBOARDING_AGENTS_TABLE)\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n try:\\n cur.execute(query)\\n conn.commit()\\n except Exception as e:\\n print(e)\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn) -> None:\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(session):\\n\\n for query in create_table_queries:\\n session.execute(query)\",\n \"def create_tables(cur, conn): \\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n cur.execute(query)\\n conn.commit()\\n print(f\\\"\\\\nRunning: {query}\\\")\",\n \"def create_tables (cls, env=os.environ):\\n\\n cur = cls.pri_table_read_cursor (env=env)\\n cur.execute ('SPECIALCASE gettablelist')\\n ret = cur.fetchall ()\\n \\n existingtables = set ([x[0].lower() for x in ret])\\n\\n for tabname in (set (cls.table_desc.keys ()) - existingtables):\\n sql, lsd = cls.table_desc[tabname]\\n epls, desls, sqlprefix = lsd.get_create_labeling (savels=True)\\n\\n conn = get_labeled_conn (epls, desls)\\n cur = conn.cursor ()\\n cur.execute (sql)\\n conn.close ()\\n lsd.pop_labelset ()\\n\\n \\n import psycopg2\\n for sql in cls.sql_createindex:\\n conn = get_labeled_conn ()\\n cur = conn.cursor ()\\n # XXX It would be better to check which indices exist as we do for tables.\\n try:\\n cur.execute (sql)\\n except psycopg2.ProgrammingError, e: \\n pass\\n conn.close ()\",\n \"def create_tables(self, script):\\n for query in script:\\n try:\\n self.cursor.execute(query)\\n except:\\n print(\\\"\\\\n Une erreur s'est produite lors \\\"\\n \\\"de la création des tables \\\\n\\\")\\n print(\\\"\\\\n Les tables ont bien été créées \\\"\\n f\\\"dans la base de données |{DB_NAME}| \\\\n\\\")\",\n \"def create_tables():\\n # Depending on your local settings, you may need to specify a user and password, e.g.\\n # conn = psycopg2.connect(dbname=DBNAME, user=\\\"postgres\\\", password=\\\"password\\\")\\n conn = psycopg2.connect(dbname=DBNAME)\\n\\n create_train_table(conn)\\n create_questions_table(conn)\\n create_lectures_table(conn)\\n create_example_test_table(conn)\\n create_example_test_table(conn)\\n\\n conn.close()\",\n \"def create_tables(cur, conn):\\n for query in create_table_queries:\\n try:\\n cur.execute(query)\\n conn.commit()\\n except psycopg2.Error as e:\\n print(\\\"Error: Could not create table from query: {}\\\".format(query))\\n print(e)\",\n \"def create_tables(self, conn, cur, *sql_queries):\\n check_creation_tables = []\\n\\n for query in sql_queries:\\n try:\\n cur.execute(query)\\n except Exception as e:\\n self.logger.error(f\\\"{type(e).__name__}: {e}\\\")\\n conn.rollback()\\n cur.execute(f\\\"DROP TABLE IF EXISTS {self.tables[0]} CASCADE\\\")\\n else:\\n conn.commit() \\n for name in self.table_names: \\n cur.execute(\\\"SELECT COUNT(*) FROM information_schema.tables \\\" \\\\\\n \\\"WHERE table_schema='public';\\\")\\n check_creation_tables = cur.fetchone()[0]\\n \\n cur.close()\\n \\n check_creation_tables = True if check_creation_tables == 2 else False\\n \\n return check_creation_tables\",\n \"def createDbTables():\\n logger.info(\\\"creating required DB table if it does not already exist\\\")\\n try:\\n with db.connect() as conn:\\n conn.execute(\\n \\\"CREATE TABLE IF NOT EXISTS birthdays \\\"\\n \\\"( username VARCHAR(255) NOT NULL, birthday DATE NOT NULL, \\\"\\n \\\"PRIMARY KEY (username) );\\\"\\n )\\n return OK\\n except Exception as e:\\n logger.info(\\\"Error creating table: %s\\\" % e)\\n return ERR\",\n \"async def create_tables():\\n text_create_citizens_table = queries.CREATE_CITIZENS\\n text_create_relative_table = queries.CREATE_RELATIVES\\n text_create_consts_table = queries.CREATE_CONSTS\\n text_insert_base_import_id = queries.INSERT_IMPORT_ID_0\\n text_create_index_citizens = queries.CREATE_INDEX_CITIZENS\\n text_create_index_relatives = queries.CREATE_INDEX_RELATIVES\\n\\n queries_list = [text_create_citizens_table, text_create_relative_table,\\n text_create_consts_table, text_insert_base_import_id,\\n text_create_index_citizens,text_create_index_relatives]\\n\\n connection = await sql.connect()\\n async with connection.transaction():\\n for query in queries_list:\\n await sql.execute_query(connection, query)\\n await sql.close(connection)\",\n \"def _create_tables():\\n from Model.DataAccessor.DbAccessor.DbOrmAccessor import db\\n db.create_tables([SubjectType, SubjectRegion, Subject])\",\n \"def imp_create_tables():\\n config = configparser.ConfigParser()\\n config.read('dwh.cfg')\\n\\n conn = psycopg2.connect(\\\"host={} dbname={} user={} password={} port={}\\\".format(*config['CLUSTER'].values()))\\n cur = conn.cursor()\\n \\n # Drop the tables (uncomment if necessary)\\n #drop_tables(cur, conn)\\n\\n # Create the tables\\n create_tables(cur, conn)\\n\\n conn.close()\",\n \"def check_and_create_table(self) -> None:\\n table_ids = [t.table_id for t in self.instance.list_tables()]\\n\\n if not self.table_id in table_ids:\\n self.table.create()\\n f = self.table.column_family(self.family_id)\\n f.create()\\n\\n f_inc = self.table.column_family(self.incrementer_family_id,\\n gc_rule=MaxVersionsGCRule(1))\\n f_inc.create()\\n\\n f_log = self.table.column_family(self.log_family_id)\\n f_log.create()\\n\\n f_ce = self.table.column_family(self.cross_edge_family_id,\\n gc_rule=MaxVersionsGCRule(1))\\n f_ce.create()\\n\\n print(\\\"Table created\\\")\",\n \"def create_database_tables():\\n with APP.app_context():\\n DB.create_all()\",\n \"def _init_db(self):\\n cursor = self._main_connection.cursor()\\n cursor.execute(self.sql[\\\"create_table\\\"])\\n self._main_connection.commit()\",\n \"def create_tables (self):\\n cursor = self.cur()\\n cursor.execute('DROP TABLE IF EXISTS person')\\n cursor.execute('DROP TABLE IF EXISTS room')\\n cursor.execute('DROP TABLE IF EXISTS allocation')\\n cursor.execute(\\n 'CREATE TABLE IF NOT EXISTS person (person_id INTEGER PRIMARY KEY, name TEXT, role TEXT)WITHOUT ROWID')\\n cursor.execute(\\n 'CREATE TABLE IF NOT EXISTS room (name TEXT , no_of_members INTEGER, room_type TEXT)')\\n cursor.execute(\\n 'CREATE TABLE IF NOT EXISTS allocation (room_name TEXT , person_id INTEGER)')\",\n \"def create_tables(self):\\n if not self.is_enabled(Subsystem.database):\\n raise RuntimeError(\\\"Database subsystem was not enabled\\\")\\n\\n Base.metadata.create_all(self.engine)\",\n \"def createTables ( c ) :\\n assert str(type(c)) == \\\"<type '_mysql.connection'>\\\"\\n sqlQuery ( c, \\\"drop table if exists Crises;\\\" )\\n sqlQuery ( c, \\\"drop table if exists Organizations;\\\" )\\n sqlQuery ( c, \\\"drop table if exists People;\\\" )\\n sqlQuery ( c, \\\"drop table if exists CrisisLocations;\\\" )\\n sqlQuery ( c, \\\"drop table if exists PeopleLocations;\\\" )\\n sqlQuery ( c, \\\"drop table if exists OrganizationLocations;\\\" )\\n sqlQuery ( c, \\\"drop table if exists HumanImpact;\\\" )\\n sqlQuery ( c, \\\"drop table if exists ResourceNeeded;\\\" )\\n sqlQuery ( c, \\\"drop table if exists WaysToHelp;\\\" )\\n sqlQuery ( c, \\\"drop table if exists PersonExternalResources;\\\" )\\n sqlQuery ( c, \\\"drop table if exists OrganizationExternalResources;\\\" )\\n sqlQuery ( c, \\\"drop table if exists CrisisExternalResources;\\\" )\\n sqlQuery ( c, \\\"drop table if exists PeopleToOrganizations;\\\" )\\n sqlQuery ( c, \\\"drop table if exists OrganizationsToCrises;\\\" )\\n sqlQuery ( c, \\\"drop table if exists CrisesToPeople;\\\" )\\n sqlQuery ( c, \\\"drop table if exists OrganizationKind;\\\" )\\n sqlQuery ( c, \\\"drop table if exists PersonKind;\\\" )\\n sqlQuery ( c, \\\"drop table if exists CrisisKind;\\\" )\\n \\n sqlQuery ( c, \\\"create table Crises ( crisisID text, name text, crisisKindID text, startDate date, startTime time, endDate date, endTime time, economicImpact text );\\\" )\\n sqlQuery ( c, \\\"create table Organizations ( orgID text, name text, orgKindID text, history text, phone bigint, fax bigint, email text, address text, locality text, region text, postalCode text, country text );\\\" )\\n sqlQuery ( c, \\\"create table People ( personID text, firstName text, middleName text, lastName text, suffix text, personKindID text );\\\" )\\n sqlQuery ( c, \\\"create table CrisisLocations ( crisisID text, locality text, region text, country text );\\\" )\\n sqlQuery ( c, \\\"create table PeopleLocations ( personID text, locality text, region text, country text );\\\" )\\n sqlQuery ( c, \\\"create table OrganizationLocations ( orgID text, locality text, region text, country text );\\\" )\\n sqlQuery ( c, \\\"create table HumanImpact ( crisisID text, type text, number int );\\\" )\\n sqlQuery ( c, \\\"create table ResourceNeeded ( crisisID text, resource text );\\\" )\\n sqlQuery ( c, \\\"create table WaysToHelp ( crisisID text, helpType text );\\\" )\\n sqlQuery ( c, \\\"create table PersonExternalResources ( personID text, type text, url text );\\\" )\\n sqlQuery ( c, \\\"create table OrganizationExternalResources ( orgID text, type text, url text );\\\" )\\n sqlQuery ( c, \\\"create table CrisisExternalResources ( crisisID text, type text, url text );\\\" )\\n sqlQuery ( c, \\\"create table PeopleToOrganizations ( personID text, orgID text );\\\" )\\n sqlQuery ( c, \\\"create table OrganizationsToCrises ( orgID text, crisisID text );\\\" )\\n sqlQuery ( c, \\\"create table CrisesToPeople ( crisisID text, personID text );\\\" )\\n sqlQuery ( c, \\\"create table OrganizationKind ( orgKindID text, name text, description text );\\\" )\\n sqlQuery ( c, \\\"create table PersonKind ( personKindID text, name text, description text );\\\" )\\n sqlQuery ( c, \\\"create table CrisisKind ( crisisKindID text, name text, description text );\\\" )\\n sqlQuery ( c, \\\"show tables;\\\" )\",\n \"def setup_tables(self):\\n try:\\n self.cursor.execute('CREATE SCHEMA sandbox')\\n self.cursor.execute(\\\"DROP TABLE sandbox.dvds_rdbhdb_super;\\\")\\n except (db.ProgrammingError, db.OperationalError), e:\\n # sandbox may not exist\\n pass #raise\\n\\n try:\\n self.cursor.execute(\\n \\\"\\\"\\\"CREATE TABLE sandbox.dvds_rdbhdb_super(\\n id SERIAL PRIMARY KEY,\\n name varchar(40) NOT NULL,\\n rating float,\\n UNIQUE(name)\\n );\\n \\\"\\\"\\\" )\\n except db.ProgrammingError, e:\\n if e[0] != '42P07':\\n raise\",\n \"def test_create_tables_cmd_success(self):\\n self.runner.invoke(cli,\\n args=['create-tables'],\\n env={'OS_ELASTICSEARCH_ADDRESS': LOCAL_ELASTICSEARCH})\\n engine = config.get_engine()\\n inspector = Inspector.from_engine(engine)\\n self.assertTrue('models' not in inspector.get_table_names())\",\n \"def __new_tables_statement(self):\\n new_tables = self.__new_tables()\\n for table in new_tables:\\n with open('./update/create_tables.sql', 'a') as f:\\n create_statement = self.source.query_create_table_statement(table.name)\\n f.write(create_statement)\\n f.write('\\\\n')\",\n \"def create_tables(self, tables=None):\\n LOG.debug(f\\\"Creating table subset {tables}\\\")\\n Base.metadata.create_all(self.engine, tables, checkfirst=False)\",\n \"def _do_action_tables_create(self):\\n\\n schema_shell = os.path.join(self.bento_home, \\\"schema-shell\\\", \\\"bin\\\", \\\"kiji-schema-shell\\\")\\n assert os.path.isfile(schema_shell), schema_shell\\n\\n # Delete the table first!\\n cmd = (\\n \\\"kiji delete --target={kiji_uri} --interactive=false; \\\" +\\n \\\"kiji install --kiji={kiji_uri}\\\" ).format(kiji_uri=self.kiji_uri)\\n self._run_kiji_job(cmd)\\n\\n for ddl in self.ddls:\\n ddl_full_path = os.path.join(self.movie_advisor_home, ddl)\\n assert os.path.isfile(ddl_full_path)\\n cmd = \\\"{schema_shell} --kiji={kiji_uri} --file={ddl_full_path}\\\".format(\\n schema_shell=schema_shell,\\n kiji_uri=self.kiji_uri,\\n ddl_full_path=ddl_full_path)\\n self._run_kiji_job(cmd)\",\n \"def test_db_schema(client):\\n table_names = [\\\"user\\\", \\\"house\\\", \\\"user_role\\\", \\\"model_param\\\"]\\n with db.engine.connect() as connexion:\\n for table_name in table_names:\\n assert db.engine.dialect.has_table(connexion, table_name) == True\",\n \"def createTables(self):\\n metadata = Base.metadata\\n metadata.create_all(self._engine)\\n return\",\n \"def init_tables(self):\\n\\n settings.Base.metadata.tables[\\n 'session_master'].drop(bind=settings.engine)\\n settings.Base.metadata.tables['uurl'].drop(bind=settings.engine)\\n\\n settings.Base.metadata.tables[\\n 'session_master'].create(bind=settings.engine)\\n settings.Base.metadata.tables['uurl'].create(bind=settings.engine)\\n\\n logging.info(\\\"Sessionization Tables created\\\")\",\n \"def create_db_execute(self):\\n self.execute(query=self.db_create_schema.format(self.db_name))\",\n \"def create_tables():\\n inf(\\\"Creating tables\\\")\\n \\n pinners = Table('pinners', metadata,\\n Column('pinner_id', Integer, primary_key=True),\\n Column('name', String(40)),\\n Column('email', String(40))\\n )\\n pinners.create()\\n \\n contents = Table('contents', metadata,\\n Column('content_id', Integer, primary_key=True),\\n Column('url', String(80)),\\n Column('display_status', String(20)), # good, objectionable, copyright\\n Column('pinner_id', Integer, ForeignKey('pinners.pinner_id'))\\n )\\n contents.create()\\n\\n reviewers = Table('reviewers', metadata,\\n Column('reviewer_id', Integer, primary_key=True),\\n Column('name', String(40)),\\n Column('email', String(40))\\n )\\n reviewers.create()\\n\\n complaints = Table('complaints', metadata,\\n Column('complaint_id', Integer, primary_key=True),\\n Column('complaint_timestamp', DateTime), # when the complaint was filed\\n Column('complaint_type', String(80)), # objectionable, copyright\\n Column('process_status', String(20)), # complaint, review, done\\n Column('display_status', String(20)), # good, objectionable, copyright\\n Column('review_timestamp', DateTime), # when the compliant was resolved\\n Column('pinner_id', Integer, ForeignKey('pinners.pinner_id')),\\n Column('reviewer_id', Integer, ForeignKey('reviewers.reviewer_id')),\\n Column('content_id', Integer, ForeignKey('contents.content_id'))\\n )\\n complaints.create()\\n \\n # could create a table of \\\"near by\\\" images and/or near by features and \\n # include these in the review\",\n \"def create_tables(engine):\\n BASE.metadata.create_all(engine)\",\n \"def create_tables(self):\\n if self.mock:\\n mock_dynamodb2(self._create_tables())\\n else:\\n self._create_tables()\",\n \"def create_tables(c, drop_all = False):\\n\\tprint \\\"create_tables [status]: create tables triggered.\\\"\\n\\tautoincrement = \\\" autoincrement\\\"\\n\\tglobal Options, Database\\n\\tif drop_all:\\n\\t\\tprint \\\"create_tables [status]: dropping tables initiated.\\\"\\n\\t\\tif Database.type == DatabaseTypes.SQLITE:\\n\\t\\t\\tdrop_sql = open(mk_drop(\\\"sqlite\\\")).read()\\n\\t\\telif Database.type == DatabaseTypes.MYSQL:\\n\\t\\t\\tdrop_sql = open(mk_drop(\\\"mysql\\\")).read()\\n\\t\\telif Database.type == DatabaseTypes.POSTGRES:\\n\\t\\t\\tdrop_sql = open(mk_drop(\\\"postgres\\\")).read()\\n\\t\\tdrop_list = drop_sql.split(\\\";\\\")\\n\\t\\tfor line in drop_list:\\n\\t\\t\\tquery = line.strip()\\n\\t\\t\\tif query:\\n\\t\\t\\t\\tc.execute(line)\\n\\t\\tprint \\\"create_tables [status]: dropping tables complete.\\\"\\n\\tif Database.type == DatabaseTypes.SQLITE:\\n\\t\\tdbf = open(mk_schema(\\\"sqlite\\\", Options.use_dict))\\n\\t\\tquery_list = dbf.read()\\n\\t\\tc.executescript(query_list)\\n\\telif Database.type == DatabaseTypes.MYSQL:\\n\\t\\tdbf = open(mk_schema(\\\"mysql\\\", Options.use_dict))\\n\\t\\texecutescript(c, dbf)\\n\\telif Database.type == DatabaseTypes.POSTGRES:\\n\\t\\tdbf = open(mk_schema(\\\"postgres\\\", Options.use_dict))\\n\\t\\texecutescript(c, dbf)\",\n \"def CheckTables():\\n cursor.execute(\\\"SELECT name FROM sqlite_master WHERE type='table'\\\")\\n tables = [row[0] for row in cursor.fetchall()]\\n if not tables or not \\\"master\\\" in tables:\\n cursor.execute('''CREATE TABLE master (\\n hit TEXT,\\n logfile TEXT,\\n count INTEGER,\\n date TEXT)''')\\n con.commit()\\n if not tables or not \\\"rotate\\\" in tables:\\n cursor.execute('''CREATE TABLE rotate (\\n logfile TEXT,\\n hash TEXT,\\n date TEXT)''')\\n con.commit()\",\n \"def create_table(create_table_sql):\\n conn = DbUtil.connection\\n try:\\n c = conn.cursor()\\n c.execute(create_table_sql)\\n except Error as e:\\n print(e)\",\n \"def create_database():\\n with connection:\\n connection.execute(CREATE_MOVIE_TABLE)\\n connection.execute(CREATE_USER_TABLE)\\n connection.execute(CREATE_WATCHED_TABLE)\",\n \"def create_fact_tables(cur,conn):\\n\\tfor query in create_fact_queries:\\n\\t\\tcur.execute(query)\\n\\t\\tconn.commit()\",\n \"def test_create_tables(self):\\n conn_object = ParentConnection()\\n conn_object.create_tables()\\n conn = psycopg2.connect(**{\\\"host\\\": \\\"localhost\\\",\\n \\\"database\\\": \\\"test\\\",\\n \\\"user\\\": \\\"test\\\",\\n \\\"password\\\": \\\"test\\\"})\\n cur = conn.cursor()\\n cur.execute(\\\"SELECT * from information_schema.tables \\\"\\n \\\"WHERE table_schema = 'public' \\\"\\n \\\"AND table_type = 'BASE TABLE';\\\")\\n result = cur.fetchall()\\n result = [x[2] for x in result]\\n self.assertCountEqual(result,\\n ['bioms', 'counts', 'networks',\\n 'taxonomy', 'edges', 'samples', 'meta']\\n )\\n cur.close()\\n conn.close()\\n conn_object.delete_tables()\",\n \"def clean_up():\\n drop_all_tables()\\n create_all()\",\n \"def _create_tables_classic(self, engine, metadata):\\n if engine and metadata:\\n with (yield from engine) as conn:\\n for x in self._models.values():\\n try:\\n yield from conn.execute(CreateTable(x))\\n except ProgrammingError as error:\\n if hasattr(self.app, 'log') and self.app.log:\\n if self.app.debug:\\n self.app.log.info(\\\"[PostgressPlugin] [ `{}` already exists]\\\".format(x))\\n else:\\n if self.app.debug:\\n print(\\\"[PostgressPlugin] [ `{}` already exists]\\\".format(x))\\n return\",\n \"def init_tables(database_url, _metadata, checkfirst=True):\\n import dpds.storages.db.tables.operations\\n import dpds.storages.db.tables.block\\n import dpds.storages.db.tables.meta\\n with isolated_nullpool_engine(database_url) as engine:\\n _metadata.create_all(bind=engine, checkfirst=checkfirst)\",\n \"def create_table(self, create_table_sql):\\n connection = self.__create_connection()\\n try:\\n c = connection.cursor()\\n c.execute(create_table_sql)\\n except Error as e:\\n print(e)\",\n \"def create_tables(self):\\n for name, attribute in self.__dict__.items():\\n if hasattr(attribute, 'create_table_in_sqlite_db'):\\n attribute.create_table_in_sqlite_db()\",\n \"def check_db_schema(self):\\n if not self.db.get_tables():\\n self.create_db_schema()\",\n \"def _create_table(self) :\\n\\n cur = self.con.cursor()\\n delete_sql = 'DROP TABLE IF EXISTS \\\"%s\\\"' % self.name\\n cur.execute(delete_sql)\\n\\n col_sql = ','.join(['\\\"%s\\\" %s' % (self.cols[i], self.types[i])\\n for i in range(len(self.cols))])\\n create_sql = 'CREATE TABLE \\\"%s\\\" ( %s );' % (self.name, col_sql)\\n cur.execute(create_sql)\",\n \"def _ensure_tables(self, db):\\n\\n # NOTE(kgriffs): Create tables all together rather\\n # than separately in each controller, since some queries\\n # in the individual controllers actually require the\\n # presence of more than one table.\\n\\n # NOTE(flaper87): Consider moving tables definition\\n # outside this method.\\n\\n db.execute('''\\n create table\\n if not exists\\n Messages (\\n id INTEGER,\\n qid INTEGER,\\n ttl INTEGER,\\n content DOCUMENT,\\n client UUID,\\n created DATETIME, -- seconds since the Julian day\\n PRIMARY KEY(id),\\n FOREIGN KEY(qid) references Queues(id) on delete cascade\\n )\\n ''')\\n\\n db.execute('''\\n create table\\n if not exists\\n Queues (\\n id INTEGER,\\n project TEXT,\\n name TEXT,\\n metadata DOCUMENT,\\n PRIMARY KEY(id),\\n UNIQUE(project, name)\\n )\\n ''')\\n\\n db.execute('''\\n create table\\n if not exists\\n Claims (\\n id INTEGER PRIMARY KEY AUTOINCREMENT,\\n qid INTEGER,\\n ttl INTEGER,\\n created DATETIME, -- seconds since the Julian day\\n FOREIGN KEY(qid) references Queues(id) on delete cascade\\n )\\n ''')\\n\\n db.execute('''\\n create table\\n if not exists\\n Locked (\\n cid INTEGER,\\n msgid INTEGER,\\n FOREIGN KEY(cid) references Claims(id) on delete cascade,\\n FOREIGN KEY(msgid) references Messages(id) on delete cascade\\n )\\n ''')\",\n \"def createTable(self):\\n results = self.db.table_create(self.entity).run(self.r)\\n time.sleep(5)\\n return results\",\n \"def create_tables(): \\n \\n pk_contraint = \\\"CONSTRAINT {}_pk PRIMARY KEY ({})\\\"\\n uq_contraint = \\\"CONSTRAINT {}_uq UNIQUE ({})\\\"\\n fk_query = \\\"\\\"\\\"CONSTRAINT {}_fk_{} \\n FOREIGN KEY ({}) \\n REFERENCES {}({}) \\n ON UPDATE CASCADE \\n ON DELETE RESTRICT\\n \\\"\\\"\\\"\\n \\n create_dict = {}\\n index = 1\\n\\n\\n ############################## public SCHEMA ##############################\\n \\n schema = 'public'\\n create_schema(schema)\\n\\n #################### site ####################\\n table_name = 'site'\\n pk_id = 'site_id'\\n uq_list = ['site_code']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_code CHAR(3),\\n purok VARCHAR,\\n sitio VARCHAR,\\n barangay VARCHAR,\\n municipality VARCHAR,\\n province VARCHAR,\\n region VARCHAR,\\n psgc INTEGER,\\n active BOOLEAN NOT NULL DEFAULT TRUE,\\n season SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n\\n ############################## spatial SCHEMA ##############################\\n \\n schema = 'spatial'\\n create_schema(schema)\\n \\n #################### exposure ####################\\n table_name = 'exposure'\\n pk_id = 'exp_id'\\n uq_list = ['exp_name']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n exp_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n \\n #################### site_exposure ####################\\n table_name = 'site_exposure'\\n pk_id = 'se_id'\\n uq_list = ['site_id', 'exp_id', 'geom']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\\n 'exp_id': {'ref_schema': 'spatial', 'ref_table': 'exposure'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n exp_id INTEGER,\\n label_name VARCHAR,\\n geom GEOMETRY,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n deactivated DATE,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n \\n #################### feature ####################\\n table_name = 'feature'\\n pk_id = 'feat_id'\\n uq_list = ['feat_name']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n feat_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### site_feature ####################\\n table_name = 'site_feature'\\n pk_id = 'sf_id'\\n uq_list = ['site_id', 'feat_id', 'geom']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\\n 'feat_id': {'ref_schema': 'spatial', 'ref_table': 'feature'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n feat_id INTEGER,\\n geom GEOMETRY,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n deactivated DATE,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### hazard_zone ####################\\n table_name = 'hazard_zone'\\n pk_id = 'hz_id'\\n uq_list = ['site_id, geom']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n geom GEOMETRY,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n deactivated DATE,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### monitoring ####################\\n table_name = 'monitoring'\\n pk_id = 'mon_id'\\n uq_list = ['mon_name']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n mon_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### site_monitoring ####################\\n table_name = 'site_monitoring'\\n pk_id = 'sm_id'\\n uq_list = ['site_id', 'mon_id', 'geom']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'},\\n 'mon_id': {'ref_schema': 'spatial', 'ref_table': 'monitoring'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n mon_id INTEGER,\\n label_name VARCHAR,\\n geom GEOMETRY,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n deactivated DATE,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n\\n ############################### comm SCHEMA ###############################\\n \\n schema = 'comm'\\n create_schema(schema)\\n\\n #################### gsm_server ####################\\n table_name = 'gsm_server'\\n pk_id = 'server_id'\\n uq_list = ['server_name']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n server_name VARCHAR,\\n platform_type VARCHAR,\\n version SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### server_port ####################\\n table_name = 'server_port'\\n pk_id = 'port_id'\\n uq_list = ['server_id', 'port']\\n fk_dict = {'server_id': {'ref_schema': 'comm', 'ref_table': 'gsm_server'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n server_id INTEGER,\\n port BOOLEAN,\\n ser_port VARCHAR,\\n pwr_on_pin SMALLINT,\\n ring_pin SMALLINT,\\n module_type SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n query += \\\"\\\"\\\" COMMENT ON TABLE {}.{} IS \\n '0- left\\n 1- right'\\n ;\\\"\\\"\\\".format(schema, table_name)\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### network_type ####################\\n table_name = 'network_type'\\n pk_id = 'prefix'\\n uq_list = ['prefix']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} VARCHAR(3), \\n carrier SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n query += \\\"\\\"\\\" COMMENT ON TABLE {}.{} IS \\n '1- globe\\n 2- smart\\n 3- landline'\\n ;\\\"\\\"\\\".format(schema, table_name)\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### gsm_module ####################\\n table_name = 'gsm_module'\\n pk_id = 'gsm_id'\\n uq_list = ['prefix', 'num', 'activated']\\n fk_dict = {'prefix': {'ref_schema': 'comm', 'ref_table': 'network_type'},\\n 'port_id': {'ref_schema': 'comm', 'ref_table': 'server_port'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n prefix VARCHAR(3),\\n num CHAR(7),\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n port_id INTEGER,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n\\n ############################# temporal SCHEMA #############################\\n \\n schema = 'temporal'\\n create_schema(schema)\\n\\n #################### marker_observation ####################\\n table_name = 'marker_observation'\\n pk_id = 'mo_id'\\n uq_list = ['site_id', 'ts']\\n fk_dict = {'site_id': {'ref_schema': 'public', 'ref_table': 'site'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n site_id INTEGER,\\n ts TIMESTAMP,\\n meas_type VARCHAR(7),\\n weather VARCHAR,\\n observer_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### marker_history ####################\\n table_name = 'marker_history'\\n pk_id = 'hist_id'\\n uq_list = ['sm_id', 'ts', 'event']\\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL,\\n sm_id BIGINT,\\n ts TIMESTAMP,\\n event BOOLEAN,\\n label_name VARCHAR,\\n {}, {} {}\\n );\\n \\\"\\\"\\\"\\n query += \\\"\\\"\\\" COMMENT ON TABLE {}.{} IS \\n '0- rename\\n 1- reposition'\\n ;\\\"\\\"\\\".format(schema, table_name)\\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### marker_data ####################\\n table_name = 'marker_data'\\n pk_id = 'data_id'\\n uq_list = ['sm_id', 'mo_id']\\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'},\\n 'mo_id': {'ref_schema': 'temporal', 'ref_table': 'marker_observation'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL,\\n mo_id BIGINT,\\n sm_id BIGINT,\\n measurement NUMERIC(5,1),\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### marker_alert ####################\\n table_name = 'marker_alert'\\n pk_id = 'alert_id'\\n uq_list = ['data_id']\\n fk_dict = {'data_id': {'ref_schema': 'temporal', 'ref_table': 'marker_data'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL,\\n data_id BIGINT,\\n displacement NUMERIC(4,1),\\n time_delta FLOAT,\\n alert_level SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### logger_model ####################\\n table_name = 'logger_model'\\n pk_id = 'model_id'\\n uq_list = ['has_tilt', 'has_rain', 'has_piezo', 'has_soms', 'logger_type']\\n fk_dict = {}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n has_tilt BOOLEAN,\\n has_rain BOOLEAN,\\n has_piezo BOOLEAN,\\n has_soms BOOLEAN,\\n logger_type SMALLINT,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n #################### logger ####################\\n table_name = 'logger'\\n pk_id = 'logger_id'\\n uq_list = ['sm_id']\\n fk_dict = {'sm_id': {'ref_schema': 'spatial', 'ref_table': 'site_monitoring'},\\n 'model_id': {'ref_schema': 'temporal', 'ref_table': 'logger_model'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL, \\n sm_id BIGINT,\\n model_id INTEGER,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n \\n #################### logger_mobile ####################\\n table_name = 'logger_mobile'\\n pk_id = 'mobile_id'\\n uq_list = ['logger_id', 'activated']\\n fk_dict = {'logger_id': {'ref_schema': 'temporal', 'ref_table': 'logger'},\\n 'gsm_id': {'ref_schema': 'comm', 'ref_table': 'gsm_module'}}\\n query = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS {}.{} (\\n {} SERIAL,\\n logger_id INTEGER,\\n activated DATE NOT NULL DEFAULT CURRENT_DATE,\\n sim_num VARCHAR(12),\\n gsm_id INTEGER,\\n {}, {} {}\\n );\\n \\\"\\\"\\\" \\n create_dict[index] = {'schema': schema,\\n 'table_name': table_name,\\n 'query': query,\\n 'pk_id': pk_id,\\n 'uq_list': uq_list,\\n 'fk_dict': fk_dict}\\n index += 1\\n\\n\\n #################### EXECUTE QUERY TO CREATE TABLES ####################\\n for index in create_dict.keys():\\n dct = create_dict[index]\\n schema = dct['schema']\\n table_name = dct['table_name']\\n query = dct['query']\\n pk_id = dct['pk_id']\\n uq_list = dct['uq_list']\\n fk_dict = dct['fk_dict']\\n if len(fk_dict.keys()) == 0:\\n fk_constraint = ''\\n else:\\n fk_constraint_list = ['']\\n for fk_id in fk_dict.keys():\\n ref_schema = fk_dict.get(fk_id)['ref_schema']\\n ref_table = fk_dict.get(fk_id)['ref_table']\\n fk_part = fk_query.format(table_name, ref_table, fk_id,\\n \\\"{}.{}\\\".format(ref_schema, ref_table),\\n fk_id)\\n fk_constraint_list.append(fk_part)\\n fk_constraint = ', '.join(fk_constraint_list)\\n \\n query = query.format(schema, table_name, pk_id, \\n pk_contraint.format(table_name, pk_id),\\n uq_contraint.format(table_name, ', '.join(uq_list)),\\n \\\"{}\\\".format(fk_constraint))\\n qdb.execute(query)\",\n \"async def _create_tables_declarative(self, base, engine):\\n if hasattr(base, 'metadata'):\\n base.metadata.create_all(bind=engine, checkfirst=True)\\n return\",\n \"def create_tables(cursor):\\n cursor.execute(\\\"\\\"\\\"\\n CREATE TABLE users(\\n userid INTEGER PRIMARY KEY,\\n username TEXT NOT NULL,\\n password TEXT NOT NULL,\\n email TEXT NOT NULL\\n );\\n \\\"\\\"\\\")\\n cursor.execute(\\\"\\\"\\\"\\n CREATE TABLE groups(\\n groupid INTEGER PRIMARY KEY,\\n name TEXT NOT NULL\\n );\\n \\\"\\\"\\\")\\n cursor.execute(\\\"\\\"\\\"\\n CREATE TABLE usergroups(\\n userid INTEGER,\\n groupid INTEGER,\\n PRIMARY KEY (userid, groupid)\\n FOREIGN KEY (userid) REFERENCES users (userid)\\n ON DELETE CASCADE ON UPDATE NO ACTION\\n FOREIGN KEY (groupid) REFERENCES groups (groupid)\\n ON DELETE CASCADE ON UPDATE NO ACTION\\n );\\n \\\"\\\"\\\")\\n cursor.execute(\\\"\\\"\\\"\\n CREATE TABLE settings(\\n key TEXT PRIMARY KEY,\\n value\\n );\\n \\\"\\\"\\\")\\n cursor.execute(\\\"\\\"\\\"\\n CREATE TABLE sessions(\\n userid INTEGER PRIMARY KEY,\\n key TEXT NOT NULL,\\n started TEXT DEFAULT (datetime('now')),\\n FOREIGN KEY (userid) REFERENCES users (userid)\\n ON DELETE CASCADE ON UPDATE NO ACTION\\n );\\n \\\"\\\"\\\")\\n cursor.execute(\\\"CREATE UNIQUE INDEX idx_groups_name ON groups (name)\\\")\\n cursor.execute(\\n \\\"CREATE UNIQUE INDEX idx_users_username ON users (username)\\\"\\n )\",\n \"def main():\\n print(\\\"Creating tables\\\")\\n config = configparser.ConfigParser()\\n config.read('dwh.cfg')\\n\\n connection_string = get_redshift_connection_string(config=config)\\n conn = psycopg2.connect(connection_string)\\n cur = conn.cursor()\\n\\n drop_tables(cur, conn)\\n create_tables(cur, conn)\\n\\n conn.close()\\n\\n print(\\\"Tables have been successfully created\\\")\",\n \"def setUp(self):\\n db.drop_all() # clean up the last tests\\n db.create_all() # make our sqlalchemy tables\",\n \"def create_table_statements() -> [str]:\\n pass\",\n \"def create_tables(db_engine):\\n\\n with db_engine.connect() as conn:\\n create_table_stmts = []\\n\\n create_drugs_table = \\\"\\\"\\\"\\n DROP TABLE IF EXISTS drugs CASCADE; \\n CREATE TABLE drugs (\\n drugbank_id char(7) PRIMARY KEY,\\n name varchar NOT NULL, -- Something “Human Readable”,\\n smiles varchar\\n );\\n \\\"\\\"\\\"\\n\\n create_table_stmts.append(create_drugs_table)\\n\\n create_drug_id_types_table = \\\"\\\"\\\"\\n DROP TABLE IF EXISTS drug_identifier_types CASCADE; \\n CREATE TABLE drug_identifier_types (\\n identifier_type_id SERIAL UNIQUE, \\n identifier_type_name varchar UNIQUE\\n ); \\n \\\"\\\"\\\"\\n create_table_stmts.append(create_drug_id_types_table)\\n\\n create_drug_identifiers_table = \\\"\\\"\\\"\\n DROP TABLE IF EXISTS drug_identifiers CASCADE;\\n CREATE TABLE drug_identifiers (\\n drugbank_id char(7) references drugs(drugbank_id),\\n alt_identifier_value varchar NOT NULL,\\n alt_identifier_type_id int references drug_identifier_types(identifier_type_id) NOT NULL,\\n alt_identifier_url varchar\\n );\\n \\\"\\\"\\\"\\n create_table_stmts.append(create_drug_identifiers_table)\\n\\n create_drug_action_types = \\\"\\\"\\\"\\n DROP TABLE IF EXISTS drug_action_types CASCADE;\\n CREATE TABLE drug_action_types (\\n action_type_id SERIAL UNIQUE, \\n action_type varchar UNIQUE\\n );\\n \\\"\\\"\\\"\\n create_table_stmts.append(create_drug_action_types)\\n\\n create_drug_targets_table = \\\"\\\"\\\"\\n DROP TABLE IF EXISTS drug_targets CASCADE;\\n CREATE TABLE drug_targets (\\n drugbank_id char(7) references drugs(drugbank_id),\\n gene_name varchar NOT NULL, \\n action_type_id int references drug_action_types(action_type_id),\\n UNIQUE(drugbank_id, gene_name, action_type_id)\\n );\\n \\\"\\\"\\\"\\n create_table_stmts.append(create_drug_targets_table)\\n\\n logger.info(\\\"Creating %d tables\\\", len(create_table_stmts))\\n for stmt in tqdm(create_table_stmts):\\n conn.execute(stmt)\",\n \"def create_tables():\\r\\n db = connect_database()\\r\\n table_wait = \\\"waiting\\\"\\r\\n table_helped = \\\"helped\\\"\\r\\n table_help = \\\"help\\\"\\r\\n param_name = ['cus_num', 'name', 'username', 'ru_id', 'os_platform', 'description']\\r\\n param_type1 = ['INTEGER PRIMARY KEY AUTOINCREMENT', 'TEXT', 'TEXT', 'TEXT', 'TEXT', 'TEXT']\\r\\n param_type2 = ['INTEGER PRIMARY KEY', 'TEXT', 'TEXT', 'TEXT', 'TEXT', 'TEXT']\\r\\n with db:\\r\\n create_table(db, table_wait, param_name, param_type1)\\r\\n create_table(db, table_helped, param_name, param_type2)\\r\\n create_table(db, table_help, param_name, param_type2)\\r\\n db.close()\",\n \"def create_tables(self):\\n users_tb = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS Users(\\n user_id serial PRIMARY KEY,\\n email varchar(30) NOT NULL,\\n username varchar(15) NOT NULL,\\n password varchar(250) NOT NULL,\\n role varchar(10) DEFAULT 'User'\\n );\\\"\\\"\\\"\\n\\n meals_tb = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS Meals(\\n meal_id serial PRIMARY KEY,\\n meal_name varchar(25) NOT NULL,\\n image varchar(150) NOT NULL,\\n description varchar(250) NOT NULL,\\n unit_price decimal(5,2) NOT NULL\\n );\\\"\\\"\\\"\\n\\n orders_tb = \\\"\\\"\\\"CREATE TABLE IF NOT EXISTS Orders(\\n order_id serial PRIMARY KEY,\\n user_id integer NOT NULL,\\n meal_id integer NOT NULL,\\n address varchar(50),\\n quantity int NOT NULL,\\n order_date timestamp NOT NULL,\\n status varchar(15),\\n FOREIGN KEY (user_id) REFERENCES users(user_id)\\n ON DELETE CASCADE ON UPDATE CASCADE,\\n FOREIGN KEY (meal_id) REFERENCES meals(meal_id)\\n ON DELETE CASCADE ON UPDATE CASCADE\\n );\\\"\\\"\\\"\\n return [users_tb, meals_tb, orders_tb]\",\n \"def process(self):\\n try:\\n # self.alter_columns()\\n self.collect_drop_fk()\\n self.update_table()\\n self.create_tables()\\n self.db_operations.create_fk_constraint(self.fk_constraints, self.contraints_columns)\\n return True\\n except Exception as err:\\n logger.error(\\\"create_tables [error] -> %s\\\" % err)\",\n \"def create_db_tables(self):\\n self.releases = Table(\\n RELEASES,\\n self.metadata,\\n Column(\\\"id\\\", Integer, primary_key=True, autoincrement=True),\\n Column(\\\"repo\\\", String),\\n Column(\\\"tag_name\\\", String),\\n Column(\\\"release_name\\\", String),\\n Column(\\\"created\\\", DateTime, default=datetime.datetime.now()),\\n extend_existing=True,\\n )\\n self.commits = Table(\\n COMMITS,\\n self.metadata,\\n Column(\\\"id\\\", Integer, primary_key=True, autoincrement=True),\\n Column(\\\"repo\\\", String),\\n Column(\\\"branch\\\", String),\\n Column(\\\"sha\\\", String),\\n Column(\\\"created\\\", DateTime, default=datetime.datetime.now()),\\n extend_existing=True,\\n )\\n self.tags = Table(\\n TAGS,\\n self.metadata,\\n Column(\\\"id\\\", Integer, primary_key=True, autoincrement=True),\\n Column(\\\"repo\\\", String),\\n Column(\\\"tag_name\\\", String),\\n Column(\\\"sha\\\", String),\\n Column(\\\"created\\\", DateTime, default=datetime.datetime.now()),\\n extend_existing=True,\\n )\\n try:\\n self.metadata.create_all()\\n log.info(\\\"Tables created\\\")\\n except Exception as e:\\n log.error(\\\"Error occurred during Table creation!\\\")\\n log.exception(e)\",\n \"def create_table(self, conn, create_table_sql):\\n try:\\n c = conn.cursor()\\n c.execute(create_table_sql)\\n except Error as e:\\n print(e)\",\n \"def create_tables(self):\\n\\n self.cur.execute('''CREATE TABLE IF NOT EXISTS my_business_entry\\n (\\n id SERIAL PRIMARY KEY,\\n url_yes_no boolean,\\n url TEXT,\\n phone_yes_no boolean,\\n phone TEXT,\\n rating TEXT,\\n nr_of_ratings TEXT,\\n myBusiness boolean,\\n company TEXT\\n );''')\\n\\n self.connection.commit()\",\n \"def create_table(conn, create_table_sql):\\r\\n try:\\r\\n c = conn.cursor()\\r\\n c.execute(create_table_sql)\\r\\n except Error as e:\\r\\n print(e)\",\n \"def _CreateTable(db_conn, create_table_sql):\\r\\n try:\\r\\n c = db_conn.cursor()\\r\\n c.execute(create_table_sql)\\r\\n except Error as e:\\r\\n print(e)\",\n \"def create_table(cursor, TABLES):\\n for t_name,t_desc in TABLES.items():\\n try:\\n print(f\\\"Creating table '{t_name}'...\\\")\\n cursor.execute(t_desc)\\n except mysql.connector.Error as err:\\n if err.errno == errorcode.ER_TABLE_EXISTS_ERROR:\\n print(f\\\"{t_name} already exists, moving on...\\\")\\n pass\\n else:\\n print(err.msg+\\\".\\\")\\n exit(1)\\n else:\\n print(\\\"OK\\\")\\n return None\",\n \"def create_example_test_table(conn):\\n execute_sql_script(conn, \\\"06_create_example_test_table.sql\\\")\",\n \"def refresh_tables(db):\\r\\n try:\\r\\n c = db.cursor()\\r\\n c.execute(\\\"DROP TABLE waiting\\\")\\r\\n c.execute(\\\"DROP TABLE help\\\")\\r\\n c.execute(\\\"DROP TABLE helped\\\")\\r\\n create_tables()\\r\\n except Error as e:\\r\\n print(e)\",\n \"def create_tables(args):\\n\\n from bob.db.base.utils import create_engine_try_nolock\\n\\n engine = create_engine_try_nolock(args.type, args.files[0], echo=(args.verbose >= 2));\\n Client.metadata.create_all(engine)\\n File.metadata.create_all(engine) \\n Annotation.metadata.create_all(engine)\\n #Protocol_File_Association.metadata.create_all(engine)\",\n \"def run():\\r\\n table_names = [\\\"ram\\\", \\\"cpu\\\", \\\"ssd\\\", \\\"gpu\\\"]\\r\\n for table_name in table_names:\\r\\n create_table(table_name)\\r\\n page_data: List[str] = get_page_data(table_name=table_name)\\r\\n processed_data: List[Tuple] = process_page_data(page_data=page_data)\\r\\n insert_data(processed_data, table_name)\\r\\n print(\\\"Complete.\\\")\\r\\n\\r\\n conn.commit()\\r\\n conn.close()\",\n \"def create_table(conn, create_table_sql):\\r\\n try:\\r\\n c = conn.cursor()\\r\\n c.execute(create_table_sql)\\r\\n except Error as e:\\r\\n print(e)\",\n \"def create_tables( self ) :\\n return self._create_tables\",\n \"def init_db():\\n db = get_db()\\n Page.create_table(db)\\n PageVersion.create_table(db)\\n User.create_table(db)\",\n \"def _create_schema(self): \\n q = (\\\"CREATE TABLE IF NOT EXISTS \\\" + \\\\\\n \\\"profiles (username text, body text, epoch numeric)\\\",)\\n for x in q: self.cursor.execute(x)\\n self.conn.commit()\",\n \"def setup(self):\\n #print \\\"Creating test database...\\\"\\n files = glob.glob(os.path.join(self.home_dir, 'sqlFiles', '*.sql'))\\n for fls in files:\\n loc = fls.rfind('/')\\n #print(\\\" \\\" + fls.replace('.sql', '')[loc + 1:])\\n flh = open(fls, 'r')\\n curs = self.cursor()\\n curs.executescript(flh.read())\\n self.commit()\\n curs.close()\\n flh.close()\\n for fls in ['INSERTS', 'TRIGGERS']:\\n #print(fls)\\n flh = open(os.path.join(self.home_dir, 'sqlFiles', fls), 'r')\\n curs = self.cursor()\\n curs.executescript(flh.read())\\n self.commit()\\n curs.close()\\n flh.close()\",\n \"def create_table(conn, create_table_sql):\\r\\n try:\\r\\n c = conn.cursor()\\r\\n c.execute(create_table_sql)\\r\\n conn.commit()\\r\\n except Error as e:\\r\\n print(e)\",\n \"def insert_db():\\n populate_tables()\",\n \"def test_db_table_creation_check(self):\\n mock_cursor = Mock()\\n mock_cursor.configure_mock(**{\\\"cursor.return_value.fetchone.return_value\\\": (\\\"vnf_table_2\\\")})\\n status = misshtbtd.db_table_creation_check(mock_cursor, \\\"vnf_table_2\\\")\\n self.assertEqual(status, True)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8495893","0.7980632","0.7980632","0.7966904","0.79503256","0.7923164","0.7920233","0.7841086","0.78342694","0.7815559","0.77894527","0.77793336","0.77781737","0.7769905","0.77690786","0.77588534","0.77438813","0.77397835","0.77397835","0.77397835","0.77397835","0.77397835","0.77397835","0.77397835","0.77397835","0.77397835","0.77286","0.7725363","0.7708096","0.76638097","0.76549655","0.7571568","0.7548345","0.7545028","0.7496709","0.7467794","0.7425495","0.74154097","0.74044067","0.73942935","0.7349202","0.7331742","0.7307908","0.72730225","0.7255859","0.72448915","0.7206286","0.7193589","0.71935046","0.7187388","0.7153704","0.7133455","0.7130986","0.7115213","0.71122783","0.71119636","0.7104131","0.7066388","0.7038865","0.7038478","0.70381796","0.70280117","0.70273286","0.70221996","0.70215726","0.7012627","0.69984525","0.69903046","0.6989323","0.6979142","0.69748545","0.6959236","0.69504833","0.69498545","0.6949695","0.6940887","0.6932684","0.692657","0.6926379","0.69253623","0.69177115","0.6897311","0.6886651","0.68813664","0.6872944","0.68591845","0.6842985","0.68418527","0.68384916","0.68302685","0.6820417","0.6808301","0.68082523","0.68031543","0.68021065","0.68020207","0.6798108","0.67948985","0.6793053","0.678845"],"string":"[\n \"0.8495893\",\n \"0.7980632\",\n \"0.7980632\",\n \"0.7966904\",\n \"0.79503256\",\n \"0.7923164\",\n \"0.7920233\",\n \"0.7841086\",\n \"0.78342694\",\n \"0.7815559\",\n \"0.77894527\",\n \"0.77793336\",\n \"0.77781737\",\n \"0.7769905\",\n \"0.77690786\",\n \"0.77588534\",\n \"0.77438813\",\n \"0.77397835\",\n \"0.77397835\",\n \"0.77397835\",\n \"0.77397835\",\n \"0.77397835\",\n \"0.77397835\",\n \"0.77397835\",\n \"0.77397835\",\n \"0.77397835\",\n \"0.77286\",\n \"0.7725363\",\n \"0.7708096\",\n \"0.76638097\",\n \"0.76549655\",\n \"0.7571568\",\n \"0.7548345\",\n \"0.7545028\",\n \"0.7496709\",\n \"0.7467794\",\n \"0.7425495\",\n \"0.74154097\",\n \"0.74044067\",\n \"0.73942935\",\n \"0.7349202\",\n \"0.7331742\",\n \"0.7307908\",\n \"0.72730225\",\n \"0.7255859\",\n \"0.72448915\",\n \"0.7206286\",\n \"0.7193589\",\n \"0.71935046\",\n \"0.7187388\",\n \"0.7153704\",\n \"0.7133455\",\n \"0.7130986\",\n \"0.7115213\",\n \"0.71122783\",\n \"0.71119636\",\n \"0.7104131\",\n \"0.7066388\",\n \"0.7038865\",\n \"0.7038478\",\n \"0.70381796\",\n \"0.70280117\",\n \"0.70273286\",\n \"0.70221996\",\n \"0.70215726\",\n \"0.7012627\",\n \"0.69984525\",\n \"0.69903046\",\n \"0.6989323\",\n \"0.6979142\",\n \"0.69748545\",\n \"0.6959236\",\n \"0.69504833\",\n \"0.69498545\",\n \"0.6949695\",\n \"0.6940887\",\n \"0.6932684\",\n \"0.692657\",\n \"0.6926379\",\n \"0.69253623\",\n \"0.69177115\",\n \"0.6897311\",\n \"0.6886651\",\n \"0.68813664\",\n \"0.6872944\",\n \"0.68591845\",\n \"0.6842985\",\n \"0.68418527\",\n \"0.68384916\",\n \"0.68302685\",\n \"0.6820417\",\n \"0.6808301\",\n \"0.68082523\",\n \"0.68031543\",\n \"0.68021065\",\n \"0.68020207\",\n \"0.6798108\",\n \"0.67948985\",\n \"0.6793053\",\n \"0.678845\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7529499"},"document_rank":{"kind":"string","value":"34"}}},{"rowIdx":92098,"cells":{"query":{"kind":"string","value":"Determine if a cached value from the given compare time is still valid"},"document":{"kind":"string","value":"def is_study_mapping_in_sync(self, unit_id: str, compare_time: float):\n return compare_time > self._last_study_mapping_update_times[unit_id]"},"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(t):\n return float(t) > time.time()","def is_cache_valid(self):\n if os.path.isfile(self.cache_filename):\n mod_time = os.path.getmtime(self.cache_filename)\n current_time = time()\n if (mod_time + self.cache_max_age) > current_time:\n return True\n return False","def _matchTime(self, time: float):\n return self._comparator['Time'] < time","def check_time():\n times = get_times()\n time_difference = abs((times['local'] - times['target']).total_seconds())\n return time_difference < post_time_tol_seconds","def cache_is_valid():\n if ARGV.get(NOCACHE_OPT):\n return False\n if not CACHE['last-request'] \\\n or not CACHE['max-age'] \\\n or not CACHE['feed']:\n return False\n current_time = float(time.time())\n last_request = float(CACHE['last-request'])\n max_age = float(CACHE['max-age'])\n return bool(current_time - last_request < max_age)","def check_expiration(self, cur_time):\n\n\t\ttime_limit = 1000\n\t\ttime_elapsed = cur_time - self.time_created\n\n\t\t# Erase cache after an arbitrary amount of time\n\t\tif time_elapsed > time_limit:\n\t\t\tself.cache_expiration()","def deciding(self):\n\n if not self.db.cacheEmpty():\n cacheMsgs = self.db.getCacheMsgs()\n prev = datetime.datetime.min\n prev_location = \"FOO LOCATION\"\n for msg in cacheMsgs:\n neutrinoTime = msg[\"neutrino_time\"]\n # go through messages to check if any two or more are within the time threshold\n if neutrinoTime - datetime.timedelta(seconds=self.coinc_threshold) <= prev:\n # verify the locations are different\n if msg[\"location\"] != prev_location:\n return True\n prev = neutrinoTime\n prev_location = msg[\"location\"]\n return False\n\n # return not self.db.cacheEmpty()","def is_cache_valid(self):\n if os.path.isfile(self.cache_path_cache):\n mod_time = os.path.getmtime(self.cache_path_cache)\n current_time = time()\n if (mod_time + self.cache_max_age) > current_time:\n if os.path.isfile(self.cache_path_index):\n return True\n return False","def checkAtFinalTime():\n global final_time\n if final_time <= current_second:\n return True\n return False","def test_timed(self):\n time = 0.001\n cache = TimedCache(max_age=time)\n\n cache[1] = 1\n assert 1 in cache\n sleep(time)\n assert 1 not in cache\n with pytest.raises(KeyError):\n assert cache[1]\n\n for i in range(50):\n cache[i] = i\n assert i in cache\n assert cache[i] == i\n sleep(time)\n for i in range(50):\n assert i not in cache\n with pytest.raises(KeyError):\n assert cache[i]","def newcache(cchepath):\n # it's under 30 mins old and not an empty file\n now = time.time()\n mtime = os.path.getmtime(cchepath)\n if now - mtime <= 1800:\n return False\n return True","def is_safe_cache(self):\n if self.get_last_update() > self.timestamp:\n return False\n return True","def check_timer(self, wanted_time):\n if time.time() - self.start_time >= wanted_time:\n return True\n return False","def _check_time_consistency(self, cache_mtime, chain_mtime):\n if cache_mtime != chain_mtime:\n log.warn(\"\"\"Modification times do not correspond.\n Last change of chain: {}\n Last change in cache: {}\"\"\".format(time.ctime(chain_mtime),\n time.ctime(cache_mtime)))","def _check_expire(self):\n self._log.debug(\"Checking entry expiration...\")\n current_time = time.time()\n for key in self._obj_cache.keys():\n self._log.debug(' -> %s (type = %s)',\n key, type(self._obj_cache[key]))\n # Remove if the key has a timeout, and the timeout period has been\n # exceeded (last access + timeout period <= current_time).\n if self._obj_timeouts[key] > 0 \\\n and current_time >= (self._obj_last_access[key]\n + self._obj_timeouts[key]):\n self._log.debug(' EXPIRED -- removing')\n # delete\n del self._obj_cache[key]\n del self._obj_last_access[key]\n del self._obj_timeouts[key]","def contains(self, key) -> bool:\n if key not in self._cache:\n return False\n value, expiration = self._cache[key]\n if self._clock() <= expiration:\n return True\n else:\n del self._cache[key]\n return False","def valid(self):\n delta = datetime.datetime.now() - self._last_access\n return ((delta.seconds < 7200) and not self.is_empty()) or \\\n (delta.seconds < 60)","def is_outdated(self, timestamp):\n\n expiry_time = datetime.datetime.now() - self.cache_time\n return expiry_time > timestamp","def isStale(self):\n return self.m_expirationDate < datetime.datetime.now(tz=pytz.utc)","def isDefaultedAt(self, time):\n return time > self.getDefaultTime()","def token_valid_check(start_time):\n #calculate the time elapsed since token was last refreshed\n elapsed_time = time.time() - start_time\n #take action if token is expired\n if elapsed_time > 3540:\n return False\n return True","def get_state_by_time(python_time):\n present = datetime.now()\n\n if python_time <= present:\n return 2\n else:\n return 1","def has_cached(self,ourmod,etag=None):\n if \"If-Modified-Since\" in self.request.headers:\n hdr = self.request.headers[\"If-Modified-Since\"]\n theirmod =time.mktime(parsedate(hdr))\n return theirmod < ourmod\n elif \"If-None-Match\" in self.request.headers and etag is not None:\n return self.request.headers[\"ETag\"] == etag","def is_valid(self):\n return self.startTime <= ApiKey.get_now() < self.endTime","def test_timed_reset(self):\n time = 0.005\n cache = TimedCache(max_age=time)\n\n cache[1] = 1\n assert 1 in cache\n assert cache[1] == 1\n sleep(time / 2)\n assert 1 in cache\n assert cache[1] == 1\n cache[1] = 1\n sleep(time / 2)\n assert 1 in cache\n assert cache[1] == 1\n sleep(time / 2)\n assert 1 not in cache\n with pytest.raises(KeyError):\n assert cache[1]","def valid(cache_file: Path, lifetime: int = None) -> bool:\n\n if not cache_file.exists():\n return False\n\n if lifetime is None:\n return True\n\n mtime = datetime.fromtimestamp(cache_file.lstat().st_mtime)\n if datetime.now() - timedelta(seconds=lifetime) < mtime:\n return True\n\n return False","def valid(self):\n return self.expiry > timezone.now()","def is_expired(self, key, now=None, remove=False):\n with self._lock:\n if now is None:\n now = time.time()\n # pylint: disable=unused-variable\n expire, _value = self._values[key]\n if expire is None:\n return False\n expired = expire < now\n if expired and remove:\n self.__delitem__(key)\n return expired","def check_attack(self):\n now = time.time() * 1000\n if self.prev_time is None:\n return True\n else:\n next_time = self.prev_time + self.get_recharge\n if now >= next_time:\n return True\n else:\n return False","def cached_data_fresh(name, max_age):\n age = get_cached_data_age(name)\n if not age:\n return False\n return age < max_age","def is_expired(self):\n return int(time.time()) - self.time > self.interval","def check_if_ok_to_update(self):\n current_time = int(time.time())\n last_refresh = self.last_refresh\n if last_refresh is None:\n last_refresh = 0\n if current_time >= (last_refresh + self.refresh_rate):\n return True\n return False","def test_untimed(self):\n cache = TimedCache()\n for i in range(500):\n cache[i] = i\n for i in range(500):\n assert i in cache\n assert cache[i] == i","def is_expired(self):\n\n return time.time() * 1000 - self._refreshed_on > self._expire","def check_diff(self,game,wanted_diff,wanted_starting_time=''):\n return True","def validity_by_time(self):\n conn = psycopg2.connect(self.conn)\n permissable_maximum_age_secs = 600 # 600s = 10mins\n query = \"SELECT time FROM steve_sense_sensor_logs ORDER BY time DESC LIMIT 1\"\n cur = conn.cursor()\n cur.execute(query)\n queryResult = cur.fetchall()\n age_seconds = (datetime.datetime.now(\n timezone.utc) - queryResult[0][0]).seconds\n cur.close()\n conn.close()\n if age_seconds > permissable_maximum_age_secs:\n print(\"Check Sensor, last sample is \"+str(age_seconds)+\" old\")\n return False\n else:\n return True","def expired(self):\n return int(time.time()) > self.expires_at","def __expired_timestamp(self, timestamp):\n return int(time.time()) > timestamp + self.__ttl","def _has_expired(self):\n try:\n expires = datetime.fromtimestamp(\n os.stat(self.lockfile).st_mtime\n )\n except OSError as e:\n if e in self.NOT_EXIST_ERRORS:\n return False\n raise\n return datetime.now() > expires","def needs_update(self, cache_key):\r\n return self._read_sha(cache_key) != cache_key.hash","def _verify_timeout(self, doc):\n expires = doc['expires']\n if expires == 0:\n return False\n if expires >= self._time():\n return False\n return True","def find(self, value):\n if not self.ts:\n return False\n\n if self.cache.get(value, False):\n return True\n\n for n in self.ts:\n if (value - n) in self.ts and (value - n != n or\n self.ts[(value - n)] > 1):\n self.cache[value] = True\n return True\n\n return False","def test_evict_expired(self):\n\n # use an invasive technique so that we don't have to sleep for\n # the item to expire\n\n bc = TimedCache(keep_time=1)\n\n bc[\"test\"] = \"value\"\n bc[\"test2\"] = \"value2\"\n self.assertEqual(len(bc), 2)\n\n # test that expired item i\n bc.cache[\"test\"].timestamp = bc.cache[\"test\"].timestamp - 2\n bc.purge_expired()\n self.assertEqual(len(bc), 1)\n self.assertFalse(\"test\" in bc)\n self.assertTrue(\"test2\" in bc)","def is_expired(snap):\n exp_epoch = int(snap.split(\"_\")[const.VLAB_SNAP_EXPIRES])\n current_time = int(time.time())\n return exp_epoch < current_time","def check(self, k, x):\n k = self._checkIndex(k)\n return bool(self.caches[k].count(x))","def has_expired(self):\n self.ensure_one()\n return datetime.now() > fields.Datetime.from_string(self.expires)","def __contains__(self, key):\n item = self._store.get(key)\n if not item:\n return False\n\n value, expires_at = item\n if expires_at and time.time() < expires_at:\n return False\n\n return True","def fresh(self):\n if NO_CACHE:\n return False\n return os.path.getmtime(pagePath(self.pageName))<=self.lastUpdated","def assert_cached(self, check, expected):\n self.assertEqual(check.add_cached, expected)\n self.assertEqual(check.cached_total, expected)","def _has_expired(self):\r\n expired = False\r\n if hasattr(self, 'Expiration'):\r\n now = datetime.datetime.utcnow()\r\n expiration = datetime.datetime.strptime(self.Expiration, '%Y-%m-%dT%H:%M:%SZ')\r\n expired = (now >= expiration)\r\n else:\r\n raise ValueError(\"ERROR: Request for expired property, but no Expiration in HIT!\")\r\n return expired","def is_expired(self):\n\n if self._lifetime is not None and self._lifetime > 0:\n # 300 seconds waite is the tolerance !\n # The unit of lifetime is millisecond\n if (time.time() - self._create_date) * 1000 > self._lifetime + 300000:\n return True\n\n return False","def has_expired(self, now):\n if now < self._expires:\n return False\n\n return self._enclave_wait_timer.has_expired()","def is_expired (self, now=None):\n if now is None: now = time.time()\n return self.is_idle_timed_out(now) or self.is_hard_timed_out(now)","def isFreeTimeExpired(self):\n assert self.notify.debugStateCall(self, 'loginFSM', 'gameFSM')\n if self.accountOldAuth:\n return 0\n\n # check for the config overrides\n # if true, free-time-expired takes precedence over unlimited-free-time\n if base.config.GetBool(\"free-time-expired\", 0):\n return 1\n if base.config.GetBool(\"unlimited-free-time\", 0):\n return 0\n\n # -1 == never expires (paid/exempt)\n if self.freeTimeExpiresAt == -1:\n return 0\n\n # 0 == expired\n if self.freeTimeExpiresAt == 0:\n return 1\n\n if self.freeTimeExpiresAt < -1:\n self.notify.warning('freeTimeExpiresAt is less than -1 (%s)' %\n self.freeTimeExpiresAt)\n\n # freeTimeExpiresAt is an epoch time\n # is it in the past?\n if self.freeTimeExpiresAt < time.time():\n return 1\n else:\n return 0","def _pair_stale(self, pair):\r\n (_conn, return_time) = pair\r\n now = time.time()\r\n return return_time + ConnectionPool.STALE_DURATION < now","def needs_update(self):\n now = time.time()/60\n return (self.last_update_time_in_minutes+self.timeout) < now","def _check_cache(self):\n return os.path.exists(self._cache_key)","def timed_cache(expire_seconds):\n cache = {'cache_time': 0, 'cache_value': None}\n\n def expired():\n return cache['cache_time'] + expire_seconds < time.time()\n\n def wrapper(func):\n @wraps(func)\n def inner():\n if expired():\n cache['cache_value'] = func()\n cache['cache_time'] = time.time()\n return cache['cache_value']\n\n return inner\n\n return wrapper","def is_file_expired(fname, cache_time=0):\n\n if cache_time:\n lastupdate = get_file_last_update_time(fname)\n return not (lastupdate and datetime.now() - lastupdate < timedelta(seconds=cache_time))\n\n return True","def is_expired(self):\n return utcnow() >= self.expires","def is_expired(self):\n return timeutils.utcnow_ts() > self.expire_ts","def constant_time_compare(val1, val2):\n return secrets.compare_digest(force_bytes(val1), force_bytes(val2))","def _check_goauth_expiration(self, expiry):\n now = int(time.time())\n time_left = int(expiry) - now\n # 10 days\n min_time_left = 60*60*24*10\n if time_left < min_time_left:\n return False\n else:\n return True","def _verify_time(given_time):\n\t\treturn int(given_time)","def constant_time_compare(self, val1, val2):\n return secrets.compare_digest(force_bytes(val1), force_bytes(val2))","def isExpired(self):\n return True/False","def compute_pirep_valid(self, hour, minute):\n res = self.utcnow.replace(\n hour=hour, minute=minute, second=0, microsecond=0\n )\n if hour > self.utcnow.hour:\n res -= datetime.timedelta(hours=24)\n return res","def is_expired(self):\n if not self.is_signed:\n return True\n return int(self._token_claims.get(self.__class__.exp_claim, 0)) < int(\n time.time()\n )","def has_expired(dirpath_build_cms, time_now):\n for (_, expiration, _) in _iter_expiration_files(\n os.path.join(dirpath_build_cms,\n _DIRNAME_EXPIRATION)):\n if (expiration is not None) and (expiration > time_now):\n return False\n return True","def is_cached(name, typ=\"pkl\"):\n return os.path.exists(cache_name(name, typ))","def testExpirationTime(self):\n\n bye = \"Good bye!\"\n memcache.add('bye', bye, 1)\n assert memcache.get('bye') == bye\n time.sleep(2)\n assert memcache.get('bye') == None","def validateTiming(obj):\n if obj.start_time:\n if obj.end_time:\n return obj.start_time <= timezone.now() and obj.end_time > timezone.now()\n else:\n return obj.start_time <= timezone.now()\n else:\n if obj.end_time:\n return obj.end_time > timezone.now()\n else:\n return True","def valid(cls, key, data=True):\n token = cls(key)\n if not token.well_formed():\n return False\n result = cache.get(token.cache_key())\n if result is not None:\n return result == data\n return False","def valid(self):\n return (self.expiry is None or self.expiry > timezone.now()) and (\n self.use_limit is None or self.times_used < self.use_limit\n )","def test_refetch_precomputed_valid_cache():\n ident = _id()\n res1 = proj.fetch('test', ident)\n res2 = proj.fetch('test', ident)\n # As these are timestamps, they would not be the same if this were recomputed\n assert res1.result['val'] == res2.result['val']","def token_is_stale(self):\n return self.m_token_expiry < datetime.datetime.now(tz=pytz.utc)","def is_real_time(self):\n return time.time() - self.timestamp < self._DEADLINE_SEC","def is_expired(self) -> bool:\n return now() > self.expires","def get_from_cache(self, url):\n cache_key, cache_lookup = self.get_cacheable_info(url)\n\n cache_timeout = self.cache_timeouts.get(cache_key,\n self.default_cache_timeout)\n\n data, access_time = MEM_CACHE[cache_key].get(cache_lookup, (None, 0))\n if data and time.time() - access_time < cache_timeout:\n return data\n return False","def is_expired(self):\n if self.access_token is None:\n logging.debug('Access token not found')\n return True\n else:\n return (self.expiration <= datetime.now())","def is_newer(self, time):\n with self.connection_pool.item() as sftpc:\n return (\n sftpc.stat(self.remote_path).st_mtime > time\n or sftpc.lstat(self.remote_path).st_mtime > time\n )","def is_cached(self):\n if self.should_persist:\n # If our value is persistable, it can be saved either on disk or in memory,\n # but only the former counts as being officially \"cached\".\n return self._result_value_hash is not None\n else:\n return self._result is not None","def expired(self):\n return rospy.get_rostime() - self.start_time > self.duration","def check_cached(self, file_name, n):\n try:\n with open('files/' + file_name + '.txt', 'r') as f:\n f_ = f.readlines()\n if len(f_) == 0: # no data in the file\n return False\n return float(f_[0]) + (n * 60) < time.time()\n except FileNotFoundError:\n with open('files/' + file_name + '.txt', 'w') as new_file:\n new_file.write(str(time.time()))\n with open('files/' + file_name + '.json', 'w') as new_json:\n new_json.write('')\n print('created new files for {}'.format(file_name))\n return True","def ValidLifeTime(self):\n if self.force_auto_sync:\n self.get('ValidLifeTime')\n return self._ValidLifeTime","def cache(func, cache, invalid_after):\n\n def cache_wrapper(*args, **kwargs):\n call_id = str(func) + str(args)\n try:\n return_value = cache[call_id]\n if ctime() - return_value[0] > invalid_after:\n raise Exception\n else:\n return return_value[1]\n except:\n return_value = func(*args, **kwargs)\n cache[call_id] = (ctime(), return_value)\n return return_value\n return cache_wrapper","def haveTime(self):\n if self.timeout is None:\n return True\n return time.time() <= self._stop","def test_expires(self):\n # We aren't bother going to test the actual time in expires, that\n # way lies pain with broken tests later.\n up = self.get(self.good_data)\n hdrs = dict(up.get_headers(1))\n lm = datetime(*utils.parsedate_tz(hdrs['Last-Modified'])[:7])\n exp = datetime(*utils.parsedate_tz(hdrs['Expires'])[:7])\n assert (exp - lm).seconds == 3600","def is_rate_validated(from_no):\n from_key_time = \"from_time_\"+from_no\n from_key_count = \"from_count_\" + from_no\n\n if not get_cache(from_key_time) or not get_cache(from_key_count):\n set_cache(from_key_time, time.time())\n set_cache(from_key_count, 1)\n return True\n cached_time = get_cache(from_key_time)\n time_diff = time.time() - cached_time\n cached_count = get_cache(from_key_count)\n\n if time_diff < RATE_LIMIT_DURATION and cached_count >= RATE_LIMIT_COUNT:\n return False\n elif time_diff > RATE_LIMIT_DURATION:\n set_cache(from_key_time, cached_time + RATE_LIMIT_DURATION)\n set_cache(from_key_count, 1)\n return True\n else: # cached_count < RATE_LIMIT_COUNT\n # print(\"hit from -%s, count - %s\" % (from_no,cached_count))\n set_cache(from_key_count, cached_count+1)\n return True","def check_expired_time(date_time_str, date_time_format=None, buffer=300):\n date_format = \"%Y-%m-%dT%H:%M:%SZ\" # \"2019-09-16T19:04:13Z\"\n date_time_obj = datetime.datetime.strptime(date_time_str, date_format)\n\n return date_time_obj.timestamp() > datetime.datetime.utcnow().timestamp() + buffer","def _HasExpired(self, key):\n self.logger.debug('Processing key: %s.', key)\n\n try:\n schema, json_str = key.split(None, 3)[2:]\n except (ValueError, AttributeError):\n self.logger.debug('No schema identifier. Not expiring key.')\n return False\n\n if schema != 'google-ssh':\n self.logger.debug('Invalid schema %s. Not expiring key.', schema)\n return False\n\n try:\n json_obj = json.loads(json_str)\n except ValueError:\n self.logger.debug('Invalid JSON %s. Not expiring key.', json_str)\n return False\n\n if 'expireOn' not in json_obj:\n self.logger.debug('No expiration timestamp. Not expiring key.')\n return False\n\n expire_str = json_obj['expireOn']\n format_str = '%Y-%m-%dT%H:%M:%S+0000'\n try:\n expire_time = datetime.datetime.strptime(expire_str, format_str)\n except ValueError:\n self.logger.warning(\n 'Expiration timestamp \"%s\" not in format %s. Not expiring key.',\n expire_str, format_str)\n return False\n\n # Expire the key if and only if we have exceeded the expiration timestamp.\n return datetime.datetime.utcnow() > expire_time","def test_cache_set_with_zero_or_negative_timeout(self):\n self.cache.set('goner', 'to be expired')\n\n self.cache.set('superman', 'clark kent', 0)\n self.cache.set('recipe', {'sugar': 2, 'wine': 5}, -10)\n self.cache.set('goner', 'expired', 0)\n\n self.assertEqual(self.cache.get('superman'), None)\n self.assertEqual(self.cache.get('recipe'), None)\n self.assertEqual(self.cache.get('goner'), None)\n\n # Move time forward 5 seconds\n cache.datetime.now = lambda: datetime.now() + timedelta(seconds=5)\n\n self.assertEqual(self.cache.get('superman'), None)\n self.assertEqual(self.cache.get('recipe'), None)\n self.assertEqual(self.cache.get('goner'), None)","def check_if_data_is_in_cache(self, channel, start, end, run_number):\n\n if self._cache_engine is None:\n return False\n\n sql = f'select * from Mya_Data_Ranges where run_number = {run_number} and channel = \"{channel}\";'\n run_data_mya = pd.read_sql(sql, self._cache_engine, index_col=\"run_number\",\n parse_dates=[\"start_time\", \"end_time\"])\n if len(run_data_mya) == 1:\n if self._debug > 2:\n print(f\"MyaData:: Data found in cache for {run_number} {channel}\")\n if start is not None and start < run_data_mya.iloc[0].start_time:\n print(f\"MyaData: WARNING- asking from cache before start: {start} < {run_data_mya.iloc[0].start_time}\")\n if end is not None and end > run_data_mya.iloc[0].end_time:\n print(f\"MyaData: WARNING - asking from cache after end: {end} > {run_data_mya.iloc[0].end_time}\")\n return True\n\n if len(run_data_mya) > 1:\n print(f\"MyaData Cache corruption: Multiple entries found for {run_number} {channel} \")\n\n return False","def check_diff(self, primary_perfdata):\n exist, contains = self.cache.check_if_exists_and_contains(self.io_key)\n compare_results = {}\n\n if exist:\n result_to_compare = self.cache.get_pickled_dict(self.io_key)\n compare_results['result1'] = result_to_compare\n compare_results['result2'] = primary_perfdata\n else:\n self.cache.set_pickled_dict(self.io_key, primary_perfdata, expire=COMPARISON_TTL)\n raise CheckError('No data to compare with')\n\n self.cache.set_pickled_dict(self.io_key, compare_results['result2'], expire=COMPARISON_TTL)\n\n return self.compare_results_data(compare_results['result1'], compare_results['result2'])","def has_expired(self):\n if not self._initialized:\n return True\n\n expires_in = self.expires_in\n if expires_in > 0:\n return False\n else:\n return True","def isFresh(self, timestamp):\n if not os.path.exists(self.__resource):\n return False;\n return os.path.getmtime(self.__resource) < timestamp;","def is_valid(self):\n return self.access_token is not None \\\n and time.time() < self._expiration_timestamp","def check_consistency(object) -> bool:\n time = np.array(list(object.keys()))\n time_diff = time[1:] - time[0:-1]\n return np.all(time_diff == 1)","def _is_expired(self):\n current_time = datetime.now()\n if (current_time > self._expires_at):\n logging.debug('token expired')\n return True\n else:\n return False","def testUpdatingAfterCaching(self):\n valid_period = datetime.timedelta(2, 4, 6)\n cached_list_logic.setCacheItems(\n 'test_list', [{KEY: 'foo'}, {KEY: 'bar'}], valid_period)\n cached_list = cached_list_model.CachedList.get_by_id('test_list')\n\n self.assertAlmostEqual(cached_list.valid_through,\n datetime.datetime.now() + valid_period,\n delta=datetime.timedelta(seconds=5))\n\n self.assertFalse(cached_list.is_processing)","def isTimeRemaining(self):\n if self.run_type.startswith('timed'):\n time_since_start = (time.time() - self.start_times['run'])\n remaining_time = self.max_time * 60 - time_since_start\n if remaining_time < 0:\n return False\n else:\n return True"],"string":"[\n \"def valid(t):\\n return float(t) > time.time()\",\n \"def is_cache_valid(self):\\n if os.path.isfile(self.cache_filename):\\n mod_time = os.path.getmtime(self.cache_filename)\\n current_time = time()\\n if (mod_time + self.cache_max_age) > current_time:\\n return True\\n return False\",\n \"def _matchTime(self, time: float):\\n return self._comparator['Time'] < time\",\n \"def check_time():\\n times = get_times()\\n time_difference = abs((times['local'] - times['target']).total_seconds())\\n return time_difference < post_time_tol_seconds\",\n \"def cache_is_valid():\\n if ARGV.get(NOCACHE_OPT):\\n return False\\n if not CACHE['last-request'] \\\\\\n or not CACHE['max-age'] \\\\\\n or not CACHE['feed']:\\n return False\\n current_time = float(time.time())\\n last_request = float(CACHE['last-request'])\\n max_age = float(CACHE['max-age'])\\n return bool(current_time - last_request < max_age)\",\n \"def check_expiration(self, cur_time):\\n\\n\\t\\ttime_limit = 1000\\n\\t\\ttime_elapsed = cur_time - self.time_created\\n\\n\\t\\t# Erase cache after an arbitrary amount of time\\n\\t\\tif time_elapsed > time_limit:\\n\\t\\t\\tself.cache_expiration()\",\n \"def deciding(self):\\n\\n if not self.db.cacheEmpty():\\n cacheMsgs = self.db.getCacheMsgs()\\n prev = datetime.datetime.min\\n prev_location = \\\"FOO LOCATION\\\"\\n for msg in cacheMsgs:\\n neutrinoTime = msg[\\\"neutrino_time\\\"]\\n # go through messages to check if any two or more are within the time threshold\\n if neutrinoTime - datetime.timedelta(seconds=self.coinc_threshold) <= prev:\\n # verify the locations are different\\n if msg[\\\"location\\\"] != prev_location:\\n return True\\n prev = neutrinoTime\\n prev_location = msg[\\\"location\\\"]\\n return False\\n\\n # return not self.db.cacheEmpty()\",\n \"def is_cache_valid(self):\\n if os.path.isfile(self.cache_path_cache):\\n mod_time = os.path.getmtime(self.cache_path_cache)\\n current_time = time()\\n if (mod_time + self.cache_max_age) > current_time:\\n if os.path.isfile(self.cache_path_index):\\n return True\\n return False\",\n \"def checkAtFinalTime():\\n global final_time\\n if final_time <= current_second:\\n return True\\n return False\",\n \"def test_timed(self):\\n time = 0.001\\n cache = TimedCache(max_age=time)\\n\\n cache[1] = 1\\n assert 1 in cache\\n sleep(time)\\n assert 1 not in cache\\n with pytest.raises(KeyError):\\n assert cache[1]\\n\\n for i in range(50):\\n cache[i] = i\\n assert i in cache\\n assert cache[i] == i\\n sleep(time)\\n for i in range(50):\\n assert i not in cache\\n with pytest.raises(KeyError):\\n assert cache[i]\",\n \"def newcache(cchepath):\\n # it's under 30 mins old and not an empty file\\n now = time.time()\\n mtime = os.path.getmtime(cchepath)\\n if now - mtime <= 1800:\\n return False\\n return True\",\n \"def is_safe_cache(self):\\n if self.get_last_update() > self.timestamp:\\n return False\\n return True\",\n \"def check_timer(self, wanted_time):\\n if time.time() - self.start_time >= wanted_time:\\n return True\\n return False\",\n \"def _check_time_consistency(self, cache_mtime, chain_mtime):\\n if cache_mtime != chain_mtime:\\n log.warn(\\\"\\\"\\\"Modification times do not correspond.\\n Last change of chain: {}\\n Last change in cache: {}\\\"\\\"\\\".format(time.ctime(chain_mtime),\\n time.ctime(cache_mtime)))\",\n \"def _check_expire(self):\\n self._log.debug(\\\"Checking entry expiration...\\\")\\n current_time = time.time()\\n for key in self._obj_cache.keys():\\n self._log.debug(' -> %s (type = %s)',\\n key, type(self._obj_cache[key]))\\n # Remove if the key has a timeout, and the timeout period has been\\n # exceeded (last access + timeout period <= current_time).\\n if self._obj_timeouts[key] > 0 \\\\\\n and current_time >= (self._obj_last_access[key]\\n + self._obj_timeouts[key]):\\n self._log.debug(' EXPIRED -- removing')\\n # delete\\n del self._obj_cache[key]\\n del self._obj_last_access[key]\\n del self._obj_timeouts[key]\",\n \"def contains(self, key) -> bool:\\n if key not in self._cache:\\n return False\\n value, expiration = self._cache[key]\\n if self._clock() <= expiration:\\n return True\\n else:\\n del self._cache[key]\\n return False\",\n \"def valid(self):\\n delta = datetime.datetime.now() - self._last_access\\n return ((delta.seconds < 7200) and not self.is_empty()) or \\\\\\n (delta.seconds < 60)\",\n \"def is_outdated(self, timestamp):\\n\\n expiry_time = datetime.datetime.now() - self.cache_time\\n return expiry_time > timestamp\",\n \"def isStale(self):\\n return self.m_expirationDate < datetime.datetime.now(tz=pytz.utc)\",\n \"def isDefaultedAt(self, time):\\n return time > self.getDefaultTime()\",\n \"def token_valid_check(start_time):\\n #calculate the time elapsed since token was last refreshed\\n elapsed_time = time.time() - start_time\\n #take action if token is expired\\n if elapsed_time > 3540:\\n return False\\n return True\",\n \"def get_state_by_time(python_time):\\n present = datetime.now()\\n\\n if python_time <= present:\\n return 2\\n else:\\n return 1\",\n \"def has_cached(self,ourmod,etag=None):\\n if \\\"If-Modified-Since\\\" in self.request.headers:\\n hdr = self.request.headers[\\\"If-Modified-Since\\\"]\\n theirmod =time.mktime(parsedate(hdr))\\n return theirmod < ourmod\\n elif \\\"If-None-Match\\\" in self.request.headers and etag is not None:\\n return self.request.headers[\\\"ETag\\\"] == etag\",\n \"def is_valid(self):\\n return self.startTime <= ApiKey.get_now() < self.endTime\",\n \"def test_timed_reset(self):\\n time = 0.005\\n cache = TimedCache(max_age=time)\\n\\n cache[1] = 1\\n assert 1 in cache\\n assert cache[1] == 1\\n sleep(time / 2)\\n assert 1 in cache\\n assert cache[1] == 1\\n cache[1] = 1\\n sleep(time / 2)\\n assert 1 in cache\\n assert cache[1] == 1\\n sleep(time / 2)\\n assert 1 not in cache\\n with pytest.raises(KeyError):\\n assert cache[1]\",\n \"def valid(cache_file: Path, lifetime: int = None) -> bool:\\n\\n if not cache_file.exists():\\n return False\\n\\n if lifetime is None:\\n return True\\n\\n mtime = datetime.fromtimestamp(cache_file.lstat().st_mtime)\\n if datetime.now() - timedelta(seconds=lifetime) < mtime:\\n return True\\n\\n return False\",\n \"def valid(self):\\n return self.expiry > timezone.now()\",\n \"def is_expired(self, key, now=None, remove=False):\\n with self._lock:\\n if now is None:\\n now = time.time()\\n # pylint: disable=unused-variable\\n expire, _value = self._values[key]\\n if expire is None:\\n return False\\n expired = expire < now\\n if expired and remove:\\n self.__delitem__(key)\\n return expired\",\n \"def check_attack(self):\\n now = time.time() * 1000\\n if self.prev_time is None:\\n return True\\n else:\\n next_time = self.prev_time + self.get_recharge\\n if now >= next_time:\\n return True\\n else:\\n return False\",\n \"def cached_data_fresh(name, max_age):\\n age = get_cached_data_age(name)\\n if not age:\\n return False\\n return age < max_age\",\n \"def is_expired(self):\\n return int(time.time()) - self.time > self.interval\",\n \"def check_if_ok_to_update(self):\\n current_time = int(time.time())\\n last_refresh = self.last_refresh\\n if last_refresh is None:\\n last_refresh = 0\\n if current_time >= (last_refresh + self.refresh_rate):\\n return True\\n return False\",\n \"def test_untimed(self):\\n cache = TimedCache()\\n for i in range(500):\\n cache[i] = i\\n for i in range(500):\\n assert i in cache\\n assert cache[i] == i\",\n \"def is_expired(self):\\n\\n return time.time() * 1000 - self._refreshed_on > self._expire\",\n \"def check_diff(self,game,wanted_diff,wanted_starting_time=''):\\n return True\",\n \"def validity_by_time(self):\\n conn = psycopg2.connect(self.conn)\\n permissable_maximum_age_secs = 600 # 600s = 10mins\\n query = \\\"SELECT time FROM steve_sense_sensor_logs ORDER BY time DESC LIMIT 1\\\"\\n cur = conn.cursor()\\n cur.execute(query)\\n queryResult = cur.fetchall()\\n age_seconds = (datetime.datetime.now(\\n timezone.utc) - queryResult[0][0]).seconds\\n cur.close()\\n conn.close()\\n if age_seconds > permissable_maximum_age_secs:\\n print(\\\"Check Sensor, last sample is \\\"+str(age_seconds)+\\\" old\\\")\\n return False\\n else:\\n return True\",\n \"def expired(self):\\n return int(time.time()) > self.expires_at\",\n \"def __expired_timestamp(self, timestamp):\\n return int(time.time()) > timestamp + self.__ttl\",\n \"def _has_expired(self):\\n try:\\n expires = datetime.fromtimestamp(\\n os.stat(self.lockfile).st_mtime\\n )\\n except OSError as e:\\n if e in self.NOT_EXIST_ERRORS:\\n return False\\n raise\\n return datetime.now() > expires\",\n \"def needs_update(self, cache_key):\\r\\n return self._read_sha(cache_key) != cache_key.hash\",\n \"def _verify_timeout(self, doc):\\n expires = doc['expires']\\n if expires == 0:\\n return False\\n if expires >= self._time():\\n return False\\n return True\",\n \"def find(self, value):\\n if not self.ts:\\n return False\\n\\n if self.cache.get(value, False):\\n return True\\n\\n for n in self.ts:\\n if (value - n) in self.ts and (value - n != n or\\n self.ts[(value - n)] > 1):\\n self.cache[value] = True\\n return True\\n\\n return False\",\n \"def test_evict_expired(self):\\n\\n # use an invasive technique so that we don't have to sleep for\\n # the item to expire\\n\\n bc = TimedCache(keep_time=1)\\n\\n bc[\\\"test\\\"] = \\\"value\\\"\\n bc[\\\"test2\\\"] = \\\"value2\\\"\\n self.assertEqual(len(bc), 2)\\n\\n # test that expired item i\\n bc.cache[\\\"test\\\"].timestamp = bc.cache[\\\"test\\\"].timestamp - 2\\n bc.purge_expired()\\n self.assertEqual(len(bc), 1)\\n self.assertFalse(\\\"test\\\" in bc)\\n self.assertTrue(\\\"test2\\\" in bc)\",\n \"def is_expired(snap):\\n exp_epoch = int(snap.split(\\\"_\\\")[const.VLAB_SNAP_EXPIRES])\\n current_time = int(time.time())\\n return exp_epoch < current_time\",\n \"def check(self, k, x):\\n k = self._checkIndex(k)\\n return bool(self.caches[k].count(x))\",\n \"def has_expired(self):\\n self.ensure_one()\\n return datetime.now() > fields.Datetime.from_string(self.expires)\",\n \"def __contains__(self, key):\\n item = self._store.get(key)\\n if not item:\\n return False\\n\\n value, expires_at = item\\n if expires_at and time.time() < expires_at:\\n return False\\n\\n return True\",\n \"def fresh(self):\\n if NO_CACHE:\\n return False\\n return os.path.getmtime(pagePath(self.pageName))<=self.lastUpdated\",\n \"def assert_cached(self, check, expected):\\n self.assertEqual(check.add_cached, expected)\\n self.assertEqual(check.cached_total, expected)\",\n \"def _has_expired(self):\\r\\n expired = False\\r\\n if hasattr(self, 'Expiration'):\\r\\n now = datetime.datetime.utcnow()\\r\\n expiration = datetime.datetime.strptime(self.Expiration, '%Y-%m-%dT%H:%M:%SZ')\\r\\n expired = (now >= expiration)\\r\\n else:\\r\\n raise ValueError(\\\"ERROR: Request for expired property, but no Expiration in HIT!\\\")\\r\\n return expired\",\n \"def is_expired(self):\\n\\n if self._lifetime is not None and self._lifetime > 0:\\n # 300 seconds waite is the tolerance !\\n # The unit of lifetime is millisecond\\n if (time.time() - self._create_date) * 1000 > self._lifetime + 300000:\\n return True\\n\\n return False\",\n \"def has_expired(self, now):\\n if now < self._expires:\\n return False\\n\\n return self._enclave_wait_timer.has_expired()\",\n \"def is_expired (self, now=None):\\n if now is None: now = time.time()\\n return self.is_idle_timed_out(now) or self.is_hard_timed_out(now)\",\n \"def isFreeTimeExpired(self):\\n assert self.notify.debugStateCall(self, 'loginFSM', 'gameFSM')\\n if self.accountOldAuth:\\n return 0\\n\\n # check for the config overrides\\n # if true, free-time-expired takes precedence over unlimited-free-time\\n if base.config.GetBool(\\\"free-time-expired\\\", 0):\\n return 1\\n if base.config.GetBool(\\\"unlimited-free-time\\\", 0):\\n return 0\\n\\n # -1 == never expires (paid/exempt)\\n if self.freeTimeExpiresAt == -1:\\n return 0\\n\\n # 0 == expired\\n if self.freeTimeExpiresAt == 0:\\n return 1\\n\\n if self.freeTimeExpiresAt < -1:\\n self.notify.warning('freeTimeExpiresAt is less than -1 (%s)' %\\n self.freeTimeExpiresAt)\\n\\n # freeTimeExpiresAt is an epoch time\\n # is it in the past?\\n if self.freeTimeExpiresAt < time.time():\\n return 1\\n else:\\n return 0\",\n \"def _pair_stale(self, pair):\\r\\n (_conn, return_time) = pair\\r\\n now = time.time()\\r\\n return return_time + ConnectionPool.STALE_DURATION < now\",\n \"def needs_update(self):\\n now = time.time()/60\\n return (self.last_update_time_in_minutes+self.timeout) < now\",\n \"def _check_cache(self):\\n return os.path.exists(self._cache_key)\",\n \"def timed_cache(expire_seconds):\\n cache = {'cache_time': 0, 'cache_value': None}\\n\\n def expired():\\n return cache['cache_time'] + expire_seconds < time.time()\\n\\n def wrapper(func):\\n @wraps(func)\\n def inner():\\n if expired():\\n cache['cache_value'] = func()\\n cache['cache_time'] = time.time()\\n return cache['cache_value']\\n\\n return inner\\n\\n return wrapper\",\n \"def is_file_expired(fname, cache_time=0):\\n\\n if cache_time:\\n lastupdate = get_file_last_update_time(fname)\\n return not (lastupdate and datetime.now() - lastupdate < timedelta(seconds=cache_time))\\n\\n return True\",\n \"def is_expired(self):\\n return utcnow() >= self.expires\",\n \"def is_expired(self):\\n return timeutils.utcnow_ts() > self.expire_ts\",\n \"def constant_time_compare(val1, val2):\\n return secrets.compare_digest(force_bytes(val1), force_bytes(val2))\",\n \"def _check_goauth_expiration(self, expiry):\\n now = int(time.time())\\n time_left = int(expiry) - now\\n # 10 days\\n min_time_left = 60*60*24*10\\n if time_left < min_time_left:\\n return False\\n else:\\n return True\",\n \"def _verify_time(given_time):\\n\\t\\treturn int(given_time)\",\n \"def constant_time_compare(self, val1, val2):\\n return secrets.compare_digest(force_bytes(val1), force_bytes(val2))\",\n \"def isExpired(self):\\n return True/False\",\n \"def compute_pirep_valid(self, hour, minute):\\n res = self.utcnow.replace(\\n hour=hour, minute=minute, second=0, microsecond=0\\n )\\n if hour > self.utcnow.hour:\\n res -= datetime.timedelta(hours=24)\\n return res\",\n \"def is_expired(self):\\n if not self.is_signed:\\n return True\\n return int(self._token_claims.get(self.__class__.exp_claim, 0)) < int(\\n time.time()\\n )\",\n \"def has_expired(dirpath_build_cms, time_now):\\n for (_, expiration, _) in _iter_expiration_files(\\n os.path.join(dirpath_build_cms,\\n _DIRNAME_EXPIRATION)):\\n if (expiration is not None) and (expiration > time_now):\\n return False\\n return True\",\n \"def is_cached(name, typ=\\\"pkl\\\"):\\n return os.path.exists(cache_name(name, typ))\",\n \"def testExpirationTime(self):\\n\\n bye = \\\"Good bye!\\\"\\n memcache.add('bye', bye, 1)\\n assert memcache.get('bye') == bye\\n time.sleep(2)\\n assert memcache.get('bye') == None\",\n \"def validateTiming(obj):\\n if obj.start_time:\\n if obj.end_time:\\n return obj.start_time <= timezone.now() and obj.end_time > timezone.now()\\n else:\\n return obj.start_time <= timezone.now()\\n else:\\n if obj.end_time:\\n return obj.end_time > timezone.now()\\n else:\\n return True\",\n \"def valid(cls, key, data=True):\\n token = cls(key)\\n if not token.well_formed():\\n return False\\n result = cache.get(token.cache_key())\\n if result is not None:\\n return result == data\\n return False\",\n \"def valid(self):\\n return (self.expiry is None or self.expiry > timezone.now()) and (\\n self.use_limit is None or self.times_used < self.use_limit\\n )\",\n \"def test_refetch_precomputed_valid_cache():\\n ident = _id()\\n res1 = proj.fetch('test', ident)\\n res2 = proj.fetch('test', ident)\\n # As these are timestamps, they would not be the same if this were recomputed\\n assert res1.result['val'] == res2.result['val']\",\n \"def token_is_stale(self):\\n return self.m_token_expiry < datetime.datetime.now(tz=pytz.utc)\",\n \"def is_real_time(self):\\n return time.time() - self.timestamp < self._DEADLINE_SEC\",\n \"def is_expired(self) -> bool:\\n return now() > self.expires\",\n \"def get_from_cache(self, url):\\n cache_key, cache_lookup = self.get_cacheable_info(url)\\n\\n cache_timeout = self.cache_timeouts.get(cache_key,\\n self.default_cache_timeout)\\n\\n data, access_time = MEM_CACHE[cache_key].get(cache_lookup, (None, 0))\\n if data and time.time() - access_time < cache_timeout:\\n return data\\n return False\",\n \"def is_expired(self):\\n if self.access_token is None:\\n logging.debug('Access token not found')\\n return True\\n else:\\n return (self.expiration <= datetime.now())\",\n \"def is_newer(self, time):\\n with self.connection_pool.item() as sftpc:\\n return (\\n sftpc.stat(self.remote_path).st_mtime > time\\n or sftpc.lstat(self.remote_path).st_mtime > time\\n )\",\n \"def is_cached(self):\\n if self.should_persist:\\n # If our value is persistable, it can be saved either on disk or in memory,\\n # but only the former counts as being officially \\\"cached\\\".\\n return self._result_value_hash is not None\\n else:\\n return self._result is not None\",\n \"def expired(self):\\n return rospy.get_rostime() - self.start_time > self.duration\",\n \"def check_cached(self, file_name, n):\\n try:\\n with open('files/' + file_name + '.txt', 'r') as f:\\n f_ = f.readlines()\\n if len(f_) == 0: # no data in the file\\n return False\\n return float(f_[0]) + (n * 60) < time.time()\\n except FileNotFoundError:\\n with open('files/' + file_name + '.txt', 'w') as new_file:\\n new_file.write(str(time.time()))\\n with open('files/' + file_name + '.json', 'w') as new_json:\\n new_json.write('')\\n print('created new files for {}'.format(file_name))\\n return True\",\n \"def ValidLifeTime(self):\\n if self.force_auto_sync:\\n self.get('ValidLifeTime')\\n return self._ValidLifeTime\",\n \"def cache(func, cache, invalid_after):\\n\\n def cache_wrapper(*args, **kwargs):\\n call_id = str(func) + str(args)\\n try:\\n return_value = cache[call_id]\\n if ctime() - return_value[0] > invalid_after:\\n raise Exception\\n else:\\n return return_value[1]\\n except:\\n return_value = func(*args, **kwargs)\\n cache[call_id] = (ctime(), return_value)\\n return return_value\\n return cache_wrapper\",\n \"def haveTime(self):\\n if self.timeout is None:\\n return True\\n return time.time() <= self._stop\",\n \"def test_expires(self):\\n # We aren't bother going to test the actual time in expires, that\\n # way lies pain with broken tests later.\\n up = self.get(self.good_data)\\n hdrs = dict(up.get_headers(1))\\n lm = datetime(*utils.parsedate_tz(hdrs['Last-Modified'])[:7])\\n exp = datetime(*utils.parsedate_tz(hdrs['Expires'])[:7])\\n assert (exp - lm).seconds == 3600\",\n \"def is_rate_validated(from_no):\\n from_key_time = \\\"from_time_\\\"+from_no\\n from_key_count = \\\"from_count_\\\" + from_no\\n\\n if not get_cache(from_key_time) or not get_cache(from_key_count):\\n set_cache(from_key_time, time.time())\\n set_cache(from_key_count, 1)\\n return True\\n cached_time = get_cache(from_key_time)\\n time_diff = time.time() - cached_time\\n cached_count = get_cache(from_key_count)\\n\\n if time_diff < RATE_LIMIT_DURATION and cached_count >= RATE_LIMIT_COUNT:\\n return False\\n elif time_diff > RATE_LIMIT_DURATION:\\n set_cache(from_key_time, cached_time + RATE_LIMIT_DURATION)\\n set_cache(from_key_count, 1)\\n return True\\n else: # cached_count < RATE_LIMIT_COUNT\\n # print(\\\"hit from -%s, count - %s\\\" % (from_no,cached_count))\\n set_cache(from_key_count, cached_count+1)\\n return True\",\n \"def check_expired_time(date_time_str, date_time_format=None, buffer=300):\\n date_format = \\\"%Y-%m-%dT%H:%M:%SZ\\\" # \\\"2019-09-16T19:04:13Z\\\"\\n date_time_obj = datetime.datetime.strptime(date_time_str, date_format)\\n\\n return date_time_obj.timestamp() > datetime.datetime.utcnow().timestamp() + buffer\",\n \"def _HasExpired(self, key):\\n self.logger.debug('Processing key: %s.', key)\\n\\n try:\\n schema, json_str = key.split(None, 3)[2:]\\n except (ValueError, AttributeError):\\n self.logger.debug('No schema identifier. Not expiring key.')\\n return False\\n\\n if schema != 'google-ssh':\\n self.logger.debug('Invalid schema %s. Not expiring key.', schema)\\n return False\\n\\n try:\\n json_obj = json.loads(json_str)\\n except ValueError:\\n self.logger.debug('Invalid JSON %s. Not expiring key.', json_str)\\n return False\\n\\n if 'expireOn' not in json_obj:\\n self.logger.debug('No expiration timestamp. Not expiring key.')\\n return False\\n\\n expire_str = json_obj['expireOn']\\n format_str = '%Y-%m-%dT%H:%M:%S+0000'\\n try:\\n expire_time = datetime.datetime.strptime(expire_str, format_str)\\n except ValueError:\\n self.logger.warning(\\n 'Expiration timestamp \\\"%s\\\" not in format %s. Not expiring key.',\\n expire_str, format_str)\\n return False\\n\\n # Expire the key if and only if we have exceeded the expiration timestamp.\\n return datetime.datetime.utcnow() > expire_time\",\n \"def test_cache_set_with_zero_or_negative_timeout(self):\\n self.cache.set('goner', 'to be expired')\\n\\n self.cache.set('superman', 'clark kent', 0)\\n self.cache.set('recipe', {'sugar': 2, 'wine': 5}, -10)\\n self.cache.set('goner', 'expired', 0)\\n\\n self.assertEqual(self.cache.get('superman'), None)\\n self.assertEqual(self.cache.get('recipe'), None)\\n self.assertEqual(self.cache.get('goner'), None)\\n\\n # Move time forward 5 seconds\\n cache.datetime.now = lambda: datetime.now() + timedelta(seconds=5)\\n\\n self.assertEqual(self.cache.get('superman'), None)\\n self.assertEqual(self.cache.get('recipe'), None)\\n self.assertEqual(self.cache.get('goner'), None)\",\n \"def check_if_data_is_in_cache(self, channel, start, end, run_number):\\n\\n if self._cache_engine is None:\\n return False\\n\\n sql = f'select * from Mya_Data_Ranges where run_number = {run_number} and channel = \\\"{channel}\\\";'\\n run_data_mya = pd.read_sql(sql, self._cache_engine, index_col=\\\"run_number\\\",\\n parse_dates=[\\\"start_time\\\", \\\"end_time\\\"])\\n if len(run_data_mya) == 1:\\n if self._debug > 2:\\n print(f\\\"MyaData:: Data found in cache for {run_number} {channel}\\\")\\n if start is not None and start < run_data_mya.iloc[0].start_time:\\n print(f\\\"MyaData: WARNING- asking from cache before start: {start} < {run_data_mya.iloc[0].start_time}\\\")\\n if end is not None and end > run_data_mya.iloc[0].end_time:\\n print(f\\\"MyaData: WARNING - asking from cache after end: {end} > {run_data_mya.iloc[0].end_time}\\\")\\n return True\\n\\n if len(run_data_mya) > 1:\\n print(f\\\"MyaData Cache corruption: Multiple entries found for {run_number} {channel} \\\")\\n\\n return False\",\n \"def check_diff(self, primary_perfdata):\\n exist, contains = self.cache.check_if_exists_and_contains(self.io_key)\\n compare_results = {}\\n\\n if exist:\\n result_to_compare = self.cache.get_pickled_dict(self.io_key)\\n compare_results['result1'] = result_to_compare\\n compare_results['result2'] = primary_perfdata\\n else:\\n self.cache.set_pickled_dict(self.io_key, primary_perfdata, expire=COMPARISON_TTL)\\n raise CheckError('No data to compare with')\\n\\n self.cache.set_pickled_dict(self.io_key, compare_results['result2'], expire=COMPARISON_TTL)\\n\\n return self.compare_results_data(compare_results['result1'], compare_results['result2'])\",\n \"def has_expired(self):\\n if not self._initialized:\\n return True\\n\\n expires_in = self.expires_in\\n if expires_in > 0:\\n return False\\n else:\\n return True\",\n \"def isFresh(self, timestamp):\\n if not os.path.exists(self.__resource):\\n return False;\\n return os.path.getmtime(self.__resource) < timestamp;\",\n \"def is_valid(self):\\n return self.access_token is not None \\\\\\n and time.time() < self._expiration_timestamp\",\n \"def check_consistency(object) -> bool:\\n time = np.array(list(object.keys()))\\n time_diff = time[1:] - time[0:-1]\\n return np.all(time_diff == 1)\",\n \"def _is_expired(self):\\n current_time = datetime.now()\\n if (current_time > self._expires_at):\\n logging.debug('token expired')\\n return True\\n else:\\n return False\",\n \"def testUpdatingAfterCaching(self):\\n valid_period = datetime.timedelta(2, 4, 6)\\n cached_list_logic.setCacheItems(\\n 'test_list', [{KEY: 'foo'}, {KEY: 'bar'}], valid_period)\\n cached_list = cached_list_model.CachedList.get_by_id('test_list')\\n\\n self.assertAlmostEqual(cached_list.valid_through,\\n datetime.datetime.now() + valid_period,\\n delta=datetime.timedelta(seconds=5))\\n\\n self.assertFalse(cached_list.is_processing)\",\n \"def isTimeRemaining(self):\\n if self.run_type.startswith('timed'):\\n time_since_start = (time.time() - self.start_times['run'])\\n remaining_time = self.max_time * 60 - time_since_start\\n if remaining_time < 0:\\n return False\\n else:\\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6786222","0.6448674","0.64324737","0.63750684","0.630569","0.63012683","0.6299927","0.6272141","0.6211941","0.6175154","0.61743593","0.61084133","0.6042745","0.6010127","0.6009563","0.60086095","0.6004558","0.59777814","0.5974766","0.5972415","0.5965831","0.5957111","0.59479016","0.5947427","0.5932441","0.59242517","0.5913843","0.59042925","0.5883468","0.58718467","0.5866056","0.5857018","0.583715","0.58313113","0.58236355","0.5814396","0.577254","0.5766491","0.57538843","0.57532036","0.57459027","0.57417643","0.57409865","0.5738168","0.57183796","0.5708378","0.57031","0.56764805","0.5669017","0.56622463","0.5650135","0.56486535","0.5633434","0.56314254","0.5629001","0.5605726","0.5602234","0.5601032","0.5592241","0.558272","0.55763817","0.5573387","0.55722904","0.5570012","0.5566424","0.5557584","0.55459386","0.5543868","0.55404687","0.5512429","0.5511445","0.5502811","0.5485383","0.54824877","0.5481295","0.5471237","0.5469748","0.54687816","0.5466477","0.54649365","0.54618376","0.54613507","0.54612905","0.54573965","0.5447233","0.54454476","0.54434884","0.5439638","0.5436317","0.5433492","0.5425501","0.54249686","0.5424225","0.54217106","0.5418034","0.5413759","0.5406845","0.5401724","0.5393656","0.53845733","0.53814507"],"string":"[\n \"0.6786222\",\n \"0.6448674\",\n \"0.64324737\",\n \"0.63750684\",\n \"0.630569\",\n \"0.63012683\",\n \"0.6299927\",\n \"0.6272141\",\n \"0.6211941\",\n \"0.6175154\",\n \"0.61743593\",\n \"0.61084133\",\n \"0.6042745\",\n \"0.6010127\",\n \"0.6009563\",\n \"0.60086095\",\n \"0.6004558\",\n \"0.59777814\",\n \"0.5974766\",\n \"0.5972415\",\n \"0.5965831\",\n \"0.5957111\",\n \"0.59479016\",\n \"0.5947427\",\n \"0.5932441\",\n \"0.59242517\",\n \"0.5913843\",\n \"0.59042925\",\n \"0.5883468\",\n \"0.58718467\",\n \"0.5866056\",\n \"0.5857018\",\n \"0.583715\",\n \"0.58313113\",\n \"0.58236355\",\n \"0.5814396\",\n \"0.577254\",\n \"0.5766491\",\n \"0.57538843\",\n \"0.57532036\",\n \"0.57459027\",\n \"0.57417643\",\n \"0.57409865\",\n \"0.5738168\",\n \"0.57183796\",\n \"0.5708378\",\n \"0.57031\",\n \"0.56764805\",\n \"0.5669017\",\n \"0.56622463\",\n \"0.5650135\",\n \"0.56486535\",\n \"0.5633434\",\n \"0.56314254\",\n \"0.5629001\",\n \"0.5605726\",\n \"0.5602234\",\n \"0.5601032\",\n \"0.5592241\",\n \"0.558272\",\n \"0.55763817\",\n \"0.5573387\",\n \"0.55722904\",\n \"0.5570012\",\n \"0.5566424\",\n \"0.5557584\",\n \"0.55459386\",\n \"0.5543868\",\n \"0.55404687\",\n \"0.5512429\",\n \"0.5511445\",\n \"0.5502811\",\n \"0.5485383\",\n \"0.54824877\",\n \"0.5481295\",\n \"0.5471237\",\n \"0.5469748\",\n \"0.54687816\",\n \"0.5466477\",\n \"0.54649365\",\n \"0.54618376\",\n \"0.54613507\",\n \"0.54612905\",\n \"0.54573965\",\n \"0.5447233\",\n \"0.54454476\",\n \"0.54434884\",\n \"0.5439638\",\n \"0.5436317\",\n \"0.5433492\",\n \"0.5425501\",\n \"0.54249686\",\n \"0.5424225\",\n \"0.54217106\",\n \"0.5418034\",\n \"0.5413759\",\n \"0.5406845\",\n \"0.5401724\",\n \"0.5393656\",\n \"0.53845733\",\n \"0.53814507\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":92099,"cells":{"query":{"kind":"string","value":"Register a new Study mapping in the table"},"document":{"kind":"string","value":"def new_study(\n self,\n prolific_study_id: str,\n study_link: str,\n duration_in_seconds: int,\n task_run_id: str,\n status: str = StudyStatus.UNPUBLISHED,\n ) -> None:\n with self.table_access_condition, self._get_connection() as conn:\n c = conn.cursor()\n c.execute(\n \"\"\"\n INSERT INTO studies(\n prolific_study_id,\n task_run_id,\n link,\n assignment_time_in_seconds,\n status\n ) VALUES (?, ?, ?, ?, ?);\n \"\"\",\n (prolific_study_id, task_run_id, study_link, duration_in_seconds, status),\n )\n c.execute(\n \"\"\"\n INSERT INTO run_mappings(\n prolific_study_id,\n run_id\n ) VALUES (?, ?);\n \"\"\",\n (prolific_study_id, task_run_id),\n )"},"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 register(self, table_name, **fields):\n if table_name == 'groups':\n self.register_group(**fields)\n elif table_name == 'homework':\n self.register_homework(**fields)\n elif table_name == 'parents':\n self.register_parent(**fields)\n elif table_name == 'students':\n self.register_student(**fields)\n elif table_name == 'teachers':\n self.register_teacher(**fields)\n elif table_name == 'tutors':\n self.register_tutor(**fields)\n elif table_name == 'courses':\n self.register_course(**fields)\n else:\n raise KeyError","def add_ens_mapping(\n self,\n write_cursor: 'DBCursor',\n address: ChecksumEvmAddress,\n name: Optional[str],\n now: Timestamp,\n ) -> None:\n write_cursor.execute(\n 'INSERT INTO ens_mappings (ens_name, address, last_update) '\n 'VALUES (?, ?, ?) ON CONFLICT(address) '\n 'DO UPDATE SET ens_name=excluded.ens_name, last_update=excluded.last_update; ',\n (name, address, now),\n )","def addMapping(mapping):\n defaultMapping_.addMapping(mapping)","def mapping(self, mapping):\n self.set_mapping(mapping)","def addMappingFile(self, study_id, mapping_file_path):\n try:\n con = self.getMetadataDatabaseConnection()\n con.cursor().callproc('qiime_assets.add_mapping_file', [study_id, mapping_file_path])\n return True\n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), e)\n return False","def create_mapping(self):\n\n indice = client.IndicesClient(self.es)\n\n indice.put_mapping(index=self.es_main_index,\n doc_type=self.es_main_type,\n body=self.mapping)","def setup_mapping():\n # Mapping describes how elasticsearch handles a document during indexing.\n # Most fields are detected and mapped automatically.\n m = {\n # Turn off analysis on name so we can sort by it.\n 'name': {'index': 'not_analyzed', 'type': 'string'},\n }\n es = elasticutils.get_es()\n try:\n es.create_index_if_missing(settings.ES_INDEX)\n es.put_mapping(Addon._meta.app_label, {'properties': m},\n settings.ES_INDEX)\n except pyes.ElasticSearchException:\n pass","def new_map(self):\n self.wizard = NewMap(self)","def createSampleKey(self, study_id, sample_name):\n try:\n con = self.getMetadataDatabaseConnection()\n con.cursor().callproc('qiime_assets.sample_insert', [study_id, sample_name])\n except Exception, e:\n print 'Exception caught: %s.\\nThe error is: %s' % (type(e), e)\n return False","def register_student(self, **fields):\n if 'student_key' not in fields.keys():\n raise KeyError('Primary key is missing')\n existing_fields = [i.name for i in self._db.get_columns('students')]\n needed_fields = {}\n for key, value in fields.items():\n if key in existing_fields:\n needed_fields[key] = value\n if 'UID' not in needed_fields.keys():\n needed_fields['UID'] = needed_fields['student_key']\n check = Students.get_or_none(student_key=needed_fields['student_key'])\n if check is not None:\n return check\n dummy_parent = Parents.get(parent_key=fields['parent']) if 'parent' in fields else Parents.get(parent_key='0')\n new_student = Students.get_or_create(parent=dummy_parent, **needed_fields)\n return new_student[0]","def set_mapping(self, mapping):\n mapping = pylastica.doc_type.Mapping.create(mapping)\n mapping.doc_type = self\n return mapping.send()","def push(self, mapping):\n self.mappings.append(mapping)","def register_type(self, type_name, mapping, model=None):\n assert type_name not in self.mappings\n self.mappings[type_name] = TypeMapping(type_name, mapping, model)","def create_new_study(self, study_name: Optional[str] = None) -> int:\n # TODO(ytsmiling) Fix RDB storage implementation to ensure unique `study_id`.\n raise NotImplementedError","def post_route_table_create(self, resource_dict):\n pass","def save(self, *args, **kwargs):\n self.phs = self.set_phs()\n super(Study, self).save(*args, **kwargs)","def study_dictionary(self, study_dictionary):\n\n self._study_dictionary = study_dictionary","def add_map(new_prot, new_target, map_path, map_type):\n hotspot_map = HotspotMap.objects.get_or_create(\n map_type=map_type, target_id=new_target, prot_id=new_prot\n )[0]\n hotspot_map.map_info.save(os.path.basename(map_path), File(open(map_path, encoding='utf-8')))\n return hotspot_map","def register_submission_to_study(\n self,\n prolific_study_id: str,\n unit_id: Optional[str] = None,\n prolific_submission_id: Optional[str] = None,\n ) -> None:\n logger.debug(\n f\"Attempting to assign Study {prolific_study_id}, \"\n f\"Unit {unit_id}, \"\n f\"Submission {prolific_submission_id}.\"\n )\n with self.table_access_condition, self._get_connection() as conn:\n c = conn.cursor()\n\n c.execute(\n \"\"\"\n INSERT OR IGNORE INTO submissions(\n prolific_study_id,\n prolific_submission_id\n ) VALUES (?, ?);\n \"\"\",\n (prolific_study_id, prolific_submission_id),\n )\n\n if unit_id is not None:\n self._mark_study_mapping_update(unit_id)","def register(self, prim, fn):\n assert prim not in self.mapping\n self.mapping[prim] = fn","def register(self, model: GemTable) -> GemTable:\n raise RuntimeError('Creating Tables is not supported at this time.')","def register(self):\n assert not self.is_registered\n with transaction.atomic():\n cursor = connection.cursor()\n cursor.execute(\"SELECT audit.audit_table(%s)\", [self.model_content_type.model_class()._meta.db_table])\n self.is_registered = True\n self.save()","def pre_route_table_create(self, resource_dict):\n pass","def study_id(self, study_id):\n\n self._study_id = study_id","def study_id(self, study_id):\n\n self._study_id = study_id","def study_id(self, study_id):\n\n self._study_id = study_id","def register(self):\n raise NotImplementedError","def register(self):\n raise NotImplementedError","def add(self, nodeLoc):\n self.table[self.getHashIndex(nodeLoc)] = True","def sit(self, table):\n self.table = table","def register_train(key, module):\n register(key, module, train_dict)","def addEntry(self, symbol, address):\n self.table[symbol] = address","def _do_mapping(self):\n pass","def requires_mapping(self):","def lvar_mapping_insert(*args):\n return _ida_hexrays.lvar_mapping_insert(*args)","def add(self, model_dict, datatype):\n self.push_datatype(datatype)\n\n model_dict['institution'] = self._institution\n db.session.add(self.cur_datatype_model()(model_dict))\n\n self.pop_datatype()","def add_target_and_index(self, name, sig, signode):\n key = normalize_object_name(name)\n if key in self.state.document.ids:\n return\n\n signode['names'].append(name)\n signode['ids'].append(key)\n signode['first'] = not self.names\n self.indexnode['entries'].append(\n ('single', 'JSON Objects; {}'.format(name), key, '', None))","def register_new_scanner(self, tarchive_info_dict, center_id):\n\n # create a new candidate for the scanner\n candidate = Candidate(self.verbose)\n new_cand_id = candidate.generate_cand_id(self.db)\n column_names = (\n 'CandID', 'PSCID', 'RegistrationCenterID', 'Date_active',\n 'UserID', 'Entity_type', 'Date_registered',\n )\n values = (\n new_cand_id, 'scanner', center_id, datetime.datetime.now(),\n 'imaging.py', 'Scanner', datetime.datetime.now()\n )\n self.db.insert(\n table_name = 'candidate',\n column_names = column_names,\n values = values\n )\n\n # create the new scanner ID\n manufacturer = tarchive_info_dict['ScannerManufacturer'],\n serial_number = tarchive_info_dict['ScannerSerialNumber'],\n software = tarchive_info_dict['ScannerSoftwareVersion'],\n model = tarchive_info_dict['ScannerModel'],\n scanner_id = self.db.insert(\n table_name = 'mri_scanner',\n column_names = ('Manufacturer', 'Model', 'Serial_number', 'Software', 'CandID'),\n values = (manufacturer, model, serial_number, software, new_cand_id),\n get_last_id = True\n )\n\n return scanner_id","def register(self, tensor: 'NmTensor'):\n\n # Check if object is already in a set.\n if tensor.unique_name in self._nmtensor_uniname_dict:\n pass\n\n # Finally, add object to the set.\n self._nmtensor_uniname_dict[tensor.unique_name] = tensor","def add_person_to_the_station(self, line, station):\n\n if line in self.__stations_dict:\n if station in self.__stations_dict[line]:\n self.__stations_dict[line][station] += 1\n else:\n self.__stations_dict[line][station] = 1\n else:\n self.__stations_dict[line] = {station: 1}","def setup_pair_register():\n register_param = {}\n si = SI.RegisterImagePair()\n register_param['si'] = si\n register_param['model0_name']= 'affine_map'\n register_param['model1_name']= 'svf_vector_momentum_map'\n\n return register_param","def createPrepKey(self, study_id, sample_name, row_number, barcode, linker, primer, run_prefix):\n con = self.getMetadataDatabaseConnection()\n con.cursor().callproc('qiime_assets.prep_insert', [study_id, sample_name, row_number, barcode, linker, primer, run_prefix])","def addPair(self, symbol, address):\r\n self.s_table[symbol] = address","def post_interface_route_table_create(self, resource_dict):\n pass","def addMapping(self, baseType, refType):\n if not self.apiName(baseType) or not self.apiName(refType):\n self.logMsg('diag', 'ScriptOutputGenerator::addMapping: IGNORE map from', baseType, '<->', refType)\n return\n\n self.logMsg('diag', 'ScriptOutputGenerator::addMapping: map from',\n baseType, '<->', refType)\n\n if baseType not in self.mapDict:\n baseDict = {}\n self.mapDict[baseType] = baseDict\n else:\n baseDict = self.mapDict[baseType]\n if refType not in self.mapDict:\n refDict = {}\n self.mapDict[refType] = refDict\n else:\n refDict = self.mapDict[refType]\n\n baseDict[refType] = None\n refDict[baseType] = None","def AddStudent(self, event):\n pass","def register_tutor(self, **fields):\n if 'tutor_key' not in fields.keys():\n raise KeyError('Primary key is missing')\n existing_fields = [i.name for i in self._db.get_columns('tutors')]\n needed_fields = {}\n for key, value in fields.items():\n if key in existing_fields:\n needed_fields[key] = value\n if 'UID' not in needed_fields.keys():\n needed_fields['UID'] = needed_fields['tutor_key']\n check = Tutors.get_or_none(tutor_key=needed_fields['tutor_key'])\n if check is not None:\n return check\n new_tutor = Tutors.get_or_create(**needed_fields)\n return new_tutor","def test_create(self):\n st = SampleTemplate.create(self.metadata, self.new_study)\n # The returned object has the correct id\n self.assertEqual(st.id, 2)\n\n # The relevant rows to required_sample_info have been added.\n obs = self.conn_handler.execute_fetchall(\n \"SELECT * FROM qiita.required_sample_info WHERE study_id=2\")\n # sample_id study_id physical_location has_physical_specimen\n # has_extracted_data sample_type required_sample_info_status_id\n # collection_timestamp host_subject_id description\n exp = [[\"2.Sample1\", 2, \"location1\", True, True, \"type1\", 1,\n datetime(2014, 5, 29, 12, 24, 51), \"NotIdentified\",\n \"Test Sample 1\", 42.42, 41.41],\n [\"2.Sample2\", 2, \"location1\", True, True, \"type1\", 1,\n datetime(2014, 5, 29, 12, 24, 51), \"NotIdentified\",\n \"Test Sample 2\", 4.2, 1.1],\n [\"2.Sample3\", 2, \"location1\", True, True, \"type1\", 1,\n datetime(2014, 5, 29, 12, 24, 51), \"NotIdentified\",\n \"Test Sample 3\", 4.8, 4.41]]\n self.assertEqual(obs, exp)\n\n # The relevant rows have been added to the study_sample_columns\n obs = self.conn_handler.execute_fetchall(\n \"SELECT study_id, column_name, column_type FROM \"\n \"qiita.study_sample_columns WHERE study_id=2 \"\n \"order by column_name\")\n\n # study_id, column_name, column_type\n exp = [[2L, 'int_column', 'integer'], [2, \"str_column\", \"varchar\"]]\n self.assertEqual(obs, exp)\n\n # The new table exists\n self.assertTrue(exists_table(\"sample_2\", self.conn_handler))\n\n # The new table hosts the correct values\n obs = self.conn_handler.execute_fetchall(\n \"SELECT * FROM qiita.sample_2\")\n # sample_id, str_column\n exp = [['2.Sample1', 1, \"Value for sample 1\"],\n ['2.Sample2', 2, \"Value for sample 2\"],\n ['2.Sample3', 3, \"Value for sample 3\"]]\n self.assertEqual(obs, exp)","def initialize_region(self):\n self.new_region_name = \"\"\n self.map.regions.create_new_region()","def register(self):\n raise NotImplementedError()","def register_model(self, model_name: str, model: Any, training_columns: List[str]):\n self.models[model_name] = (model, training_columns)","def registerWithSitemap(self):\n\n self.core.requireUniqueService('registerWithSitemap')\n\n #from soc.modules.seeder.views import seeder\n #self.core.registerSitemapEntry(seeder.view.getDjangoURLPatterns())","def initiate_new_tag (self,tag,key):\r\n\r\n #with shelf\r\n if self.using_shelf:\r\n self.tag_dict[tag] = {key}\r\n #with database\r\n\r\n if self.using_database:\r\n\r\n value_tuple = (notebookname, tag, key)\r\n db_cursor.execute(\"INSERT OR REPLACE\"\r\n +\" INTO tags_to_keys\"\r\n +\" (notebook, tag, keyword)\"\r\n +\" VALUES (?,?,?);\",\r\n value_tuple)","def _add_mapping(self, mother_element: GraphElement,\n daughter_element: GraphElement) -> None:\n self.mapping[mother_element] = daughter_element","def add_students_to_table(students):\n for student_name, points in students.items():\n try:\n Student.create(username=student_name, points=points)\n except IntegrityError: # IntError occurs when username already exists\n student_record = Student.get(username=student_name)\n if student_record.points != points:\n student_record.points = points\n student_record.save()","def add_location(self, seqid, gene, params, sr):\n location = dict()\n aliases = self.get_aliases(sr, seqid)\n sequence_id = [a for a in aliases if a.startswith('ga4gh')][0]\n\n if gene.start != '.' and gene.end != '.' and sequence_id:\n if 0 <= gene.start <= gene.end:\n seq_location = models.SequenceLocation(\n sequence_id=sequence_id,\n interval=models.SimpleInterval(\n start=gene.start,\n end=gene.end\n )\n )\n seq_location._id = ga4gh_identify(seq_location)\n location = seq_location.as_dict()\n else:\n logger.info(f\"{params['concept_id']} has invalid interval:\"\n f\"start={gene.start} end={gene.end}\")\n return location","def add_table(self, table, data_frame, alias=None):\n if alias is not None:\n for name in alias:\n self.alias_map[name] = table\n self.alias_map[table] = table\n self.data_frames[table] = data_frame","def append_table(self, table):\n\n self._db_manager.register_table(table)","def _add_pk(self, conn, *, tblname, pk_columns):\n idx_metadatum = partition_utils.IndexMetadatum(idx_cols=pk_columns, is_unique=True)\n partition_utils.add_indices(conn, tbl_name=tblname, idx_metadata=[idx_metadatum])","def __handle_new_study_form(new_study_form, info_messages, error_messages):\n if new_study_form.register.data:\n StudyDAO.get_instance().save(Study.from_study_form(new_study_form))\n info_messages.append(_(\"New study {0} saved\".format(new_study_form.name.data)))\n\n elif new_study_form.update.data:\n study = StudyDAO.get_instance().find(new_study_form.id.data)\n study.update_with_form(new_study_form)\n StudyDAO.get_instance().update(study)\n info_messages.append(_(\"Study {0} updated\".format(study.name)))","def _add_mapping(self, mother_element: GraphElement,\n daughter_element: GraphElement) -> None:\n pass","def register(self):\n self.validate(True)\n\n # If everything works correctly then commit to database.\n db.session.add(self)\n db.session.commit()","def pre_interface_route_table_create(self, resource_dict):\n pass","def insert_person(self, document, name, birthday, vaccinated):\n self.__people[document] = Person(document, name, birthday, vaccinated)","def create_new_index(self, dict_pg_info):\n # ! Setting if fun can use default setting\n ruler = Rules()\n str_conn = ruler.pg_info_rules(dict_pg_info)\n conn = psycopg2.connect(str_conn)\n\n with conn:\n with conn.cursor() as cur:\n str_create_table = \"CREATE TABLE \" + dict_pg_info['table'] + \" (path varchar PRIMARY KEY);\"\n # ! Check if table already exit\n cur.execute(str_create_table)\n cur.close()\n\n conn.close()","def copy_sr_name_to_syn(self, cs, x_db, log_pfx):\n asm_v = self.asm_name()\n sql = r'''insert into seq_region_synonym (seq_region_id, synonym, external_db_id)\n select\n sr.seq_region_id, sr.name, xdb.external_db_id\n from\n seq_region sr, external_db xdb, coord_system cs\n where xdb.db_name = \"%s\"\n and sr.coord_system_id = cs.coord_system_id\n and cs.name = \"%s\"\n and cs.version = \"%s\"\n and sr.name like \"%%._\"\n ;''' % (x_db, cs, asm_v)\n return self.run_sql_req(sql, log_pfx)","def _mark_study_mapping_update(self, unit_id: str) -> None:\n self._last_study_mapping_update_times[unit_id] = time.monotonic()","def get_study_mapping(self, unit_id: str) -> sqlite3.Row:\n with self.table_access_condition:\n conn = self._get_connection()\n c = conn.cursor()\n c.execute(\n \"\"\"\n SELECT * from studies\n INNER JOIN units USING (prolific_study_id)\n WHERE units.unit_id = ?;\n \"\"\",\n (unit_id,),\n )\n results = c.fetchall()\n return results[0]","def register(self, kw: str, vs: Sequence[str]) -> None:\n if self._table.get(kw) is not None:\n self._table[kw] = self._table[kw].union(vs)\n else:\n self._table[kw] = set(vs)","def register(key, module, module_dict):\n if key in module_dict:\n raise KeyError('Key {} is already pre-defined.'.format(key))\n else:\n module_dict[key] = module","def transfer(self, en_cls, table_name, db_name):\n self.into_en_map(en_cls, table_name, db_name, create=False)\n self._start()","def register(cls, L):\r\n ...","def create_season_table(database, data, tbl_name):\n sql_types = data.get_sql_type()\n constraint = {UniqueConstraint: [\"start_time\", \"home_team\", \"away_team\"]}\n database.map_table(tbl_name, sql_types, constraint)\n database.create_tables()\n database.insert_rows(tbl_name, data.data)\n database.clear_mappers() # if mappers aren't cleared, others scripts won't be able to use DBInterface.Template","def register(migration):\n MIGRATIONS[migration.__name__] = migration","def post(self):\n body = request.get_json(force=True)\n try:\n st = StudySchema(strict=True).load(body).data\n except ValidationError as err:\n abort(400, 'could not create study: {}'.format(err.messages))\n\n db.session.add(st)\n db.session.commit()\n return StudySchema(\n 201, 'study {} created'.format(st.kf_id)\n ).jsonify(st), 201","def _register(self, noun):\n self.noun = noun","def register_molecule(self, molecule, name):\n self[name] = molecule","def register(self):\n raise NotImplementedError(\"Should have implemented this\")","def add_sensor(sensor):\n if not isinstance(sensor, Sensor):\n raise TypeError(\"pysma.Sensor expected\")\n if get_sensor(sensor.name):\n _LOGGER.error(\"Cannot add sensor. %s already exists\", sensor.name)\n if get_sensor(sensor.key):\n _LOGGER.error(\"Cannot add sensor %s. Key %s already exists\",\n sensor.name, sensor.key)\n SENSORS.append(sensor)","def study_code(self, study_code):\n\n self._study_code = study_code","def add_row(self, row_id):","def register_probe(request):\n serial_number = request.data['sn']\n\n try:\n probe = Probe.objects.get(sn=serial_number)\n except Probe.DoesNotExist:\n probe = None\n\n # md = []\n # for modem in request.data['modems']:\n # try:\n # inst_modem = Modem.objects.get(imei=modem['imei'])\n # except Modem.DoesNotExist:\n # inst_modem = None\n # md.append( inst_modem)\n serializer = ProbeSerializer(probe, data=request.data, partial=True)\n if serializer.is_valid():\n serializer.save()\n return Response(serializer.data, status=status.HTTP_201_CREATED)\n return Response({\"message\": _(\"Error probe registering!\"), 'more': serializer.errors})","def register_vocab(self, start_concept, end_concept, alias_of, regex_str):\n self.register_vocabulary(start_concept, end_concept,\n alias_of, regex_str)","def register_stage(key, module):\n register(key, module, stage_dict)","def register_problem(self, location, name):\r\n self.problems[location] = name","def add(self, sensor):\n if isinstance(sensor, (list, tuple)):\n for sss in sensor:\n self.add(sss)\n return\n\n if not isinstance(sensor, Sensor):\n raise TypeError(\"pysaj.Sensor expected\")\n\n if sensor.name in self:\n old = self[sensor.name]\n self.__s.remove(old)\n _LOGGER.warning(\"Replacing sensor %s with %s\", old, sensor)\n\n if sensor.key in self:\n _LOGGER.warning(\"Duplicate SAJ sensor key %s\", sensor.key)\n\n self.__s.append(sensor)","def add(table):\n id_storage = common.get_values_from_column(table, 0)\n id_ = common.generate_random(table)\n table = manage_data_from_user(table, id_storage, id_, False)\n\n return table","def make_mapping(self) -> None:\n start_mark = StreamMark('generated node', 0, 0, 0)\n end_mark = StreamMark('generated node', 0, 0, 0)\n self.yaml_node = yaml.MappingNode('tag:yaml.org,2002:map', list(),\n start_mark, end_mark)","def __init__(self, uncert=None):\n super(Smap, self).__init__(uncert)\n self.res = 0.36\n self.stddev = 0.001\n self.tablename = \"soilmoist.smap\"","def createEMPStudy(self, user_id, study_name, investigation_type, miens_compliant, submit_to_insdc, \n portal_type, study_title, study_alias, pmid, study_abstract, study_description,\n number_samples_collected, number_samples_promised , lab_person,\n lab_person_contact, emp_person, first_contact, most_recent_contact, sample_type, \n has_physical_specimen, has_extracted_data, timeseries, spatial_series,\n principal_investigator, principal_investigator_contact, default_emp_status, funding,\n includes_timeseries):\n con = self.getMetadataDatabaseConnection()\n study_id = 0\n results = con.cursor().callproc('qiime_assets.emp_study_insert', \n [study_id, user_id, study_name,\n investigation_type, miens_compliant, submit_to_insdc, portal_type, \n study_title, study_alias, pmid, study_abstract, study_description,\n number_samples_collected, number_samples_promised , lab_person,\n lab_person_contact, emp_person, first_contact, most_recent_contact, sample_type, \n has_physical_specimen, has_extracted_data, timeseries, spatial_series,\n principal_investigator, principal_investigator_contact, default_emp_status, funding,\n includes_timeseries])\n return results[0]","def _registerSample(self, prefix, info):\n self.checkIdentifiersPresent(info)\n self._prefixToIdentifiers[prefix] = info","def addSensor(self, coordinates, epsg, name, status):\n self.settingsDb.addSensor(coordinates, epsg, name, status)","def add(self, pro):\n self.registry[pro.cell_id] = pro","def addObject(self, name, object):\n self.map[name] = object","def initiate_new_word(self,word,index):\r\n\r\n #with shelf\r\n if self.using_shelf:\r\n\r\n self.word_dict[word] = {str(index)}\r\n\r\n #with database\r\n if self.using_database:\r\n\r\n value_tuple = (notebookname, word,)\r\n db_cursor.execute(\"INSERT OR REPLACE\"\r\n +\" INTO all_words (word, notebook)\"\r\n +\" VALUES (?,?);\",value_tuple)\r\n value_tuple = (notebookname, word, str(index))\r\n db_cursor.execute(\"INSERT OR REPLACE\"\r\n +\" INTO word_to_indexes (notebook, word, note_index)\"\r\n +\" VALUES (?,?,?);\",\r\n value_tuple)","def node_mapping(self):\n ...","def add_to_series_dict(func):\n def add(self, *args, **kwargs):\n s = func(self, *args, **kwargs)\n self.sid_series[s['id']] = s\n return s\n return add","def addSpeciesTypeComponentMapInProduct(self, *args):\n return _libsbml.MultiSpeciesReferencePlugin_addSpeciesTypeComponentMapInProduct(self, *args)","def create_scaffold_assignments_table(self):\n log.info(\"Creating table to store Scaffold genus assignments ...\")\n self.create_table(self.ScaffoldsAssignmentsTable ,self.ScaffoldAssignmentsFields,\n self.ScaffoldAssignmentsTypes)","def add_table(\n self,\n table: exp.Table | str,\n column_mapping: t.Optional[ColumnMapping] = None,\n dialect: DialectType = None,\n normalize: t.Optional[bool] = None,\n match_depth: bool = True,\n ) -> None:"],"string":"[\n \"def register(self, table_name, **fields):\\n if table_name == 'groups':\\n self.register_group(**fields)\\n elif table_name == 'homework':\\n self.register_homework(**fields)\\n elif table_name == 'parents':\\n self.register_parent(**fields)\\n elif table_name == 'students':\\n self.register_student(**fields)\\n elif table_name == 'teachers':\\n self.register_teacher(**fields)\\n elif table_name == 'tutors':\\n self.register_tutor(**fields)\\n elif table_name == 'courses':\\n self.register_course(**fields)\\n else:\\n raise KeyError\",\n \"def add_ens_mapping(\\n self,\\n write_cursor: 'DBCursor',\\n address: ChecksumEvmAddress,\\n name: Optional[str],\\n now: Timestamp,\\n ) -> None:\\n write_cursor.execute(\\n 'INSERT INTO ens_mappings (ens_name, address, last_update) '\\n 'VALUES (?, ?, ?) ON CONFLICT(address) '\\n 'DO UPDATE SET ens_name=excluded.ens_name, last_update=excluded.last_update; ',\\n (name, address, now),\\n )\",\n \"def addMapping(mapping):\\n defaultMapping_.addMapping(mapping)\",\n \"def mapping(self, mapping):\\n self.set_mapping(mapping)\",\n \"def addMappingFile(self, study_id, mapping_file_path):\\n try:\\n con = self.getMetadataDatabaseConnection()\\n con.cursor().callproc('qiime_assets.add_mapping_file', [study_id, mapping_file_path])\\n return True\\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), e)\\n return False\",\n \"def create_mapping(self):\\n\\n indice = client.IndicesClient(self.es)\\n\\n indice.put_mapping(index=self.es_main_index,\\n doc_type=self.es_main_type,\\n body=self.mapping)\",\n \"def setup_mapping():\\n # Mapping describes how elasticsearch handles a document during indexing.\\n # Most fields are detected and mapped automatically.\\n m = {\\n # Turn off analysis on name so we can sort by it.\\n 'name': {'index': 'not_analyzed', 'type': 'string'},\\n }\\n es = elasticutils.get_es()\\n try:\\n es.create_index_if_missing(settings.ES_INDEX)\\n es.put_mapping(Addon._meta.app_label, {'properties': m},\\n settings.ES_INDEX)\\n except pyes.ElasticSearchException:\\n pass\",\n \"def new_map(self):\\n self.wizard = NewMap(self)\",\n \"def createSampleKey(self, study_id, sample_name):\\n try:\\n con = self.getMetadataDatabaseConnection()\\n con.cursor().callproc('qiime_assets.sample_insert', [study_id, sample_name])\\n except Exception, e:\\n print 'Exception caught: %s.\\\\nThe error is: %s' % (type(e), e)\\n return False\",\n \"def register_student(self, **fields):\\n if 'student_key' not in fields.keys():\\n raise KeyError('Primary key is missing')\\n existing_fields = [i.name for i in self._db.get_columns('students')]\\n needed_fields = {}\\n for key, value in fields.items():\\n if key in existing_fields:\\n needed_fields[key] = value\\n if 'UID' not in needed_fields.keys():\\n needed_fields['UID'] = needed_fields['student_key']\\n check = Students.get_or_none(student_key=needed_fields['student_key'])\\n if check is not None:\\n return check\\n dummy_parent = Parents.get(parent_key=fields['parent']) if 'parent' in fields else Parents.get(parent_key='0')\\n new_student = Students.get_or_create(parent=dummy_parent, **needed_fields)\\n return new_student[0]\",\n \"def set_mapping(self, mapping):\\n mapping = pylastica.doc_type.Mapping.create(mapping)\\n mapping.doc_type = self\\n return mapping.send()\",\n \"def push(self, mapping):\\n self.mappings.append(mapping)\",\n \"def register_type(self, type_name, mapping, model=None):\\n assert type_name not in self.mappings\\n self.mappings[type_name] = TypeMapping(type_name, mapping, model)\",\n \"def create_new_study(self, study_name: Optional[str] = None) -> int:\\n # TODO(ytsmiling) Fix RDB storage implementation to ensure unique `study_id`.\\n raise NotImplementedError\",\n \"def post_route_table_create(self, resource_dict):\\n pass\",\n \"def save(self, *args, **kwargs):\\n self.phs = self.set_phs()\\n super(Study, self).save(*args, **kwargs)\",\n \"def study_dictionary(self, study_dictionary):\\n\\n self._study_dictionary = study_dictionary\",\n \"def add_map(new_prot, new_target, map_path, map_type):\\n hotspot_map = HotspotMap.objects.get_or_create(\\n map_type=map_type, target_id=new_target, prot_id=new_prot\\n )[0]\\n hotspot_map.map_info.save(os.path.basename(map_path), File(open(map_path, encoding='utf-8')))\\n return hotspot_map\",\n \"def register_submission_to_study(\\n self,\\n prolific_study_id: str,\\n unit_id: Optional[str] = None,\\n prolific_submission_id: Optional[str] = None,\\n ) -> None:\\n logger.debug(\\n f\\\"Attempting to assign Study {prolific_study_id}, \\\"\\n f\\\"Unit {unit_id}, \\\"\\n f\\\"Submission {prolific_submission_id}.\\\"\\n )\\n with self.table_access_condition, self._get_connection() as conn:\\n c = conn.cursor()\\n\\n c.execute(\\n \\\"\\\"\\\"\\n INSERT OR IGNORE INTO submissions(\\n prolific_study_id,\\n prolific_submission_id\\n ) VALUES (?, ?);\\n \\\"\\\"\\\",\\n (prolific_study_id, prolific_submission_id),\\n )\\n\\n if unit_id is not None:\\n self._mark_study_mapping_update(unit_id)\",\n \"def register(self, prim, fn):\\n assert prim not in self.mapping\\n self.mapping[prim] = fn\",\n \"def register(self, model: GemTable) -> GemTable:\\n raise RuntimeError('Creating Tables is not supported at this time.')\",\n \"def register(self):\\n assert not self.is_registered\\n with transaction.atomic():\\n cursor = connection.cursor()\\n cursor.execute(\\\"SELECT audit.audit_table(%s)\\\", [self.model_content_type.model_class()._meta.db_table])\\n self.is_registered = True\\n self.save()\",\n \"def pre_route_table_create(self, resource_dict):\\n pass\",\n \"def study_id(self, study_id):\\n\\n self._study_id = study_id\",\n \"def study_id(self, study_id):\\n\\n self._study_id = study_id\",\n \"def study_id(self, study_id):\\n\\n self._study_id = study_id\",\n \"def register(self):\\n raise NotImplementedError\",\n \"def register(self):\\n raise NotImplementedError\",\n \"def add(self, nodeLoc):\\n self.table[self.getHashIndex(nodeLoc)] = True\",\n \"def sit(self, table):\\n self.table = table\",\n \"def register_train(key, module):\\n register(key, module, train_dict)\",\n \"def addEntry(self, symbol, address):\\n self.table[symbol] = address\",\n \"def _do_mapping(self):\\n pass\",\n \"def requires_mapping(self):\",\n \"def lvar_mapping_insert(*args):\\n return _ida_hexrays.lvar_mapping_insert(*args)\",\n \"def add(self, model_dict, datatype):\\n self.push_datatype(datatype)\\n\\n model_dict['institution'] = self._institution\\n db.session.add(self.cur_datatype_model()(model_dict))\\n\\n self.pop_datatype()\",\n \"def add_target_and_index(self, name, sig, signode):\\n key = normalize_object_name(name)\\n if key in self.state.document.ids:\\n return\\n\\n signode['names'].append(name)\\n signode['ids'].append(key)\\n signode['first'] = not self.names\\n self.indexnode['entries'].append(\\n ('single', 'JSON Objects; {}'.format(name), key, '', None))\",\n \"def register_new_scanner(self, tarchive_info_dict, center_id):\\n\\n # create a new candidate for the scanner\\n candidate = Candidate(self.verbose)\\n new_cand_id = candidate.generate_cand_id(self.db)\\n column_names = (\\n 'CandID', 'PSCID', 'RegistrationCenterID', 'Date_active',\\n 'UserID', 'Entity_type', 'Date_registered',\\n )\\n values = (\\n new_cand_id, 'scanner', center_id, datetime.datetime.now(),\\n 'imaging.py', 'Scanner', datetime.datetime.now()\\n )\\n self.db.insert(\\n table_name = 'candidate',\\n column_names = column_names,\\n values = values\\n )\\n\\n # create the new scanner ID\\n manufacturer = tarchive_info_dict['ScannerManufacturer'],\\n serial_number = tarchive_info_dict['ScannerSerialNumber'],\\n software = tarchive_info_dict['ScannerSoftwareVersion'],\\n model = tarchive_info_dict['ScannerModel'],\\n scanner_id = self.db.insert(\\n table_name = 'mri_scanner',\\n column_names = ('Manufacturer', 'Model', 'Serial_number', 'Software', 'CandID'),\\n values = (manufacturer, model, serial_number, software, new_cand_id),\\n get_last_id = True\\n )\\n\\n return scanner_id\",\n \"def register(self, tensor: 'NmTensor'):\\n\\n # Check if object is already in a set.\\n if tensor.unique_name in self._nmtensor_uniname_dict:\\n pass\\n\\n # Finally, add object to the set.\\n self._nmtensor_uniname_dict[tensor.unique_name] = tensor\",\n \"def add_person_to_the_station(self, line, station):\\n\\n if line in self.__stations_dict:\\n if station in self.__stations_dict[line]:\\n self.__stations_dict[line][station] += 1\\n else:\\n self.__stations_dict[line][station] = 1\\n else:\\n self.__stations_dict[line] = {station: 1}\",\n \"def setup_pair_register():\\n register_param = {}\\n si = SI.RegisterImagePair()\\n register_param['si'] = si\\n register_param['model0_name']= 'affine_map'\\n register_param['model1_name']= 'svf_vector_momentum_map'\\n\\n return register_param\",\n \"def createPrepKey(self, study_id, sample_name, row_number, barcode, linker, primer, run_prefix):\\n con = self.getMetadataDatabaseConnection()\\n con.cursor().callproc('qiime_assets.prep_insert', [study_id, sample_name, row_number, barcode, linker, primer, run_prefix])\",\n \"def addPair(self, symbol, address):\\r\\n self.s_table[symbol] = address\",\n \"def post_interface_route_table_create(self, resource_dict):\\n pass\",\n \"def addMapping(self, baseType, refType):\\n if not self.apiName(baseType) or not self.apiName(refType):\\n self.logMsg('diag', 'ScriptOutputGenerator::addMapping: IGNORE map from', baseType, '<->', refType)\\n return\\n\\n self.logMsg('diag', 'ScriptOutputGenerator::addMapping: map from',\\n baseType, '<->', refType)\\n\\n if baseType not in self.mapDict:\\n baseDict = {}\\n self.mapDict[baseType] = baseDict\\n else:\\n baseDict = self.mapDict[baseType]\\n if refType not in self.mapDict:\\n refDict = {}\\n self.mapDict[refType] = refDict\\n else:\\n refDict = self.mapDict[refType]\\n\\n baseDict[refType] = None\\n refDict[baseType] = None\",\n \"def AddStudent(self, event):\\n pass\",\n \"def register_tutor(self, **fields):\\n if 'tutor_key' not in fields.keys():\\n raise KeyError('Primary key is missing')\\n existing_fields = [i.name for i in self._db.get_columns('tutors')]\\n needed_fields = {}\\n for key, value in fields.items():\\n if key in existing_fields:\\n needed_fields[key] = value\\n if 'UID' not in needed_fields.keys():\\n needed_fields['UID'] = needed_fields['tutor_key']\\n check = Tutors.get_or_none(tutor_key=needed_fields['tutor_key'])\\n if check is not None:\\n return check\\n new_tutor = Tutors.get_or_create(**needed_fields)\\n return new_tutor\",\n \"def test_create(self):\\n st = SampleTemplate.create(self.metadata, self.new_study)\\n # The returned object has the correct id\\n self.assertEqual(st.id, 2)\\n\\n # The relevant rows to required_sample_info have been added.\\n obs = self.conn_handler.execute_fetchall(\\n \\\"SELECT * FROM qiita.required_sample_info WHERE study_id=2\\\")\\n # sample_id study_id physical_location has_physical_specimen\\n # has_extracted_data sample_type required_sample_info_status_id\\n # collection_timestamp host_subject_id description\\n exp = [[\\\"2.Sample1\\\", 2, \\\"location1\\\", True, True, \\\"type1\\\", 1,\\n datetime(2014, 5, 29, 12, 24, 51), \\\"NotIdentified\\\",\\n \\\"Test Sample 1\\\", 42.42, 41.41],\\n [\\\"2.Sample2\\\", 2, \\\"location1\\\", True, True, \\\"type1\\\", 1,\\n datetime(2014, 5, 29, 12, 24, 51), \\\"NotIdentified\\\",\\n \\\"Test Sample 2\\\", 4.2, 1.1],\\n [\\\"2.Sample3\\\", 2, \\\"location1\\\", True, True, \\\"type1\\\", 1,\\n datetime(2014, 5, 29, 12, 24, 51), \\\"NotIdentified\\\",\\n \\\"Test Sample 3\\\", 4.8, 4.41]]\\n self.assertEqual(obs, exp)\\n\\n # The relevant rows have been added to the study_sample_columns\\n obs = self.conn_handler.execute_fetchall(\\n \\\"SELECT study_id, column_name, column_type FROM \\\"\\n \\\"qiita.study_sample_columns WHERE study_id=2 \\\"\\n \\\"order by column_name\\\")\\n\\n # study_id, column_name, column_type\\n exp = [[2L, 'int_column', 'integer'], [2, \\\"str_column\\\", \\\"varchar\\\"]]\\n self.assertEqual(obs, exp)\\n\\n # The new table exists\\n self.assertTrue(exists_table(\\\"sample_2\\\", self.conn_handler))\\n\\n # The new table hosts the correct values\\n obs = self.conn_handler.execute_fetchall(\\n \\\"SELECT * FROM qiita.sample_2\\\")\\n # sample_id, str_column\\n exp = [['2.Sample1', 1, \\\"Value for sample 1\\\"],\\n ['2.Sample2', 2, \\\"Value for sample 2\\\"],\\n ['2.Sample3', 3, \\\"Value for sample 3\\\"]]\\n self.assertEqual(obs, exp)\",\n \"def initialize_region(self):\\n self.new_region_name = \\\"\\\"\\n self.map.regions.create_new_region()\",\n \"def register(self):\\n raise NotImplementedError()\",\n \"def register_model(self, model_name: str, model: Any, training_columns: List[str]):\\n self.models[model_name] = (model, training_columns)\",\n \"def registerWithSitemap(self):\\n\\n self.core.requireUniqueService('registerWithSitemap')\\n\\n #from soc.modules.seeder.views import seeder\\n #self.core.registerSitemapEntry(seeder.view.getDjangoURLPatterns())\",\n \"def initiate_new_tag (self,tag,key):\\r\\n\\r\\n #with shelf\\r\\n if self.using_shelf:\\r\\n self.tag_dict[tag] = {key}\\r\\n #with database\\r\\n\\r\\n if self.using_database:\\r\\n\\r\\n value_tuple = (notebookname, tag, key)\\r\\n db_cursor.execute(\\\"INSERT OR REPLACE\\\"\\r\\n +\\\" INTO tags_to_keys\\\"\\r\\n +\\\" (notebook, tag, keyword)\\\"\\r\\n +\\\" VALUES (?,?,?);\\\",\\r\\n value_tuple)\",\n \"def _add_mapping(self, mother_element: GraphElement,\\n daughter_element: GraphElement) -> None:\\n self.mapping[mother_element] = daughter_element\",\n \"def add_students_to_table(students):\\n for student_name, points in students.items():\\n try:\\n Student.create(username=student_name, points=points)\\n except IntegrityError: # IntError occurs when username already exists\\n student_record = Student.get(username=student_name)\\n if student_record.points != points:\\n student_record.points = points\\n student_record.save()\",\n \"def add_location(self, seqid, gene, params, sr):\\n location = dict()\\n aliases = self.get_aliases(sr, seqid)\\n sequence_id = [a for a in aliases if a.startswith('ga4gh')][0]\\n\\n if gene.start != '.' and gene.end != '.' and sequence_id:\\n if 0 <= gene.start <= gene.end:\\n seq_location = models.SequenceLocation(\\n sequence_id=sequence_id,\\n interval=models.SimpleInterval(\\n start=gene.start,\\n end=gene.end\\n )\\n )\\n seq_location._id = ga4gh_identify(seq_location)\\n location = seq_location.as_dict()\\n else:\\n logger.info(f\\\"{params['concept_id']} has invalid interval:\\\"\\n f\\\"start={gene.start} end={gene.end}\\\")\\n return location\",\n \"def add_table(self, table, data_frame, alias=None):\\n if alias is not None:\\n for name in alias:\\n self.alias_map[name] = table\\n self.alias_map[table] = table\\n self.data_frames[table] = data_frame\",\n \"def append_table(self, table):\\n\\n self._db_manager.register_table(table)\",\n \"def _add_pk(self, conn, *, tblname, pk_columns):\\n idx_metadatum = partition_utils.IndexMetadatum(idx_cols=pk_columns, is_unique=True)\\n partition_utils.add_indices(conn, tbl_name=tblname, idx_metadata=[idx_metadatum])\",\n \"def __handle_new_study_form(new_study_form, info_messages, error_messages):\\n if new_study_form.register.data:\\n StudyDAO.get_instance().save(Study.from_study_form(new_study_form))\\n info_messages.append(_(\\\"New study {0} saved\\\".format(new_study_form.name.data)))\\n\\n elif new_study_form.update.data:\\n study = StudyDAO.get_instance().find(new_study_form.id.data)\\n study.update_with_form(new_study_form)\\n StudyDAO.get_instance().update(study)\\n info_messages.append(_(\\\"Study {0} updated\\\".format(study.name)))\",\n \"def _add_mapping(self, mother_element: GraphElement,\\n daughter_element: GraphElement) -> None:\\n pass\",\n \"def register(self):\\n self.validate(True)\\n\\n # If everything works correctly then commit to database.\\n db.session.add(self)\\n db.session.commit()\",\n \"def pre_interface_route_table_create(self, resource_dict):\\n pass\",\n \"def insert_person(self, document, name, birthday, vaccinated):\\n self.__people[document] = Person(document, name, birthday, vaccinated)\",\n \"def create_new_index(self, dict_pg_info):\\n # ! Setting if fun can use default setting\\n ruler = Rules()\\n str_conn = ruler.pg_info_rules(dict_pg_info)\\n conn = psycopg2.connect(str_conn)\\n\\n with conn:\\n with conn.cursor() as cur:\\n str_create_table = \\\"CREATE TABLE \\\" + dict_pg_info['table'] + \\\" (path varchar PRIMARY KEY);\\\"\\n # ! Check if table already exit\\n cur.execute(str_create_table)\\n cur.close()\\n\\n conn.close()\",\n \"def copy_sr_name_to_syn(self, cs, x_db, log_pfx):\\n asm_v = self.asm_name()\\n sql = r'''insert into seq_region_synonym (seq_region_id, synonym, external_db_id)\\n select\\n sr.seq_region_id, sr.name, xdb.external_db_id\\n from\\n seq_region sr, external_db xdb, coord_system cs\\n where xdb.db_name = \\\"%s\\\"\\n and sr.coord_system_id = cs.coord_system_id\\n and cs.name = \\\"%s\\\"\\n and cs.version = \\\"%s\\\"\\n and sr.name like \\\"%%._\\\"\\n ;''' % (x_db, cs, asm_v)\\n return self.run_sql_req(sql, log_pfx)\",\n \"def _mark_study_mapping_update(self, unit_id: str) -> None:\\n self._last_study_mapping_update_times[unit_id] = time.monotonic()\",\n \"def get_study_mapping(self, unit_id: str) -> sqlite3.Row:\\n with self.table_access_condition:\\n conn = self._get_connection()\\n c = conn.cursor()\\n c.execute(\\n \\\"\\\"\\\"\\n SELECT * from studies\\n INNER JOIN units USING (prolific_study_id)\\n WHERE units.unit_id = ?;\\n \\\"\\\"\\\",\\n (unit_id,),\\n )\\n results = c.fetchall()\\n return results[0]\",\n \"def register(self, kw: str, vs: Sequence[str]) -> None:\\n if self._table.get(kw) is not None:\\n self._table[kw] = self._table[kw].union(vs)\\n else:\\n self._table[kw] = set(vs)\",\n \"def register(key, module, module_dict):\\n if key in module_dict:\\n raise KeyError('Key {} is already pre-defined.'.format(key))\\n else:\\n module_dict[key] = module\",\n \"def transfer(self, en_cls, table_name, db_name):\\n self.into_en_map(en_cls, table_name, db_name, create=False)\\n self._start()\",\n \"def register(cls, L):\\r\\n ...\",\n \"def create_season_table(database, data, tbl_name):\\n sql_types = data.get_sql_type()\\n constraint = {UniqueConstraint: [\\\"start_time\\\", \\\"home_team\\\", \\\"away_team\\\"]}\\n database.map_table(tbl_name, sql_types, constraint)\\n database.create_tables()\\n database.insert_rows(tbl_name, data.data)\\n database.clear_mappers() # if mappers aren't cleared, others scripts won't be able to use DBInterface.Template\",\n \"def register(migration):\\n MIGRATIONS[migration.__name__] = migration\",\n \"def post(self):\\n body = request.get_json(force=True)\\n try:\\n st = StudySchema(strict=True).load(body).data\\n except ValidationError as err:\\n abort(400, 'could not create study: {}'.format(err.messages))\\n\\n db.session.add(st)\\n db.session.commit()\\n return StudySchema(\\n 201, 'study {} created'.format(st.kf_id)\\n ).jsonify(st), 201\",\n \"def _register(self, noun):\\n self.noun = noun\",\n \"def register_molecule(self, molecule, name):\\n self[name] = molecule\",\n \"def register(self):\\n raise NotImplementedError(\\\"Should have implemented this\\\")\",\n \"def add_sensor(sensor):\\n if not isinstance(sensor, Sensor):\\n raise TypeError(\\\"pysma.Sensor expected\\\")\\n if get_sensor(sensor.name):\\n _LOGGER.error(\\\"Cannot add sensor. %s already exists\\\", sensor.name)\\n if get_sensor(sensor.key):\\n _LOGGER.error(\\\"Cannot add sensor %s. Key %s already exists\\\",\\n sensor.name, sensor.key)\\n SENSORS.append(sensor)\",\n \"def study_code(self, study_code):\\n\\n self._study_code = study_code\",\n \"def add_row(self, row_id):\",\n \"def register_probe(request):\\n serial_number = request.data['sn']\\n\\n try:\\n probe = Probe.objects.get(sn=serial_number)\\n except Probe.DoesNotExist:\\n probe = None\\n\\n # md = []\\n # for modem in request.data['modems']:\\n # try:\\n # inst_modem = Modem.objects.get(imei=modem['imei'])\\n # except Modem.DoesNotExist:\\n # inst_modem = None\\n # md.append( inst_modem)\\n serializer = ProbeSerializer(probe, data=request.data, partial=True)\\n if serializer.is_valid():\\n serializer.save()\\n return Response(serializer.data, status=status.HTTP_201_CREATED)\\n return Response({\\\"message\\\": _(\\\"Error probe registering!\\\"), 'more': serializer.errors})\",\n \"def register_vocab(self, start_concept, end_concept, alias_of, regex_str):\\n self.register_vocabulary(start_concept, end_concept,\\n alias_of, regex_str)\",\n \"def register_stage(key, module):\\n register(key, module, stage_dict)\",\n \"def register_problem(self, location, name):\\r\\n self.problems[location] = name\",\n \"def add(self, sensor):\\n if isinstance(sensor, (list, tuple)):\\n for sss in sensor:\\n self.add(sss)\\n return\\n\\n if not isinstance(sensor, Sensor):\\n raise TypeError(\\\"pysaj.Sensor expected\\\")\\n\\n if sensor.name in self:\\n old = self[sensor.name]\\n self.__s.remove(old)\\n _LOGGER.warning(\\\"Replacing sensor %s with %s\\\", old, sensor)\\n\\n if sensor.key in self:\\n _LOGGER.warning(\\\"Duplicate SAJ sensor key %s\\\", sensor.key)\\n\\n self.__s.append(sensor)\",\n \"def add(table):\\n id_storage = common.get_values_from_column(table, 0)\\n id_ = common.generate_random(table)\\n table = manage_data_from_user(table, id_storage, id_, False)\\n\\n return table\",\n \"def make_mapping(self) -> None:\\n start_mark = StreamMark('generated node', 0, 0, 0)\\n end_mark = StreamMark('generated node', 0, 0, 0)\\n self.yaml_node = yaml.MappingNode('tag:yaml.org,2002:map', list(),\\n start_mark, end_mark)\",\n \"def __init__(self, uncert=None):\\n super(Smap, self).__init__(uncert)\\n self.res = 0.36\\n self.stddev = 0.001\\n self.tablename = \\\"soilmoist.smap\\\"\",\n \"def createEMPStudy(self, user_id, study_name, investigation_type, miens_compliant, submit_to_insdc, \\n portal_type, study_title, study_alias, pmid, study_abstract, study_description,\\n number_samples_collected, number_samples_promised , lab_person,\\n lab_person_contact, emp_person, first_contact, most_recent_contact, sample_type, \\n has_physical_specimen, has_extracted_data, timeseries, spatial_series,\\n principal_investigator, principal_investigator_contact, default_emp_status, funding,\\n includes_timeseries):\\n con = self.getMetadataDatabaseConnection()\\n study_id = 0\\n results = con.cursor().callproc('qiime_assets.emp_study_insert', \\n [study_id, user_id, study_name,\\n investigation_type, miens_compliant, submit_to_insdc, portal_type, \\n study_title, study_alias, pmid, study_abstract, study_description,\\n number_samples_collected, number_samples_promised , lab_person,\\n lab_person_contact, emp_person, first_contact, most_recent_contact, sample_type, \\n has_physical_specimen, has_extracted_data, timeseries, spatial_series,\\n principal_investigator, principal_investigator_contact, default_emp_status, funding,\\n includes_timeseries])\\n return results[0]\",\n \"def _registerSample(self, prefix, info):\\n self.checkIdentifiersPresent(info)\\n self._prefixToIdentifiers[prefix] = info\",\n \"def addSensor(self, coordinates, epsg, name, status):\\n self.settingsDb.addSensor(coordinates, epsg, name, status)\",\n \"def add(self, pro):\\n self.registry[pro.cell_id] = pro\",\n \"def addObject(self, name, object):\\n self.map[name] = object\",\n \"def initiate_new_word(self,word,index):\\r\\n\\r\\n #with shelf\\r\\n if self.using_shelf:\\r\\n\\r\\n self.word_dict[word] = {str(index)}\\r\\n\\r\\n #with database\\r\\n if self.using_database:\\r\\n\\r\\n value_tuple = (notebookname, word,)\\r\\n db_cursor.execute(\\\"INSERT OR REPLACE\\\"\\r\\n +\\\" INTO all_words (word, notebook)\\\"\\r\\n +\\\" VALUES (?,?);\\\",value_tuple)\\r\\n value_tuple = (notebookname, word, str(index))\\r\\n db_cursor.execute(\\\"INSERT OR REPLACE\\\"\\r\\n +\\\" INTO word_to_indexes (notebook, word, note_index)\\\"\\r\\n +\\\" VALUES (?,?,?);\\\",\\r\\n value_tuple)\",\n \"def node_mapping(self):\\n ...\",\n \"def add_to_series_dict(func):\\n def add(self, *args, **kwargs):\\n s = func(self, *args, **kwargs)\\n self.sid_series[s['id']] = s\\n return s\\n return add\",\n \"def addSpeciesTypeComponentMapInProduct(self, *args):\\n return _libsbml.MultiSpeciesReferencePlugin_addSpeciesTypeComponentMapInProduct(self, *args)\",\n \"def create_scaffold_assignments_table(self):\\n log.info(\\\"Creating table to store Scaffold genus assignments ...\\\")\\n self.create_table(self.ScaffoldsAssignmentsTable ,self.ScaffoldAssignmentsFields,\\n self.ScaffoldAssignmentsTypes)\",\n \"def add_table(\\n self,\\n table: exp.Table | str,\\n column_mapping: t.Optional[ColumnMapping] = None,\\n dialect: DialectType = None,\\n normalize: t.Optional[bool] = None,\\n match_depth: bool = True,\\n ) -> None:\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5860516","0.5694577","0.56291115","0.5563596","0.5524145","0.54332376","0.5419561","0.5383397","0.5380749","0.5315402","0.52709424","0.5228869","0.5204167","0.5195095","0.5187756","0.5159983","0.51177984","0.5053667","0.5052416","0.50509524","0.50397503","0.5037968","0.5015004","0.49910134","0.49910134","0.49910134","0.49861026","0.49861026","0.49759474","0.4954734","0.4948107","0.49433795","0.49024278","0.48991615","0.48976383","0.48969796","0.4890719","0.4882792","0.48738113","0.48690352","0.4855881","0.4853872","0.48510188","0.48491278","0.48484567","0.48397648","0.48366487","0.48351467","0.48295057","0.48206517","0.48206073","0.48164397","0.48102835","0.4807011","0.4804974","0.4802779","0.47936827","0.47927338","0.47898293","0.4788301","0.47854277","0.47737435","0.47719818","0.47711533","0.47677904","0.4767649","0.4765655","0.47516865","0.4747948","0.4747103","0.47422624","0.47383156","0.4737477","0.47277233","0.47094843","0.4708075","0.47079933","0.47074544","0.4705392","0.47024432","0.4695793","0.46864298","0.4686301","0.46821246","0.46807164","0.46713325","0.46635807","0.46628246","0.465773","0.46552554","0.46511912","0.46487796","0.46467906","0.46445495","0.46429312","0.46417797","0.4640229","0.46367142","0.4632531","0.46313503"],"string":"[\n \"0.5860516\",\n \"0.5694577\",\n \"0.56291115\",\n \"0.5563596\",\n \"0.5524145\",\n \"0.54332376\",\n \"0.5419561\",\n \"0.5383397\",\n \"0.5380749\",\n \"0.5315402\",\n \"0.52709424\",\n \"0.5228869\",\n \"0.5204167\",\n \"0.5195095\",\n \"0.5187756\",\n \"0.5159983\",\n \"0.51177984\",\n \"0.5053667\",\n \"0.5052416\",\n \"0.50509524\",\n \"0.50397503\",\n \"0.5037968\",\n \"0.5015004\",\n \"0.49910134\",\n \"0.49910134\",\n \"0.49910134\",\n \"0.49861026\",\n \"0.49861026\",\n \"0.49759474\",\n \"0.4954734\",\n \"0.4948107\",\n \"0.49433795\",\n \"0.49024278\",\n \"0.48991615\",\n \"0.48976383\",\n \"0.48969796\",\n \"0.4890719\",\n \"0.4882792\",\n \"0.48738113\",\n \"0.48690352\",\n \"0.4855881\",\n \"0.4853872\",\n \"0.48510188\",\n \"0.48491278\",\n \"0.48484567\",\n \"0.48397648\",\n \"0.48366487\",\n \"0.48351467\",\n \"0.48295057\",\n \"0.48206517\",\n \"0.48206073\",\n \"0.48164397\",\n \"0.48102835\",\n \"0.4807011\",\n \"0.4804974\",\n \"0.4802779\",\n \"0.47936827\",\n \"0.47927338\",\n \"0.47898293\",\n \"0.4788301\",\n \"0.47854277\",\n \"0.47737435\",\n \"0.47719818\",\n \"0.47711533\",\n \"0.47677904\",\n \"0.4767649\",\n \"0.4765655\",\n \"0.47516865\",\n \"0.4747948\",\n \"0.4747103\",\n \"0.47422624\",\n \"0.47383156\",\n \"0.4737477\",\n \"0.47277233\",\n \"0.47094843\",\n \"0.4708075\",\n \"0.47079933\",\n \"0.47074544\",\n \"0.4705392\",\n \"0.47024432\",\n \"0.4695793\",\n \"0.46864298\",\n \"0.4686301\",\n \"0.46821246\",\n \"0.46807164\",\n \"0.46713325\",\n \"0.46635807\",\n \"0.46628246\",\n \"0.465773\",\n \"0.46552554\",\n \"0.46511912\",\n \"0.46487796\",\n \"0.46467906\",\n \"0.46445495\",\n \"0.46429312\",\n \"0.46417797\",\n \"0.4640229\",\n \"0.46367142\",\n \"0.4632531\",\n \"0.46313503\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.47300953"},"document_rank":{"kind":"string","value":"73"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":920,"numItemsPerPage":100,"numTotalItems":95772,"offset":92000,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTYxNDU5NiwianRpIjoiMTI2Mzg0Y2MtYmUwZC00ZTg2LTgxYjctMTIzM2QxN2Q0NDBhIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU2MTgxOTYsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.jiV-x0KPO-lgp7CoFm0vjVVJykMPO_UukZlzXM0HUK0rhSWerLm-Y49QX2LiqPWQd4xvMLDkE_t5XWlEUjcVDg","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 |
|---|---|---|---|---|---|---|
This function separates features and their corresponding labels for each PMU to make more events | def separatePMUs(X,y):
num_case=X.shape[0]
num_pmu=X.shape[1]
num_sample=X.shape[2]
X=X.reshape(num_case*num_pmu,num_sample)
y2=[]
for i in range(len(y)):
if y[i]==0:
for j in range(num_pmu):
y2.append(0)
elif y[i]==1:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def feature_label(features):\n f=[]\n l=[]\n for item in features:\n f.append(item[0])\n l.append(item[1])\n return f,l",
"def create_features(energy_data, label=None):\n energy_data['date'] = energy_data.index\n energy_data['hour'] = energy_data['Datetime'].dt.hour\n energy_da... | [
"0.62411875",
"0.5955089",
"0.5826313",
"0.56419265",
"0.5625406",
"0.56080455",
"0.55885506",
"0.55627906",
"0.55348414",
"0.54979986",
"0.5487126",
"0.5486808",
"0.54865414",
"0.5469624",
"0.5466418",
"0.5460846",
"0.5440191",
"0.53921473",
"0.53465825",
"0.5327736",
"0.531... | 0.0 | -1 |
Takes the improved heuristic from class one level deeper by calculating number of possible moves next turn for each possible move | def custom_deeper(game, player):
if game.is_loser(player):
return float("-inf")
if game.is_winner(player):
return float("inf")
own_moves = game.get_legal_moves(player)
own_score = 0
for move in own_moves:
newgame = game.forecast_move(move)
newmoves = newgame.get_le... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def heuristic(self, state: ODState) -> int:\n h = 0\n if self.assigned_goals is None:\n for agent in state.new_agents:\n h += self.grid.get_heuristic(agent.coords, agent.color)\n for j in range(len(state.new_agents), len(state.agents)):\n h += self.... | [
"0.69521713",
"0.67710125",
"0.6615086",
"0.6491309",
"0.64138347",
"0.63917",
"0.6388829",
"0.63586897",
"0.6260268",
"0.6230227",
"0.6229315",
"0.6207105",
"0.6206425",
"0.614881",
"0.6136826",
"0.6109114",
"0.6107538",
"0.61038816",
"0.609334",
"0.60888714",
"0.60774225",
... | 0.0 | -1 |
Determines whether there is a continuous partition of at least two squares, and if so, whether the player is on the right side of the barrier | def partition(game, player):
height = game.height
width = game.width
blanks = game.get_blank_spaces()
has_partition = False
partition_col = int(game.width/2)
partition_row = int(game.height/2)
moves = game.get_legal_moves(player)
if moves:
player_location = game.get_player_locati... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bornoff(self, board):\n res = False\n if (self.player):\n if (reduce(lambda x, y: x+y, board.p1vec) < reduce(lambda x, y: x+y, self.board.p1vec)):\n res = True\n else:\n if (reduce(lambda x, y: x+y, board.p2vec) < reduce(lambda x, y: x+y, self.board.p2v... | [
"0.6902577",
"0.67138726",
"0.66304785",
"0.66215175",
"0.6600621",
"0.6472556",
"0.643553",
"0.6338302",
"0.632063",
"0.61761856",
"0.6143342",
"0.6139926",
"0.6075053",
"0.60525346",
"0.6041322",
"0.60189456",
"0.60154474",
"0.6007123",
"0.6003575",
"0.59951377",
"0.5994406... | 0.64387727 | 6 |
Search for the best move from the available legal moves and return a result before the time limit expires. This function must perform iterative deepening if self.iterative=True, and it must use the search method (minimax or alphabeta) corresponding to the self.method value. | def get_move(self, game, legal_moves, time_left):
self.time_left = time_left
# TODO: finish this function!
# Perform any required initializations, including selecting an initial
# move from the game board (i.e., an opening book), or returning
# immediately if there are no lega... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_move(self, game, legal_moves, time_left):\n\n self.time_left = time_left\n move = (-1, -1) #Default\n\n # Perform any required initializations, including selecting an initial\n # move from the game board (i.e., an opening book), or returning\n # immediately if there are n... | [
"0.7615938",
"0.7580609",
"0.75804436",
"0.7556078",
"0.7551935",
"0.7549352",
"0.7547239",
"0.7546612",
"0.749754",
"0.74660885",
"0.74633837",
"0.74536973",
"0.74295133",
"0.74123883",
"0.73986655",
"0.7377251",
"0.7368126",
"0.73495144",
"0.73442507",
"0.73434174",
"0.7336... | 0.77402973 | 0 |
Implement the minimax search algorithm as described in the lectures. (()) | def minimax(self, game, depth, maximizing_player=True):
if self.time_left() < self.TIMER_THRESHOLD:
raise Timeout()
if game.get_legal_moves():
scores = [(self.minvalue(game.forecast_move(move), depth), move) for move in game.get_legal_moves()]
else:
return (s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def aStarSearch(problem, heuristic=nullHeuristic):\r\n\t\"*** YOUR CODE HERE ***\"\r\n\r\n\tfrontera=util.PriorityQueue()\r\n\testadoInicial= problem.getStartState()\r\n\tvisitados=[]\r\n\tnodo = []\r\n\tnodo.append(estadoInicial)\r\n\tnodo.append(0)\r\n\tnodo.append(heuristic(estadoInicial,problem))\r\n\tnodo.app... | [
"0.6886883",
"0.68331116",
"0.68030995",
"0.67912656",
"0.67798316",
"0.6769039",
"0.6715872",
"0.6711444",
"0.6681598",
"0.6645004",
"0.66299355",
"0.6596381",
"0.6581008",
"0.6575264",
"0.6546142",
"0.653921",
"0.653921",
"0.65163356",
"0.65159863",
"0.65128225",
"0.6511745... | 0.0 | -1 |
Implement minimax search with alphabeta pruning as described in the lectures. | def alphabeta(self, game, depth, alpha=float("-inf"), beta=float("inf"), maximizing_player=True):
if self.time_left() < self.TIMER_THRESHOLD:
raise Timeout()
# if depth == 0:
# return(self.score(game,self), (-1,-1))
if game.get_legal_moves():
return self.ab_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def alphabeta_search(state):\r\n \r\n '''\r\n Terminates when game.actions is empty\r\n Class Game needs the following functions:\r\n - game.result(state, a) -- successor\r\n - game.actions(state) -- possible moves\r\n - game.utility -- returns the state of the game (win/lose or ti... | [
"0.7216275",
"0.6970839",
"0.6799403",
"0.67672324",
"0.6670666",
"0.6608765",
"0.6483431",
"0.64301497",
"0.64079326",
"0.63896084",
"0.63590366",
"0.6347302",
"0.6269195",
"0.6225856",
"0.6206144",
"0.62007076",
"0.61828464",
"0.614959",
"0.61449",
"0.61436117",
"0.61001754... | 0.5592482 | 73 |
DO NOT DO THIS. It shows a lack of understanding of set(). | def remove_duplicates_badSolution( li ):
newli=[]
seen = set()
for item in li:
if item not in seen:
seen.add( item )
newli.append(item)
return newli | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set():",
"def set():\n pass",
"def test_set(self):\n a = set()\n a.add('b')\n a.add('c')\n a.add('a')\n b = list(a)\n b.sort()\n self.assertEqual(b, ['a', 'b', 'c'])\n a.remove('b')\n b = list(a)\n b.sort()\n self.assertEqual(b... | [
"0.8495859",
"0.7840319",
"0.7707229",
"0.768068",
"0.7160374",
"0.71357864",
"0.71222466",
"0.6949142",
"0.6856452",
"0.6813004",
"0.6811096",
"0.6811096",
"0.6756013",
"0.6670584",
"0.6515988",
"0.6429255",
"0.6416853",
"0.64092004",
"0.6387745",
"0.636566",
"0.63526124",
... | 0.55986446 | 86 |
project cartesian to spherical surface, resulted in the surface cartesian coordinates | def project_to_sphere(points):
# for uv, the sphere: r=1, azimuth(phi): 2*pi*u, elevation(theta): 2*pi*v
# theta is elevation, phi is azimuth
r, theta, phi = cs.cart2sp(x=points[:, 0], y=points[:, 1], z=points[:, 2])
# logger.info(f"number of zero points in r: {np.sum(r==0)}")
as... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cartesianToSpherical(x=0, y=0, z=0):\n\n hxy = np.hypot(x, y)\n radius = np.hypot(hxy, z)\n altitude = np.arctan2(z, hxy)\n azimuth = np.arctan2(y, x)\n return altitude, azimuth, radius",
"def CartesianToSpherical(Cartesian):\n\n # x,y,z -> r,theta,phi\n x = Cartesian[:,0]\n y ... | [
"0.7355277",
"0.72828305",
"0.71637535",
"0.7123989",
"0.7075414",
"0.7019445",
"0.69850504",
"0.69818425",
"0.6980626",
"0.6977134",
"0.6959282",
"0.6947505",
"0.6928519",
"0.6924944",
"0.6924534",
"0.6891793",
"0.6881375",
"0.6867867",
"0.68466485",
"0.6824763",
"0.6783693"... | 0.7004698 | 6 |
project model points onto a unit cylinder, r=1, h=1. | def project_to_cylinder(points):
r, phi, z = cs.cart2cyl(points[:, 0], points[:, 1], points[:, 2])
# NOTE: z is unchanged
# print(np.array_equal(z, points[:, 2]))
# project onto unit cylinder
x_cyl = points[:, 0] / r
y_cyl = points[:, 1] / r
z_cyl = (z - z.min()) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def makecylinder(model=[0,0,0,1,0,0,1],height = 1,density=10):\n # extract info from cylinder model\n radius = model[6]\n X,Y,Z = model[:3]\n # get 3d points to make an upright cylinder centered to the origin\n n = np.arange(0,360,int(360/density))\n height = np.arange(0,height,height/density)\n ... | [
"0.64186925",
"0.6152617",
"0.6123609",
"0.59477514",
"0.5873414",
"0.5837798",
"0.57903296",
"0.57313627",
"0.57169354",
"0.5623152",
"0.5608285",
"0.5554857",
"0.5532812",
"0.5519945",
"0.5469074",
"0.5449008",
"0.54360414",
"0.54175097",
"0.538803",
"0.53823644",
"0.534602... | 0.7416266 | 0 |
This method takes already downloaded snapshots of a webpage, and extracts the fire data using parse(), and saves it to the datastore, but only if it's not already present. | def run_parsing(archive_directory, data_store, parse):
files = os.listdir(archive_directory)
counter = 0
count_nr = 0
for filename in files:
if not filename.endswith(".html"):
continue
parts = filename[:-len(".html")].split('_')
assert len(parts) == 4
year = i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gather_and_save(url=URL,even_if_old = False):\n \n soup = gather_current(url=url)\n \n try:\n date = get_date(soup)\n except RuntimeError as e:\n now = datetime.now()\n date = datetime(now.year,now.month,now.day,now.hour,now.minute,now.second)\n print('unable to read ... | [
"0.5918881",
"0.5396978",
"0.53650486",
"0.53435403",
"0.5257623",
"0.52304137",
"0.52221036",
"0.5166211",
"0.51637036",
"0.5119081",
"0.50640327",
"0.5053177",
"0.5037533",
"0.5020268",
"0.4983511",
"0.4936361",
"0.49201882",
"0.49062547",
"0.49061346",
"0.48950598",
"0.488... | 0.51060694 | 10 |
Fetch all the snapshots for the website. | def fetch_all_snapshots(archive_dir, wayback_filename, target_url):
# Read the list of snapshots.
with open(wayback_filename) as f:
data = f.read()
url_template = "http://web.archive.org/web/{timestamp}/{target_url}"
snapshots = data.split("\n")
pages_downloaded = 0
pages_failed = 0
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_snapshots(self):\n _url = f\"{self.connector.base_url}/projects/{self.project_id}/snapshots\"\n\n response = self.connector.http_call(\"get\", _url)\n self.snapshots = response.json()",
"def getSnapshots(self):\n snapshots = []\n for x in self.root.goto('CommonDataObjec... | [
"0.7107948",
"0.6342461",
"0.63190186",
"0.6062705",
"0.6008981",
"0.60044056",
"0.59348845",
"0.5923568",
"0.5910609",
"0.58923537",
"0.58885777",
"0.5885084",
"0.58506715",
"0.5839381",
"0.5786904",
"0.5775894",
"0.57698756",
"0.5746789",
"0.5741458",
"0.5722078",
"0.570577... | 0.6720883 | 1 |
Parameters for the experiment. | def experiment_params():
exp = {
'lr': [1e-3],
'loss_function': ['cce'],
'optimizer': ['nadam'],
'dataset': [
# 'curv_contour_length_9',
'cluttered_nist_ix1',
# 'curv_baseline',
]
}
exp['data_augmentations'] = [
[
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parameters(self):\n pass",
"def parameters(self):",
"def params(self):\n return {'cfg': self.cfg,\n 'momentum': self.momentum,\n 'center': self.center,\n 'scale': self.scale,\n 'epsilon': self.epsilon,\n 'act_fn': self.act_fn}",
"def doPara... | [
"0.7732593",
"0.75349516",
"0.75191796",
"0.7332194",
"0.7250805",
"0.7187534",
"0.7182224",
"0.71789974",
"0.7178298",
"0.71517766",
"0.7124579",
"0.70784044",
"0.7071804",
"0.6968503",
"0.6960151",
"0.6955326",
"0.6918996",
"0.68984336",
"0.68870795",
"0.68810993",
"0.68550... | 0.6977438 | 13 |
Create the hgru from Learning longrange... | def build_model(data_tensor, reuse, training):
data_format = 'channels_last'
conv_kernel = [
[3, 3],
[3, 3],
[3, 3],
]
up_kernel = [2, 2]
filters = [28, 36, 48, 64, 80]
with tf.variable_scope('cnn', reuse=reuse):
# Unclear if we should include l0 in the down/upsam... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_l_n_u_ramping(ppc, lower_bound, upper_bound, Nhrs=2):\n \"\"\"lower_bound must be neagtiva, upper_bound must be positive\"\"\"\n gens_hrs = ppc['gen'][:, 0]\n gens_hrs = np.sort(gens_hrs)\n \n n_buses = set_n_buses(ppc, Nhrs)\n n_gens = len(gens_hrs) // 2\n l = np.zeros(n_buses)\n ... | [
"0.61773634",
"0.5845611",
"0.5567021",
"0.55259305",
"0.54361016",
"0.543387",
"0.5337504",
"0.53193784",
"0.5304474",
"0.52276886",
"0.52250886",
"0.5166828",
"0.51488",
"0.51272446",
"0.5125924",
"0.5113933",
"0.51110214",
"0.5092735",
"0.50910956",
"0.5075847",
"0.5075351... | 0.0 | -1 |
Run an experiment with hGRUs. | def main(gpu_device='/gpu:0', cpu_device='/cpu:0'):
config = Config()
params = experiment_params()
model_tools.model_builder(
params=params,
config=config,
model_spec=build_model,
gpu_device=gpu_device,
cpu_device=cpu_device) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(_):\n description = xm.ExperimentDescription(\n 'HIS - trial=%d' % FLAGS.trial, tags=['his'])\n experiment = build_experiment()\n xm.launch_experiment(description, experiment)",
"def run_experiment(hparams):\n\n data_file_name = build_data_file_name(hparams.pair, hparams.time_interval, hparam... | [
"0.62144756",
"0.6207639",
"0.6056002",
"0.58943385",
"0.5853564",
"0.57410383",
"0.56689966",
"0.5646404",
"0.5642825",
"0.55434114",
"0.55428135",
"0.55404645",
"0.5536264",
"0.5517089",
"0.5515994",
"0.54892755",
"0.5484224",
"0.5480752",
"0.547767",
"0.54754966",
"0.54754... | 0.0 | -1 |
constructor for the class | def __init__(self, c_in, c_out, k_size, stride=1, pad=0, bias=True):
super(EqualizedConv2d, self).__init__()
# define the weight and bias if to be used
self.weight = torch.nn.Parameter(torch.nn.init.normal_(
torch.empty(c_out, c_in, *_pair(k_size))
))
self... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self) -> None:\n # TODO: Provide the complete constructor for this object",
"def __init__ (self):\n pass",
"def __init__ (self) :",
"def __init__(self, **kwds):\n raise NotImplementedError",
"def __init__(self):\n raise NotImplementedError",
"def __init__(self):\n... | [
"0.8734275",
"0.850767",
"0.8463304",
"0.8435188",
"0.83920276",
"0.83920276",
"0.83920276",
"0.83920276",
"0.82765424",
"0.8235263",
"0.8235263",
"0.8235263",
"0.8217727",
"0.8217727",
"0.8217727",
"0.8217727",
"0.8217727",
"0.8217727",
"0.8217727",
"0.8217727",
"0.8217727",... | 0.0 | -1 |
forward pass of the network | def forward(self, x):
return torch.conv2d(input=x,
weight=self.weight * self.scale, # scale the weight on runtime
bias=self.bias if self.use_bias else None,
stride=self.stride,
padding=self.pad) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward_pass(self):",
"def forward(self, x):\n return self.net(x)",
"def _forward(self, z):\n raise NotImplementedError(\"Forward shouldn't be called!\")",
"def forward(self):\n pass",
"def forward(self):\n pass",
"def forward(self, input):\n\n return self.network(input... | [
"0.73186237",
"0.71834505",
"0.7120856",
"0.7108922",
"0.7108922",
"0.7095405",
"0.7095405",
"0.7095405",
"0.70948553",
"0.7050654",
"0.69926625",
"0.6936527",
"0.68624467",
"0.6837398",
"0.6822475",
"0.67939997",
"0.67933697",
"0.67824763",
"0.67761517",
"0.67700446",
"0.675... | 0.0 | -1 |
constructor for the class | def __init__(self, c_in, c_out, k_size, stride=1, pad=0, bias=True):
super(EqualizedDeconv2d, self).__init__()
# define the weight and bias if to be used
self.weight = torch.nn.Parameter(torch.nn.init.normal_(
torch.empty(c_in, c_out, *_pair(k_size))
))
se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self) -> None:\n # TODO: Provide the complete constructor for this object",
"def __init__ (self):\n pass",
"def __init__ (self) :",
"def __init__(self, **kwds):\n raise NotImplementedError",
"def __init__(self):\n raise NotImplementedError",
"def __init__(self):\n... | [
"0.8734275",
"0.850767",
"0.8463304",
"0.8435188",
"0.83920276",
"0.83920276",
"0.83920276",
"0.83920276",
"0.82765424",
"0.8235263",
"0.8235263",
"0.8235263",
"0.8217727",
"0.8217727",
"0.8217727",
"0.8217727",
"0.8217727",
"0.8217727",
"0.8217727",
"0.8217727",
"0.8217727",... | 0.0 | -1 |
forward pass of the layer | def forward(self, x):
return torch.conv_transpose2d(input=x,
weight=self.weight * self.scale, # scale the weight on runtime
bias=self.bias if self.use_bias else None,
stride=self.stride,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, input):\n return self.layers(input)",
"def forward(self, x):\n return self.layers(x)",
"def __feed_forward(self, X):\n # go over all layers\n for layer in self.__layers:\n X = layer.compute_act(X)\n\n return X",
"def _forward(self):\n\n t... | [
"0.7367367",
"0.73399484",
"0.7315237",
"0.72809756",
"0.7266685",
"0.72531646",
"0.72451967",
"0.7235675",
"0.72132516",
"0.7186353",
"0.7180268",
"0.7173166",
"0.71502644",
"0.7145505",
"0.7143514",
"0.71366554",
"0.7135957",
"0.7118842",
"0.70899886",
"0.70655066",
"0.7061... | 0.0 | -1 |
forward pass of the module | def forward(self, x, alpha=1e-8):
y = x.pow(2.).mean(dim=1, keepdim=True).add(alpha).sqrt() # [N1HW]
y = x / y # normalize the input x volume
return y | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward_pass(self):",
"def forward(self):\n pass",
"def forward(self):\n pass",
"def forward(self)->None:",
"def forward(self,input):\n\t\traise RuntimeError(\"All subclasses of Module must implement a forward method\")",
"def forward(self, *args, **kwargs):\n pass",
"def forwa... | [
"0.85779595",
"0.8085728",
"0.8085728",
"0.80816996",
"0.76255274",
"0.7576623",
"0.7449357",
"0.7449357",
"0.7302465",
"0.7278256",
"0.7218454",
"0.7218454",
"0.7218454",
"0.72112536",
"0.71955615",
"0.71460116",
"0.7123813",
"0.70815426",
"0.7080172",
"0.7046183",
"0.699500... | 0.0 | -1 |
forward pass of the layer | def forward(self, x, alpha=1e-8):
batch_size, _, height, width = x.shape
# [B x C x H x W] Subtract mean over batch.
y = x - x.mean(dim=0, keepdim=True)
# [1 x C x H x W] Calc standard deviation over batch
y = torch.sqrt(y.pow(2.).mean(dim=0, keepdim=False) + alpha)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward(self, input):\n return self.layers(input)",
"def forward(self, x):\n return self.layers(x)",
"def __feed_forward(self, X):\n # go over all layers\n for layer in self.__layers:\n X = layer.compute_act(X)\n\n return X",
"def _forward(self):\n\n t... | [
"0.7367367",
"0.73399484",
"0.7315237",
"0.72809756",
"0.7266685",
"0.72531646",
"0.72451967",
"0.7235675",
"0.72132516",
"0.7186353",
"0.7180268",
"0.7173166",
"0.71502644",
"0.7145505",
"0.7143514",
"0.71366554",
"0.7135957",
"0.7118842",
"0.70899886",
"0.70655066",
"0.7061... | 0.0 | -1 |
Evaluate modules in stack, starting at module start. When stack is fitting (valmode is False), simply calls mod.evaluate() for each module in the stack. However, when the stack is testing (valmode is True), evaluate first calls an est/val function to create a list of validation datasets ("nest"). It then extracts the f... | def evaluate(self, start=0):
if self.valmode and self.meta['nests'] > 0:
# new nested eval, doesn't require special evaluation procedure
# by modules. instead, all the remapping and collecting of val
# data from each nest handled inside this evaluation function.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate_old(self, start=0):\n\n if self.valmode and self.nests > 0:\n # evaluate using the old nesting scheme devised by Noah\n # this section is deprecated and should be deleted\n\n log.info('Evaluating nested validation data')\n mse_idx = ut.utils.find_modu... | [
"0.68430686",
"0.6166602",
"0.55665743",
"0.5501617",
"0.54066515",
"0.54039",
"0.53980684",
"0.53958213",
"0.53774875",
"0.5376684",
"0.537446",
"0.53603584",
"0.52973723",
"0.52973723",
"0.52973723",
"0.52870274",
"0.5280845",
"0.52624315",
"0.52150756",
"0.5192127",
"0.516... | 0.77966243 | 0 |
DEPRECATED new evaluate remove old nested code | def evaluate_old(self, start=0):
if self.valmode and self.nests > 0:
# evaluate using the old nesting scheme devised by Noah
# this section is deprecated and should be deleted
log.info('Evaluating nested validation data')
mse_idx = ut.utils.find_modules(self, 'm... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate(self, tree):\n\t\tpass",
"def evaluate(self):\n pass",
"def evaluate(self):\n pass",
"def evaluate(compiled_expression):",
"def evaluate(self) :\n pass",
"def eval(self):\n pass",
"def eval(self):\n pass",
"def eval(self):\n pass",
"def evaluat... | [
"0.69647765",
"0.6759526",
"0.6759526",
"0.67196566",
"0.66116154",
"0.65223426",
"0.65223426",
"0.65223426",
"0.62965846",
"0.6202219",
"0.6188042",
"0.61476445",
"0.6125099",
"0.6103021",
"0.60791487",
"0.60703933",
"0.6064442",
"0.6027227",
"0.599475",
"0.5913179",
"0.5901... | 0.0 | -1 |
Creates an instance of a module and appends it to the stack. Evaluates module in doing so. | def append(self, mod=None, **xargs):
if mod is None:
raise ValueError('stack.append: module not specified')
else:
m = mod(self, **xargs)
self.append_instance(m) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def append_instance(self, mod=None):\n if not mod:\n raise ValueError('stack.append: module not specified')\n # mod=nm.nems_module(self)\n self.modules.append(mod)\n self.data.append(mod.d_out)\n self.mod_names.append(mod.name)\n self.mod_ids.append(mod.idm)... | [
"0.6760236",
"0.6550509",
"0.6345163",
"0.6314663",
"0.61647755",
"0.61131513",
"0.6065246",
"0.6036257",
"0.60330945",
"0.59615767",
"0.59563684",
"0.5880003",
"0.58381915",
"0.58381915",
"0.5812597",
"0.58002234",
"0.5770744",
"0.5749715",
"0.5648677",
"0.5580021",
"0.55725... | 0.5783253 | 16 |
Same as append but takes an instance of a module instead of the class to preserve existing xargs. For use with insert/remove. Could maybe merge these with an added boolean arg? Wasn't sure if that would interfere with the xargs. | def append_instance(self, mod=None):
if not mod:
raise ValueError('stack.append: module not specified')
# mod=nm.nems_module(self)
self.modules.append(mod)
self.data.append(mod.d_out)
self.mod_names.append(mod.name)
self.mod_ids.append(mod.idm)
mo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def append(self, mod=None, **xargs):\n if mod is None:\n raise ValueError('stack.append: module not specified')\n else:\n m = mod(self, **xargs)\n self.append_instance(m)",
"def append(self, *args):\n self.add(*args)",
"def append(self, *__args): # real signature u... | [
"0.6353173",
"0.6127798",
"0.6106511",
"0.60686415",
"0.60615456",
"0.60283005",
"0.60082567",
"0.58047557",
"0.57165617",
"0.55905485",
"0.5451006",
"0.5382351",
"0.53696674",
"0.53086245",
"0.5297358",
"0.52906054",
"0.52289265",
"0.5198917",
"0.51974815",
"0.5194997",
"0.5... | 0.49777904 | 39 |
Creates an instance of a module and appends it to the stack. Evaluates module in doing so. APPEARS TO BE A BUG. Is input a module instance? Or a pointer to the function? | def append_no_eval(self, mod=None, **xargs):
if mod is None:
raise ValueError('stack.append: module not specified')
else:
m = mod(self, **xargs)
self.modules.append(mod)
self.data.append(mod.d_out)
self.mod_names.append(mod.name)
self.mod_ids.appen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def append_instance(self, mod=None):\n if not mod:\n raise ValueError('stack.append: module not specified')\n # mod=nm.nems_module(self)\n self.modules.append(mod)\n self.data.append(mod.d_out)\n self.mod_names.append(mod.name)\n self.mod_ids.append(mod.idm)... | [
"0.6311251",
"0.59774005",
"0.5882799",
"0.5829053",
"0.5824564",
"0.5824564",
"0.57864547",
"0.57864547",
"0.5691889",
"0.5545914",
"0.5527849",
"0.5524098",
"0.5428343",
"0.5415356",
"0.5396696",
"0.5330759",
"0.53257704",
"0.52975297",
"0.5272698",
"0.5255934",
"0.52240497... | 0.56974465 | 8 |
Insert a module at index in stack, then evaluate the inserted module and reappend all the modules that were in the stack previously, starting with the insertion index. | def insert(self, mod=None, idx=None, **xargs):
# if no index is given or index is out of bounds,
# just append mod to the end of the stack
if (not idx) or (idx > len(self.modules) - 1)\
or (idx < -1 * len(self.modules) - 1):
self.append(mod, **xargs)
idx ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def insert(self, index: int, tree: 'Tree') -> None:\n ...",
"def insert(self, indexes: Tuple[int, ...], tree: 'Tree') -> None:\n ...",
"def insert(self, *a):\r\n return self.stack.insert(*a)",
"def insert_index(self):\n pass",
"def remove(self, idx=None, mod=None, all_idx=False)... | [
"0.5868107",
"0.5672296",
"0.54033864",
"0.5368524",
"0.5336604",
"0.5311128",
"0.5281682",
"0.526412",
"0.5255213",
"0.5232728",
"0.51956016",
"0.5193696",
"0.51654994",
"0.5146614",
"0.51329195",
"0.5129675",
"0.51240057",
"0.509366",
"0.5091687",
"0.5084046",
"0.50813216",... | 0.7795618 | 0 |
Remove the module at the given index in stack, then reappend all modules that came after the removed module. | def remove(self, idx=None, mod=None, all_idx=False):
if mod and not idx:
idx = ut.utils.find_modules(self, mod.name)
if not idx:
log.warn("Module does not exist in stack.")
return
if not all_idx:
# Only remove the instance with... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pop_at(self, index):\n if len(self.stacks[index]) < 1:\n return\n popped = self.stacks[index].pop()\n if index == len(self.stacks)-1:\n return popped\n for i in range(index, len(self.stacks)-1):\n # append to last operation\n self.stacks[i... | [
"0.62720364",
"0.6165815",
"0.6154364",
"0.6141485",
"0.58771044",
"0.580344",
"0.57758456",
"0.56776845",
"0.5672032",
"0.56380874",
"0.56142616",
"0.5602583",
"0.5561665",
"0.5540167",
"0.5531981",
"0.5488315",
"0.5434079",
"0.54173774",
"0.5400926",
"0.5400379",
"0.5378563... | 0.70490533 | 0 |
For remove and insert wasn't sure if the original popmodule method had a specific usecase, so I didn't want to modify it. Can merge the two if these changes won't cause issues. Removes the last module from stack lists, along with its corresponding data and name (and id?). | def popmodule_2(self):
m = self.modules.pop(-1)
self.data.pop(-1)
self.mod_names.pop(-1)
# Doesn't look like this one is being used yet?
# self.mod_ids.pop(-1)
return m | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(self):\n return self.stack_list.pop()",
"def pop():",
"def delete_stack(Name=None):\n pass",
"def delModule(name):",
"def pop(self):",
"def pop(self):",
"def pop(self):\n del self.args[self.type_stack.pop()]\n self.id_stack.pop()",
"def popleft(self):\n return... | [
"0.6424905",
"0.60469043",
"0.6003137",
"0.59415084",
"0.5937875",
"0.5937875",
"0.59241915",
"0.5911617",
"0.5885596",
"0.581243",
"0.5812425",
"0.5803043",
"0.5738069",
"0.5673044",
"0.5652739",
"0.5649205",
"0.56475323",
"0.5647359",
"0.5626168",
"0.56206787",
"0.56127673"... | 0.78367704 | 0 |
Copy of quick_plot for easy save or embed. | def quick_plot_save(self, mode='png'):
batch = self.meta['batch']
cellid = self.meta['cellid']
modelname = self.meta['modelname']
fig = plt.figure(figsize=(8, 9))
plot_set = []
for idx, m in enumerate(self.modules):
if m.auto_plot:
plot_set.ap... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_plot(self, ):\n pass",
"def showPlot1(): \n raise NotImplementedError",
"def showPlot2():\n raise NotImplementedError",
"def defineQuickplot(self, file, var):\n if self.quickplotItem is None:\n self.quickplotItem = QDefinedVariableItem(file, var, 'quickplot')\n ... | [
"0.6487135",
"0.636231",
"0.6337448",
"0.6284134",
"0.62655956",
"0.6180178",
"0.61296946",
"0.6100648",
"0.5995507",
"0.598488",
"0.58660775",
"0.58647877",
"0.58567715",
"0.5847191",
"0.58060396",
"0.5795975",
"0.5787422",
"0.5727069",
"0.5726445",
"0.57166964",
"0.5672869"... | 0.6503567 | 0 |
Return the creation time of the script | def get_source_ctime(self):
return self.source_file_ctime | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def creation_time(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"creation_time\")",
"def creation_time(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"creation_time\")",
"def creation_timestamp(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"creation_timestamp\"... | [
"0.79180104",
"0.79180104",
"0.77224886",
"0.764707",
"0.75584537",
"0.75584537",
"0.75584537",
"0.7465545",
"0.7465545",
"0.7465545",
"0.73698586",
"0.73372173",
"0.7325024",
"0.7325024",
"0.7325024",
"0.7325024",
"0.7325024",
"0.7325024",
"0.7325024",
"0.7325024",
"0.732502... | 0.65311104 | 81 |
Set the source path | def set_source_path(self, folder):
self.source_path = folder | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setSourcePath(self, sourcePath):\n self.__sourcePath = sourcePath",
"def set_source_file(self, source_file):\n self.set_attribute(\"source_file\", source_file)",
"def set_source(self, source):\n self.data['source'] = source",
"def set_source(self, source_name):\n self.source =... | [
"0.83226603",
"0.74998415",
"0.71865904",
"0.7161414",
"0.70848644",
"0.707815",
"0.7022367",
"0.7016785",
"0.6977186",
"0.6977186",
"0.6977186",
"0.6977186",
"0.6977186",
"0.6977186",
"0.6977186",
"0.6824116",
"0.6796334",
"0.67032343",
"0.6652705",
"0.65941703",
"0.65592533... | 0.8053338 | 1 |
Get the source path | def get_source_path(self):
return self.source_path | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def source_file_path(self) -> str:\n return self._source_file_path",
"def GetSrc():\n return os.path.abspath(os.path.join(_THIS_DIR, os.pardir, os.pardir,\n os.pardir))",
"def path(self) -> str:\n return self.src + \"/\"",
"def get_source_file(self):\n ... | [
"0.8576688",
"0.8262134",
"0.79809034",
"0.7795228",
"0.77610385",
"0.7651921",
"0.76108766",
"0.7521036",
"0.75103116",
"0.75041884",
"0.7452256",
"0.7439682",
"0.7434683",
"0.73519576",
"0.73273706",
"0.7324913",
"0.7315504",
"0.72917026",
"0.72893727",
"0.72733146",
"0.727... | 0.8933967 | 0 |
Merge another object into this | def merge_object(self, obj):
for key, value in obj.lines.items():
if key not in self.lines:
self.lines[key] = value
self.lines[key] = self.lines[key] + value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge(self, obj):\n pass",
"def __add__(self, other):\n self.__dict__.update(other)\n return self",
"def _merge(self, other: dict):\n self._storage = dict_merge(self._storage, other)",
"def update(self, other):\n _merge_dicts(self, other)",
"def merge_from(self, other... | [
"0.7956597",
"0.732633",
"0.7240118",
"0.71760553",
"0.71563464",
"0.7126134",
"0.7017946",
"0.7015831",
"0.69688225",
"0.6816199",
"0.6761192",
"0.67535526",
"0.67506856",
"0.67034584",
"0.66704005",
"0.66545653",
"0.65906477",
"0.6574199",
"0.65532863",
"0.6475579",
"0.6474... | 0.6341723 | 27 |
Read content of a file | def read_file(name):
with open(name, 'r') as my_file:
return my_file.read().encode('utf-8') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __read_file(self, filename):\n with open(filename) as f:\n content = f.readlines()\n \n return content",
"def readContent(file):\n \n with open(file, \"r\", encoding = \"utf-8\") as f:\n return f.read()",
"def read_file():\n with open(FILE_NAME) as f:\n ... | [
"0.78922",
"0.7823199",
"0.7789081",
"0.7772455",
"0.77680683",
"0.776779",
"0.7736673",
"0.7735722",
"0.7685032",
"0.76653844",
"0.76480156",
"0.7647617",
"0.76447254",
"0.7622267",
"0.7586751",
"0.7577363",
"0.7576444",
"0.7574166",
"0.7567519",
"0.75650775",
"0.7549918",
... | 0.0 | -1 |
Retrieves the base MAC address for the module | def get_base_mac(self):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __get_mac_address(self):\n str_hex_mac = uuid.UUID(int=uuid.getnode()).hex[-12:]\n return str_hex_mac",
"def _get_mac_address():\n if not sys.platform.startswith('linux'):\n raise RuntimeError(\n 'Cannot get the MAC address on non-Linux platforms'\n )... | [
"0.7351595",
"0.73193",
"0.7172374",
"0.7152699",
"0.7143644",
"0.69826794",
"0.6948817",
"0.6934663",
"0.6881184",
"0.68360406",
"0.6744061",
"0.6730958",
"0.6698504",
"0.66975266",
"0.66299105",
"0.6609018",
"0.6609018",
"0.65955216",
"0.65718997",
"0.6496191",
"0.6475652",... | 0.80171996 | 0 |
Retrieves the hardware serial number for the module | def get_serial_number(self):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_serial_number(self):\n serial = create_string_buffer(64)\n self._dll.ShamrockGetSerialNumber(self._device, serial)\n return serial.value",
"def _usb_serial_number(self):\n return self.device.serial_number",
"async def get_serial_number(self):\n\n # Display info messag... | [
"0.78120714",
"0.7797088",
"0.7707035",
"0.7703776",
"0.7686934",
"0.7686934",
"0.7664357",
"0.7615573",
"0.75634897",
"0.7562538",
"0.75479317",
"0.7481692",
"0.74116325",
"0.73116183",
"0.7303067",
"0.72941494",
"0.7286045",
"0.7273102",
"0.7243157",
"0.72151095",
"0.719303... | 0.72601914 | 18 |
Retrieves a list of the names of components available on the module (e.g., BIOS, CPLD, FPGA, etc.) | def get_component_name_list(self):
return self._component_name_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chipset_driver_modules(self):\n\t\treturn self.__info_dict['info']['chipset_driver_modules']['value']",
"def list_components(self) -> Dict[str, Any]:\n return self._manager.list_components()",
"def getModuleNames():\n import setup\n names = [e.name[1:] for e in setup.wxpExtensions]\n return... | [
"0.675362",
"0.6675968",
"0.6539068",
"0.6341745",
"0.63289636",
"0.62775135",
"0.6247974",
"0.62147105",
"0.6186656",
"0.6176592",
"0.6158209",
"0.6141283",
"0.6056836",
"0.605391",
"0.60498637",
"0.6042864",
"0.6035058",
"0.602026",
"0.59946656",
"0.59918433",
"0.59878767",... | 0.6718576 | 1 |
Retrieves platformspecific hardware/firmware versions for chassis componenets such as BIOS, CPLD, FPGA, etc. | def get_firmware_version(self, component_name):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_system_hardware(self):\n return self._get_system_status()[\"hardware\"]",
"def fusion_api_get_server_hardware_firmware_compliance(self, body, api=None, headers=None):\n return self.sh.post(body=body, param='/firmware-compliance', api=api, headers=headers)",
"def get_hardware_revision():\... | [
"0.69610465",
"0.68509316",
"0.6848931",
"0.6831852",
"0.66676843",
"0.66630316",
"0.6598765",
"0.6556715",
"0.6542124",
"0.6444984",
"0.63885117",
"0.6317167",
"0.6309591",
"0.63018423",
"0.6282868",
"0.62512887",
"0.6211539",
"0.61840796",
"0.6073738",
"0.60699904",
"0.6069... | 0.580876 | 35 |
Install firmware to component | def install_component_firmware(self, component_name, image_path):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def install_firmware(self, firmware_file_path: str) -> None:\n raise NotImplementedError()",
"def install_firmware(self, image_path):\n \"\"\"Not Implement\"\"\"\n return False",
"def install_firmware(self, pbz_path, recovery=False):\n\n\t\tresources = None\n\t\twith zipfile.ZipFile(pb... | [
"0.7489954",
"0.73957425",
"0.70389396",
"0.68635696",
"0.6861828",
"0.67708874",
"0.67589694",
"0.67289037",
"0.6711583",
"0.66553813",
"0.64939946",
"0.6420946",
"0.63295645",
"0.6287184",
"0.62524647",
"0.61841255",
"0.61578",
"0.60796416",
"0.6072762",
"0.6050385",
"0.604... | 0.7738532 | 0 |
Retrieves the number of fan modules available on this module | def get_num_fans(self):
return len(self._fan_list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def module_count(self):\n return self._module_count",
"def get_count():\n _check_init()\n return _pypm.CountDevices()",
"def get_number_of_devices(self):\n return self.drt_manager.get_number_of_devices()",
"def get_binmodule_total_count(self):\n count = 0\n for binmodule in self.bin... | [
"0.73260516",
"0.7013798",
"0.6597507",
"0.6501957",
"0.6473484",
"0.62529796",
"0.6124135",
"0.60928494",
"0.60834587",
"0.6067455",
"0.6065879",
"0.60154957",
"0.59416884",
"0.5927844",
"0.5919875",
"0.5899991",
"0.5868542",
"0.58482015",
"0.58237135",
"0.58183867",
"0.5790... | 0.68157643 | 2 |
Retrieves all fan modules available on this module | def get_all_fans(self):
return self._fan_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def modules(self):\n return self._modules",
"def modules(self):\n return self.rpc.call(MsfRpcMethod.SessionCompatibleModules, [self.sid])['modules']",
"def modules_registered(self) -> list[Module]:\n return [cmds[0].module for cmds in self._registry[\"by_module\"].values()]",
"def module... | [
"0.67131376",
"0.6539543",
"0.6491338",
"0.64531904",
"0.64291096",
"0.64291096",
"0.64112544",
"0.6351758",
"0.63013667",
"0.627619",
"0.6173613",
"0.6157963",
"0.6102885",
"0.6081959",
"0.60808706",
"0.60690796",
"0.6047247",
"0.6045077",
"0.6019263",
"0.59584165",
"0.59384... | 0.6414935 | 6 |
Retrieves fan module represented by (0based) index | def get_fan(self, index):
fan = None
try:
fan = self._fan_list[index]
except IndexError:
sys.stderr.write("Fan index {} out of range (0-{})\n".format(
index, len(self._fan_list)-1))
return fan | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_index(self):\n\t\treturn call_sdk_function('PrlBootDev_GetIndex', self.handle)",
"def index(self):\n return self._data.get('index')",
"def get(self, index):\n raise NotImplementedError() # pragma: no cover",
"def index(self):\n return self.container['index']",
"def index(self) ... | [
"0.6386185",
"0.58992296",
"0.5883011",
"0.58483106",
"0.5820761",
"0.5784802",
"0.56571335",
"0.56555796",
"0.5613986",
"0.55979806",
"0.5572192",
"0.5569636",
"0.55565727",
"0.5548922",
"0.5546313",
"0.55427456",
"0.554139",
"0.554139",
"0.5529777",
"0.55279493",
"0.5519806... | 0.6381616 | 1 |
Retrieves the number of power supply units available on this module | def get_num_psus(self):
return len(self._psu_list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_power_management() -> int:",
"def get_power(self):\r\n return self._api.get_power()",
"def list_power_supply_units(self):\n\n doc = self.client.enumerate(uris.CIM_PowerSupply)\n\n psus = doc.find('.//s:Body/wsen:EnumerateResponse/wsman:Items',\n wsman.NS_MAP)\n\n ... | [
"0.72453",
"0.67439634",
"0.67290133",
"0.66231495",
"0.65658104",
"0.6514196",
"0.6482216",
"0.64284277",
"0.63828456",
"0.6366741",
"0.6366741",
"0.63495904",
"0.6284794",
"0.62792134",
"0.6273291",
"0.6269788",
"0.6268552",
"0.62483686",
"0.6207047",
"0.62027615",
"0.62027... | 0.0 | -1 |
Retrieves all power supply units available on this module | def get_all_psus(self):
return self._psu_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list_power_supply_units(self):\n\n doc = self.client.enumerate(uris.CIM_PowerSupply)\n\n psus = doc.find('.//s:Body/wsen:EnumerateResponse/wsman:Items',\n wsman.NS_MAP)\n\n return [self._parse_psus(psu) for psu in psus]",
"def get_list_powers(self):\r\n return self.... | [
"0.77775484",
"0.6766033",
"0.66853946",
"0.6468107",
"0.6416482",
"0.6375057",
"0.6272041",
"0.62313294",
"0.62313294",
"0.62275606",
"0.6223866",
"0.6195295",
"0.61867726",
"0.61856294",
"0.6168957",
"0.61667556",
"0.6141389",
"0.60405266",
"0.6037811",
"0.5994922",
"0.5977... | 0.0 | -1 |
Retrieves power supply unit represented by (0based) index | def get_psu(self, index):
psu = None
try:
psu = self._psu_list[index]
except IndexError:
sys.stderr.write("PSU index {} out of range (0-{})\n".format(
index, len(self._psu_list)-1))
return psu | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getPowerIndex(self):\n return self.powerIndex_",
"def unit_at(self, index):\n return self.child_at(index)",
"def list_power_supply_units(self):\n\n doc = self.client.enumerate(uris.CIM_PowerSupply)\n\n psus = doc.find('.//s:Body/wsen:EnumerateResponse/wsman:Items',\n ... | [
"0.6429405",
"0.6376049",
"0.59130216",
"0.5875807",
"0.5830402",
"0.57752043",
"0.574414",
"0.5738909",
"0.5710213",
"0.56981695",
"0.55573934",
"0.5550405",
"0.5523114",
"0.5516067",
"0.5491979",
"0.5477296",
"0.5443224",
"0.5437538",
"0.54343176",
"0.5416655",
"0.54004264"... | 0.5485817 | 15 |
Retrieves the number of thermals available on this module | def get_num_thermals(self):
return len(self._thermal_list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_herbs(self):\n return self._num_herbs",
"def n_thres(self):\n return np.size(self.thres)",
"def module_count(self):\n return self._module_count",
"def thres(self):\n return self._thres",
"def num_tanks(self):\n return len(self._node_reg.tank_names)",
"def get_num_cl... | [
"0.65417665",
"0.64836925",
"0.6480519",
"0.6358993",
"0.61816263",
"0.6166796",
"0.61326504",
"0.6097328",
"0.6085249",
"0.60553885",
"0.60377574",
"0.6029889",
"0.6029889",
"0.60067743",
"0.6000151",
"0.5981292",
"0.59744334",
"0.59277475",
"0.59189385",
"0.58891124",
"0.58... | 0.70140344 | 0 |
Retrieves all thermals available on this module | def get_all_thermals(self):
return self._thermal_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def thres(self):\n return self._thres",
"def listOfTTHalfModules():\n hm = TTModulesMap_instance.dictOfHalfModules\n listOfHalfModules = []\n for ul in hm.keys():\n for reg in hm[ul].keys():\n for module in hm[ul][reg]:\n for halfmod in hm[ul][reg][module]:\n ... | [
"0.62711614",
"0.59908235",
"0.59710574",
"0.5953332",
"0.56614625",
"0.56347954",
"0.5541476",
"0.5494775",
"0.5479787",
"0.5398086",
"0.5393271",
"0.5389046",
"0.53820115",
"0.5353621",
"0.5340566",
"0.53130895",
"0.52500635",
"0.5216711",
"0.51958674",
"0.5191442",
"0.5184... | 0.6584657 | 0 |
Retrieves thermal unit represented by (0based) index | def get_thermal(self, index):
thermal = None
try:
thermal = self._thermal_list[index]
except IndexError:
sys.stderr.write("THERMAL index {} out of range (0-{})\n".format(
index, len(self._thermal_list)-1))
return thermal | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unit_at(self, index):\n return self.child_at(index)",
"def unit_of_measurement(self):\n return 'index'",
"def get_wave_unit(tag, hdulist, idx=None):\n from astropy.units import Unit\n if idx is None:\n idx = 1\n # Use Table\n if isinstance(hdulist[idx],BinTableHDU):\n ... | [
"0.6782312",
"0.6672872",
"0.6465281",
"0.62784415",
"0.61447746",
"0.6080922",
"0.6078993",
"0.60755485",
"0.60755485",
"0.60755485",
"0.5995953",
"0.59833705",
"0.5874957",
"0.5864363",
"0.5839025",
"0.5820442",
"0.5817567",
"0.5805475",
"0.5805475",
"0.57990026",
"0.579775... | 0.7130597 | 0 |
Retrieves the number of sfps available on this module | def get_num_sfps(self):
return len(self._sfp_list) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_count():\n _check_init()\n return _pypm.CountDevices()",
"def get_num_psus(self):\n return len(self._psu_list)",
"def module_count(self):\n return self._module_count",
"def get_spitfp_error_count(self):\n return GetSPITFPErrorCount(*self.ipcon.send_request(self, BrickletBaromet... | [
"0.68690604",
"0.6832386",
"0.6471102",
"0.63796633",
"0.6281832",
"0.6270548",
"0.62695867",
"0.6203247",
"0.6201169",
"0.6189551",
"0.61816835",
"0.6102134",
"0.60676277",
"0.6062961",
"0.6058272",
"0.6052856",
"0.6033939",
"0.60258675",
"0.60258675",
"0.6015374",
"0.601395... | 0.8088208 | 0 |
Retrieves all sfps available on this module | def get_all_sfps(self):
return self._sfp_list | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_sp_policys(self, context):\n # handling policys method in RPC\n response = self.dns_manager.get_sp_policys(context)\n return response",
"def get_services(self):\r\n return get_service_list()",
"def get_num_sfps(self):\n return len(self._sfp_list)",
"def available_se... | [
"0.58436906",
"0.5787607",
"0.57075214",
"0.5639271",
"0.5581612",
"0.55547",
"0.5551602",
"0.55474824",
"0.5540281",
"0.551357",
"0.5476573",
"0.54620093",
"0.54596883",
"0.54454136",
"0.54394895",
"0.5405636",
"0.54031163",
"0.5376224",
"0.5344542",
"0.5316873",
"0.53115666... | 0.8060464 | 0 |
Retrieves sfp represented by (0based) index | def get_sfp(self, index):
sfp = None
try:
sfp = self._sfp_list[index]
except IndexError:
sys.stderr.write("SFP index {} out of range (0-{})\n".format(
index, len(self._sfp_list)-1))
return sfp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, index):\n raise NotImplementedError() # pragma: no cover",
"def GetSashPosition(self, idx):\n assert idx < len(self._sashes)\n return self._sashes[idx]",
"def refFromIndex(index):\n fileno = math.floor(index // 100000)\n frame = index % 100000\n return fileno, frame",
"... | [
"0.60268134",
"0.59960663",
"0.5991602",
"0.5973616",
"0.59693825",
"0.59281826",
"0.5861673",
"0.58611625",
"0.5817246",
"0.58011967",
"0.57925785",
"0.5776426",
"0.57741547",
"0.57703364",
"0.57695585",
"0.5764657",
"0.5751148",
"0.5742006",
"0.5740557",
"0.5737907",
"0.571... | 0.8008134 | 0 |
Returns a nested dictionary containing all devices which have experienced a change in this module | def get_change_event(self, timeout=0):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def devices_dict(self):\n return self.devices.dict",
"def check_device_changes(self):\n\n #---------------------------------------------------------------------------\n # USB ports\n current_serial_devices = self.enumerate_serial_devices()\n\n for device in self.old_serial_devi... | [
"0.6735557",
"0.6673611",
"0.6584133",
"0.6313082",
"0.6209342",
"0.61707854",
"0.61589",
"0.6036916",
"0.59878635",
"0.59700155",
"0.5880778",
"0.5876064",
"0.5835587",
"0.58135825",
"0.5783256",
"0.5775957",
"0.5771707",
"0.57595575",
"0.57500005",
"0.57388914",
"0.573417",... | 0.0 | -1 |
create u_{x} matrix operator using the upwind method. | def create_Ux_mat(x):
dx = x[1] - x[0]
## upwind method based on left cells moving right
## and right cells moving left (similar to a scratch assay)
'''x_int = np.arange(1,len(x)-1,dtype=int)
Ux_mat_row = np.hstack((x_int, x_int))
Ux_mat_col = np.hstack((x_int, x_int[:len(x_int)/2]-1,x... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_Uxx_mat(x):\n \n\n dx = x[1] - x[0]\n \n x_int = np.arange(1,len(x)-1,dtype=int)\n #create u_{xx} matrix operator\n Uxx_mat_row = np.hstack((x_int,x_int,x_int))\n Uxx_mat_col = np.hstack((x_int-1,x_int,x_int+1))\n Uxx_entry = (1/(dx**2))*np.hstack((np.ones(len(x)-2),-2*np.ones(le... | [
"0.6904973",
"0.67573005",
"0.618727",
"0.58783466",
"0.5850389",
"0.57314026",
"0.5695365",
"0.5695365",
"0.56091934",
"0.55918",
"0.5560309",
"0.5517079",
"0.54789305",
"0.547467",
"0.5455033",
"0.5443935",
"0.5443935",
"0.5387152",
"0.537313",
"0.5366446",
"0.53465855",
... | 0.77150667 | 0 |
create u_{xx} matrix operator using central differences. No flux boundaries assumed. | def create_Uxx_mat(x):
dx = x[1] - x[0]
x_int = np.arange(1,len(x)-1,dtype=int)
#create u_{xx} matrix operator
Uxx_mat_row = np.hstack((x_int,x_int,x_int))
Uxx_mat_col = np.hstack((x_int-1,x_int,x_int+1))
Uxx_entry = (1/(dx**2))*np.hstack((np.ones(len(x)-2),-2*np.ones(len(x)-2),(np.on... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_Ux_mat(x):\n \n dx = x[1] - x[0]\n \n ## upwind method based on left cells moving right\n ## and right cells moving left (similar to a scratch assay)\n '''x_int = np.arange(1,len(x)-1,dtype=int)\n Ux_mat_row = np.hstack((x_int, x_int))\n Ux_mat_col = np.hstack((x_int, x_int[:len(... | [
"0.62446815",
"0.62316376",
"0.6046306",
"0.6005687",
"0.59617823",
"0.5938628",
"0.59300697",
"0.58108884",
"0.5771789",
"0.5753315",
"0.5722855",
"0.5706403",
"0.56890017",
"0.5678955",
"0.5677416",
"0.5673115",
"0.5672235",
"0.56281036",
"0.5621129",
"0.56142914",
"0.55678... | 0.69822335 | 0 |
baseline proliferation function (logistic growth) | def f(y):
k = 1.0
return y*(1-y) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def logbasechange(a,b):\n return np.log(b)/np.log(a)",
"def log_prob(self):",
"def compute_log_prior(self,params: ndarray) -> float:\n ln_tE = params[0]\n ln_A0 = params[1]\n ln_deltaT = params[2]\n fbl = params[3]\n mb = params[4]\n\n # Equation (16,15,17) (note th... | [
"0.6772403",
"0.6745147",
"0.6478086",
"0.6426432",
"0.6398961",
"0.6266852",
"0.6225034",
"0.61189485",
"0.6056354",
"0.6019989",
"0.5986453",
"0.5985676",
"0.5963943",
"0.5930226",
"0.5919842",
"0.5898813",
"0.58632284",
"0.5845263",
"0.5842644",
"0.5838407",
"0.5826968",
... | 0.0 | -1 |
RHS for the FisherKPP Equation | def PDE_RHS_FKPP(t,y,q,x,description=None):
D_mat = create_Uxx_mat(x)
return (q[0]*D_mat.dot(y) +
q[1]*y*(1-y)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _fv(self):\n return self.beta * (self.x ** self.c)",
"def calc_k(self):\n\t\n\tself.k = -np.array([self.sth*self.cphi, self.sth*self.sphi, self.cth])\n\n\treturn",
"def _correct_p(self, f0, f1):\n return self.p * np.exp(self.dbeta * (f0 + f1) / 2)",
"def feller(self):\n return 2 * self.k... | [
"0.6517256",
"0.6162716",
"0.6148991",
"0.61416847",
"0.6108718",
"0.6099961",
"0.6089068",
"0.6084212",
"0.60690767",
"0.60681206",
"0.606658",
"0.6007005",
"0.5999013",
"0.59550226",
"0.5952696",
"0.5930681",
"0.5928076",
"0.5914689",
"0.5897699",
"0.5894985",
"0.5892337",
... | 0.59141266 | 18 |
RHS for an inferred Equation | def learned_RHS(t,y,q,x,desc):
Ux_mat = create_Ux_mat(x)
Uxx_mat = create_Uxx_mat(x)
return (q[desc.index('u_{x}')]*Ux_mat.dot(y) +
q[desc.index('u_{xx}')]*Uxx_mat.dot(y) +
q[desc.index('u^2')]*y**2 +
q[desc.index('u')]*y +
q[desc.index('u^2u_{x}'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getRHS(self, freq):\n\n # Get sources for the frequncy(polarizations)\n Src = self.survey.getSrcByFreq(freq)[0]\n S_e = Src.S_e(self)\n return -1j * omega(freq) * S_e",
"def _as_rhs(self):\n raise NotImplementedError",
"def sqrtx():\n return Operator([[(1.+1.j)/2,(1.-1... | [
"0.6772902",
"0.6343115",
"0.6216663",
"0.6203044",
"0.619155",
"0.61267227",
"0.61176705",
"0.61176705",
"0.6101135",
"0.6050898",
"0.6046716",
"0.6016773",
"0.6016773",
"0.6011438",
"0.6001926",
"0.5971846",
"0.59680283",
"0.596132",
"0.59369314",
"0.5900158",
"0.5892403",
... | 0.62597275 | 2 |
Generalized least squares error || (yf)/(f^gamma) ||_2^2 . where f is model , y is data Because of singularity at f=0 , we use MSE for |f| < 1e4 | def RSS_GLS(model,target,gamma):
GLS_domain = np.where(np.abs(model)>1e-4)
OLS_domain = np.where(np.abs(model)<=1e-4)
GLS_res = (model[GLS_domain]-target[GLS_domain])/(np.abs(model[GLS_domain])**gamma)
OLS_res = model[OLS_domain]-target[OLS_domain]
GLS_RSS = np.linalg.norm(GLS_res)**2
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fitGammaErrFun(self, params, x, y, minLum, maxLum):\n if self.eq == 4:\n gamma, a, k = params\n _m = gammaFun(x, minLum, maxLum, gamma, eq=self.eq, a=a, k=k)\n model = numpy.asarray(_m)\n else:\n gamma = params[0]\n _m = gammaFun(x, minLum, m... | [
"0.65444165",
"0.6524985",
"0.6521384",
"0.65144217",
"0.6448623",
"0.6415206",
"0.63830924",
"0.6343939",
"0.63054323",
"0.62762034",
"0.6265394",
"0.62134725",
"0.62062895",
"0.6161292",
"0.6149282",
"0.61463815",
"0.6141959",
"0.61390245",
"0.6115465",
"0.6110745",
"0.6088... | 0.5814023 | 61 |
Simulate 1d inferred PDE models using the method of lines approach | def PDE_sim(q,RHS,x,t,IC,f=f,g=g,description=None):
#grids for numerical integration
t_sim = np.linspace(t[0],t[-1],10000)
x_sim = np.linspace(x[0],x[-1],200)
#interpolate initial condition to new grid
f_interpolate = interpolate.interp1d(x,IC)
y0 = f_interpolate(x_sim)
#indi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tes1():\n m=DynModel()\n m.state('S1',1.0)\n m.state('S2',0.0)\n m.state('S3',0.0)\n m.connect('S1','S2',0.1)\n m.connect('S2','S3',0.1)\n #import pudb; pu.db\n assert len(m.v)==3\n assert len(m.e)==2\n\n m.prepare()\n m.simulate()\n\n #print m.storage.S\n #print m.storag... | [
"0.64934886",
"0.5998914",
"0.59710944",
"0.58593524",
"0.5664626",
"0.5661857",
"0.56392485",
"0.56255305",
"0.55981743",
"0.5583399",
"0.5563944",
"0.5562818",
"0.55403817",
"0.55263066",
"0.55070424",
"0.5461943",
"0.5424968",
"0.5410878",
"0.5400796",
"0.53888154",
"0.537... | 0.0 | -1 |
Create a multi node optimizer from a Chainer optimizer. | def create_multi_node_optimizer(actual_optimizer, communicator):
return _MultiNodeOptimizer(actual_optimizer, communicator) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_optimizer(self, context, optimizer, host):\n pass",
"def create_model_optimizer(net,alpha):\n optimizer = chainer.optimizers.Adam(alpha=alpha)\n optimizer.setup(net)\n return optimizer",
"def __init__(self, optimizer):\n super(ShardedOptimizer, self).__init__(optimizer, name=\"Sha... | [
"0.6300642",
"0.58528394",
"0.56481653",
"0.5557845",
"0.55032265",
"0.5481432",
"0.53838235",
"0.5361062",
"0.5269666",
"0.526538",
"0.52570444",
"0.5236038",
"0.5212935",
"0.5211382",
"0.5195422",
"0.51763874",
"0.51666194",
"0.51596004",
"0.51368475",
"0.5104291",
"0.50813... | 0.77730924 | 0 |
App is in testing config (test_basics.AppTest) | def test_app_is_testing(self):
self.assertTrue(current_app.config['TESTING']) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_config(app):\n assert app.testing",
"def test_config():\n assert not create_app().testing\n assert create_app(TestConfig).testing",
"def test_config():\n assert not sample.create_app().testing\n assert sample.create_app({\"TESTING\": True}).testing",
"def test_app_is_testing(self):\n ... | [
"0.8668405",
"0.85153544",
"0.8505037",
"0.8208351",
"0.8200938",
"0.81275815",
"0.76655614",
"0.7630378",
"0.75359917",
"0.74892235",
"0.745675",
"0.745582",
"0.74472284",
"0.7415486",
"0.73453236",
"0.72559136",
"0.72388124",
"0.72212666",
"0.7210432",
"0.7203444",
"0.71951... | 0.86457294 | 2 |
NAME pmag_results_extract.py DESCRIPTION make a tab delimited output file from pmag_results table SYNTAX pmag_results_extract.py [command line options] OPTIONS h prints help message and quits f RFILE, specify pmag_results table; default is pmag_results.txt fa AFILE, specify er_ages table; default is NONE fsp SFILE, spe... | def main():
dir_path='.'
res_file='pmag_results.txt'
crit_file=''
spec_file=''
age_file=""
latex=0
grade=0
if '-h' in sys.argv:
print main.__doc__
sys.exit()
if '-WD' in sys.argv:
ind = sys.argv.index('-WD')
dir_path=sys.argv[ind+1]
if '-f' in sys.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(argv=None):\n\n if argv is None:\n argv = sys.argv\n\n parser = E.ArgumentParser(description=__doc__)\n\n parser.add_argument(\"--version\", action='version', version=\"1.0\")\n\n parser.add_argument(\n \"-t\", \"--no-titles\", dest=\"titles\", action=\"store_false\",\n he... | [
"0.63927835",
"0.5856338",
"0.5830859",
"0.57654816",
"0.57296544",
"0.56147784",
"0.5584971",
"0.5574084",
"0.5554739",
"0.5493086",
"0.5442651",
"0.543576",
"0.5435534",
"0.53784925",
"0.5375411",
"0.53516924",
"0.5349065",
"0.5295951",
"0.52822334",
"0.5280381",
"0.5262662... | 0.57526374 | 4 |
Set up YoLink Sensor from a config entry. | async def async_setup_entry(
hass: HomeAssistant,
config_entry: ConfigEntry,
async_add_entities: AddEntitiesCallback,
) -> None:
coordinator = hass.data[DOMAIN][config_entry.entry_id][ATTR_COORDINATOR]
devices = [
device for device in coordinator.yl_devices if device.device_type in DEVICE_TY... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, config, sensor=None):\n if sensor is None:\n from monitor.sensor import SensorDriver\n self.sensor = SensorDriver(config.getint(CONFIG_SECTION, \"trigger_pin\"),\n config.getint(CONFIG_SECTION, \"echo_pin\"))\n else:\n ... | [
"0.6584195",
"0.6203388",
"0.584935",
"0.57472384",
"0.5724688",
"0.5683883",
"0.5639066",
"0.5629664",
"0.55922896",
"0.5591893",
"0.55794686",
"0.55689585",
"0.556001",
"0.5545611",
"0.5505439",
"0.55008173",
"0.54948884",
"0.5484322",
"0.5481953",
"0.5474745",
"0.5471682",... | 0.0 | -1 |
Update HA Entity State. | def update_entity_state(self, state: dict) -> None:
self._attr_is_on = self.entity_description.value(
state[self.entity_description.key]
)
self.async_write_ha_state() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def refresh_entity_state(self):",
"def em_update_h(self):\n with self.elbo_check('h'):\n self.update_h()",
"def update_states(self) -> None:\n self.set_states()\n self.async_write_ha_state()",
"def _sun_chaged(hass, entity_id=None, old_state=None, new_state=None):\n P... | [
"0.7127321",
"0.64405394",
"0.6430438",
"0.63795185",
"0.6246587",
"0.6200929",
"0.6177765",
"0.6141028",
"0.60287523",
"0.6006195",
"0.6003928",
"0.6003928",
"0.5998483",
"0.5997044",
"0.5992333",
"0.5991804",
"0.5985489",
"0.59831786",
"0.59779197",
"0.5945326",
"0.5934481"... | 0.74860173 | 0 |
Call setState api to change outlet state. | async def call_state_change(self, state: str) -> None:
try:
# call_device_http_api will check result, fail by raise YoLinkClientError
await self.device.call_device_http_api("setState", {"state": state})
except YoLinkAuthFailError as yl_auth_err:
self.config_entry.asyn... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setState(self, state):\n self.state = state",
"def set_state( self ):",
"def set_state(self,state):\n self.__state = state",
"def set_state(self, state: int):",
"def __change_state(self, state):\n self.state = state",
"def set_state(self, state):\n self.state = state",
"... | [
"0.68303823",
"0.6802729",
"0.6502658",
"0.64432067",
"0.63839674",
"0.63461715",
"0.6259322",
"0.623325",
"0.6202478",
"0.6195493",
"0.6195493",
"0.6194235",
"0.6173578",
"0.6173578",
"0.6173578",
"0.6173578",
"0.6173578",
"0.6173578",
"0.6173578",
"0.6173578",
"0.6173578",
... | 0.5445529 | 94 |
Turn the entity on. | async def async_turn_on(self, **kwargs: Any) -> None:
await self.call_state_change("open") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def turn_on(self, **kwargs):\n self._is_on = True",
"async def async_turn_on(self, **kwargs: Any) -> None:\n await self.entity_description.set_command(self, True)",
"def turn_on(self, **kwargs) -> None:\n self.heater.turn_on()",
"def turn_on(self, **kwargs):\n self._send_command(\... | [
"0.7749855",
"0.76333284",
"0.740764",
"0.7400453",
"0.7380775",
"0.7380276",
"0.73142236",
"0.73142236",
"0.7311529",
"0.72834134",
"0.72247684",
"0.72237045",
"0.7206476",
"0.71866083",
"0.7169044",
"0.71320957",
"0.70755565",
"0.7069967",
"0.69911647",
"0.6968239",
"0.6960... | 0.6187756 | 75 |
Turn the entity off. | async def async_turn_off(self, **kwargs: Any) -> None:
await self.call_state_change("close") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def turn_off(self, **kwargs):\n self._is_on = False",
"def turn_off(self, **kwargs):\n setattr(self.resource, self.variable, False)",
"def turn_off(self, **kwargs):\n set_sonoff_state(self._host, \"off\")\n self._state = False",
"def turn_off(self):\n self.handleCommand(1)\... | [
"0.7907074",
"0.78206724",
"0.7738741",
"0.7726449",
"0.7717234",
"0.7699036",
"0.7569424",
"0.7569424",
"0.75541544",
"0.75168324",
"0.75146556",
"0.7475353",
"0.7410971",
"0.74089587",
"0.7397875",
"0.73854035",
"0.737846",
"0.7305533",
"0.72589344",
"0.72304344",
"0.723010... | 0.0 | -1 |
Create a new Backend instance wrapping a Gremlin endpoint. | def __init__(self, graph: GraphTraversalSource, directed: bool = True):
self._g = graph | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_backend():\n return Connection()",
"def _backend(self) -> Backend:\n return self.__backend",
"def instance():\n from weighted_graph import Graph\n inst = Graph()\n for edge in EDGES:\n inst.add_edge(*edge)\n return inst",
"def __init__(self, backend: Optional[str] = None,... | [
"0.5719169",
"0.5420105",
"0.5374659",
"0.52709556",
"0.52351063",
"0.5146255",
"0.5034128",
"0.49495858",
"0.4898199",
"0.4897327",
"0.4890248",
"0.48857987",
"0.4862044",
"0.48537752",
"0.4850925",
"0.48215622",
"0.48113135",
"0.47861797",
"0.47710606",
"0.4755076",
"0.4748... | 0.0 | -1 |
Return True if the backend graph is directed. The Gremlinbacked datastore is always directed. | def is_directed(self) -> bool:
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_directed(self):\n return self.G.is_directed()",
"def is_directed(self):\n return self.graph_properties.directed",
"def is_directed(self) -> bool:\n return self._directed",
"def is_directed(G):\n return G.is_directed()",
"def is_directed(self):\n return True",
"def is... | [
"0.79627573",
"0.78262556",
"0.7661164",
"0.75749224",
"0.7518689",
"0.746787",
"0.746787",
"0.7348088",
"0.7265645",
"0.7102285",
"0.70416903",
"0.61883163",
"0.61317015",
"0.5777387",
"0.5670721",
"0.5663669",
"0.56486577",
"0.5641953",
"0.563757",
"0.5622453",
"0.5592876",... | 0.7716199 | 2 |
Add a new node to the graph. | def add_node(self, node_name: Hashable, metadata: dict):
if self.has_node(node_name):
# Retrieve the existing node; we will update the props.
v = self._g.V().has(ID, node_name)
else:
v = self._g.addV().property(ID, node_name)
for key, val in metadata.items():
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_node(self, new_node: 'GraphNode'):\n self.operator.add_node(new_node)",
"def add_node(self, node):\n self.nodes.add(node)",
"def add_node (self, node):\n self.network.add_node(node.id)\n self.network.node[node.id] = node",
"def add_node(self, node):\n self.nodes.append(node... | [
"0.86811894",
"0.83628523",
"0.83541214",
"0.8308053",
"0.82507634",
"0.82507634",
"0.8226748",
"0.8140644",
"0.80386716",
"0.8038011",
"0.80355847",
"0.8014513",
"0.79429203",
"0.78899926",
"0.7874701",
"0.7873998",
"0.78708744",
"0.78346735",
"0.7834242",
"0.7813201",
"0.77... | 0.6966002 | 65 |
Return the data associated with a node. | def get_node_by_id(self, node_name: Hashable):
try:
return _node_to_metadata(
self._g.V().has(ID, node_name).valueMap(True).toList()[0]
)
except IndexError as e:
raise KeyError() from e | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data(node):\n return node['data']",
"def node_data(self):\n return self.node_data_",
"def getNodeRRDData(self,node):\n data = self.connect('get','nodes/%s/rrddata' % (node),None)\n return data",
"def data(self):\n return self.first_node.data",
"def get_data(self, node... | [
"0.8943385",
"0.84129703",
"0.7539316",
"0.74589276",
"0.70167655",
"0.6666658",
"0.6666658",
"0.6666658",
"0.6645689",
"0.6542723",
"0.6523832",
"0.6523254",
"0.6523254",
"0.6506541",
"0.6503061",
"0.64450777",
"0.64450777",
"0.64450777",
"0.64450777",
"0.6428722",
"0.642135... | 0.0 | -1 |
Return the data associated with a node. | def has_node(self, u: Hashable) -> bool:
try:
self.get_node_by_id(u)
return True
except KeyError:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_data(node):\n return node['data']",
"def node_data(self):\n return self.node_data_",
"def getNodeRRDData(self,node):\n data = self.connect('get','nodes/%s/rrddata' % (node),None)\n return data",
"def data(self):\n return self.first_node.data",
"def get_data(self, node... | [
"0.8942996",
"0.8413421",
"0.7539084",
"0.74590695",
"0.70172197",
"0.6667136",
"0.6667136",
"0.6667136",
"0.66465026",
"0.654292",
"0.6525485",
"0.6523447",
"0.6523447",
"0.65070415",
"0.65024346",
"0.6445389",
"0.6445389",
"0.6445389",
"0.6445389",
"0.64296985",
"0.64215285... | 0.0 | -1 |
Get a generator of all of the nodes in this graph. | def all_nodes_as_iterable(self, include_metadata: bool = False) -> Generator:
if include_metadata:
return iter(
[
{n[ID][0]: _node_to_metadata(n)}
for n in self._g.V().valueMap(True).toList()
]
)
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nodes_iter(self) -> Generator:\n for n in self.graph.nodes(data=True):\n yield n",
"def all_nodes_as_iterable(self, include_metadata: bool = False) -> Generator:\n if include_metadata:\n return [\n (self._names.get_name(i), self._meta.get_node(self._names.ge... | [
"0.81258786",
"0.7627982",
"0.76152724",
"0.7595835",
"0.7333707",
"0.71609825",
"0.7120504",
"0.70782614",
"0.70782614",
"0.707579",
"0.70283145",
"0.702749",
"0.70215607",
"0.70172447",
"0.69621",
"0.69600874",
"0.69326246",
"0.69045335",
"0.6896022",
"0.68157387",
"0.68079... | 0.7104925 | 7 |
Add a new edge to the graph between two nodes. If the graph is directed, this edge will start (source) at the `u` node and end (target) at the `v` node. | def add_edge(self, u: Hashable, v: Hashable, metadata: dict):
try:
self.get_edge_by_id(u, v)
e = self._g.V().has(ID, u).outE().as_("e").inV().has(ID, v).select("e")
except IndexError:
if not self.has_node(u):
self.add_node(u, {})
if not sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_edge(self, u, v):\n self.graph[u].append(v)",
"def addEdge(self,u,v):\r\n self.graph[u].append(v)",
"def add_edge(self, u, v):\r\n keys = self.d.keys()\r\n #if nodes are not in graph, add them\r\n if u not in keys:\r\n self.add_node(u)\r\n if v not i... | [
"0.80492437",
"0.7997173",
"0.79762274",
"0.7938743",
"0.7901465",
"0.7901465",
"0.78556806",
"0.78218895",
"0.7706609",
"0.7676834",
"0.7642282",
"0.75621843",
"0.75312984",
"0.75273705",
"0.75252885",
"0.75252885",
"0.7497718",
"0.7461967",
"0.74471945",
"0.7438834",
"0.743... | 0.7544242 | 12 |
Get a list of all edges in this graph, arbitrary sort. | def all_edges_as_iterable(self, include_metadata: bool = False) -> Generator:
if include_metadata:
return iter(
[
(e["source"], e["target"], _node_to_metadata(e["properties"]))
for e in (
self._g.V()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def edge_list(self) -> List[Edge]:\r\n return [edge for edge in sorted(self._edges.values(), key=attrgetter(\"key\"))]",
"def edges_list(self):\n return self._edges_list",
"def edges(self):\n es = []\n for vertex1 in self.vertices():\n for vertex2 in self.out_vertices(ver... | [
"0.81581634",
"0.7960234",
"0.78925526",
"0.78804266",
"0.787858",
"0.7846798",
"0.7843813",
"0.7840766",
"0.78385776",
"0.78341746",
"0.78333783",
"0.78333783",
"0.78333783",
"0.78252286",
"0.77562666",
"0.7710486",
"0.77076787",
"0.76781815",
"0.7555799",
"0.7550012",
"0.75... | 0.635042 | 86 |
Get an edge by its source and target IDs. | def get_edge_by_id(self, u: Hashable, v: Hashable):
return (
self._g.V()
.has(ID, u)
.outE()
.as_("e")
.inV()
.has(ID, v)
.select("e")
.properties()
.toList()
)[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_edge(self, source: Node, target: Node) -> Optional[Edge]:\r\n return self.get_edge_by_index(source.index, target.index)",
"def getEdge(source: LNode, target: LNode) -> LEdge:\n for edge in source.getConnectedEdges():\n # [TODO] or is suspicious\n if (edge.dstNode is target) or (ed... | [
"0.7360286",
"0.7078714",
"0.7069812",
"0.6709626",
"0.67029667",
"0.65718555",
"0.6423493",
"0.63100886",
"0.63019335",
"0.6168574",
"0.613733",
"0.6136123",
"0.6105854",
"0.6103135",
"0.60391325",
"0.5967155",
"0.5952662",
"0.59199786",
"0.5867793",
"0.58538455",
"0.5817035... | 0.6502458 | 6 |
Get a generator of all downstream nodes from this node. | def get_node_neighbors(
self, u: Hashable, include_metadata: bool = False
) -> Generator:
if include_metadata:
return {
e["target"]: _node_to_metadata(e["properties"])
for e in (
self._g.V()
.has(ID, u)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def node_gen(self):\n for n in self.child_list:\n yield from n.node_gen\n yield self",
"def dfs_edges_generator(graph, source, reverse=...):\n ...",
"def edges(self):\n for e in self._edges:\n yield e",
"def iteredges(self):\n for source, targets in self.s... | [
"0.6858257",
"0.6851446",
"0.66736126",
"0.6523919",
"0.64740294",
"0.6465135",
"0.6309898",
"0.62987435",
"0.62812954",
"0.61818963",
"0.61600417",
"0.6127758",
"0.6095174",
"0.609357",
"0.609357",
"0.6080855",
"0.6064536",
"0.6004518",
"0.59982306",
"0.5996935",
"0.5993784"... | 0.0 | -1 |
Get a generator of all downstream nodes from this node. | def get_node_predecessors(
self, u: Hashable, include_metadata: bool = False
) -> Generator:
if include_metadata:
return {
e["source"]: e
for e in (
self._g.V()
.has(ID, u)
.inE()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def node_gen(self):\n for n in self.child_list:\n yield from n.node_gen\n yield self",
"def dfs_edges_generator(graph, source, reverse=...):\n ...",
"def edges(self):\n for e in self._edges:\n yield e",
"def iteredges(self):\n for source, targets in self.s... | [
"0.68572813",
"0.6851634",
"0.66723347",
"0.6522355",
"0.64741963",
"0.6464804",
"0.6309863",
"0.62989444",
"0.6280763",
"0.61826336",
"0.61584425",
"0.6127064",
"0.60939986",
"0.60926896",
"0.60926896",
"0.60814744",
"0.6065003",
"0.6003312",
"0.59978014",
"0.5995585",
"0.59... | 0.0 | -1 |
Get an integer count of the number of nodes in this graph. | def get_node_count(self) -> Iterable:
return self._g.V().count().toList()[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def node_count(self):\n return self._node_count",
"def number_of_nodes(self) -> int:\n return self.graph.number_of_nodes()",
"def node_count(self) -> int:\n return pulumi.get(self, \"node_count\")",
"def node_count(self):\n return self._root.count()",
"def node_count(self) -> pu... | [
"0.88012767",
"0.8800309",
"0.8764814",
"0.8713053",
"0.8655607",
"0.8655607",
"0.8641036",
"0.8519778",
"0.8519778",
"0.84884375",
"0.8467727",
"0.8456823",
"0.8451724",
"0.8451724",
"0.84216154",
"0.83909976",
"0.8298621",
"0.8297793",
"0.82299125",
"0.81929344",
"0.8178524... | 0.7848861 | 30 |
Fetching a protected resource using an OAuth 1 token. | def profile():
import hashlib
import binascii
import evernote.edam.userstore.constants as UserStoreConstants
import evernote.edam.type.ttypes as Types
from evernote.api.client import EvernoteClient
auth_token = session['oauth_token']
client = EvernoteClient(token=auth_token,
sand... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def authorized_fetch(self, url, auth_token, **kwargs):\n if isinstance(auth_token, bytes):\n auth_token = auth_token.decode()\n login_header = HTTPHeaders({\n \"Authorization\": \"CustomJWT {}\".format(auth_token)})\n request = HTTPRequest(\n url, headers=login... | [
"0.69519764",
"0.6282885",
"0.61803466",
"0.6128816",
"0.61275697",
"0.6112998",
"0.6103108",
"0.6008591",
"0.59770566",
"0.5919546",
"0.58596146",
"0.584992",
"0.58140063",
"0.5813354",
"0.5797826",
"0.57910305",
"0.5786092",
"0.5781067",
"0.57774854",
"0.5774434",
"0.575760... | 0.0 | -1 |
Class method to decode v1 Tx from a legacy v0 Tx. | def legacy_from_json(cls, obj):
tv = obj.get("version", -1)
if TransactionVersion.LEGACY != tv:
raise Exception(
"legacy v0 transaction is expected to be of version {}, not version {}".format(
TransactionVersion.LEGACY, tv
)
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def decode(code: bytes):# -> Transaction:\n vals: list[str] = str(bytes).split(' ')\n result: Transaction = Transaction()\n result.id = int(vals[0])\n result.time = int(vals[1])\n result.action = string_to_action(vals[2])\n result.acting_username = vals[3]\n result.... | [
"0.59203297",
"0.56318444",
"0.5603222",
"0.5576017",
"0.54629105",
"0.5462759",
"0.53999794",
"0.5362942",
"0.5338377",
"0.5328852",
"0.5315829",
"0.5315829",
"0.5300996",
"0.5256362",
"0.5195768",
"0.5135178",
"0.5074066",
"0.498903",
"0.4982154",
"0.49720398",
"0.49720398"... | 0.59679365 | 0 |
Coin inputs of this Transaction, used as funding for coin outputs, fees and any other kind of coin output. | def coin_inputs(self):
return self._coin_inputs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_coins(self):\n print(\"Please insert coins.\")\n for coin in self.COIN_VALUES:\n self.money_received += int(input(f\"How many {coin}?: \")) * self.COIN_VALUES[coin]\n return self.money_received",
"def coin_outputs(self):\n return self._coin_outputs",
"def process_coins():\r\n ... | [
"0.6123173",
"0.5966245",
"0.5634441",
"0.5558912",
"0.55467415",
"0.55467415",
"0.5481745",
"0.54760975",
"0.54194975",
"0.54084605",
"0.5364558",
"0.5345652",
"0.5327607",
"0.53122216",
"0.5287343",
"0.5282469",
"0.52809083",
"0.5277097",
"0.52711916",
"0.5259964",
"0.52548... | 0.75000954 | 0 |
Coin outputs of this Transaction, funded by the Transaction's coin inputs. | def coin_outputs(self):
return self._coin_outputs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def coin_inputs(self):\n return self._coin_inputs",
"def outputs(self, inputs):\n return inputs",
"def getCoins(self):\n return self.coins",
"def outputs(self):\n return super().outputs",
"def outputs(self):\n return super().outputs",
"def outputs(self):\n return... | [
"0.6787281",
"0.6559575",
"0.6514078",
"0.59406906",
"0.59406906",
"0.59406906",
"0.59406906",
"0.5934072",
"0.59194964",
"0.5907574",
"0.5898513",
"0.58806205",
"0.5828155",
"0.5714257",
"0.56731254",
"0.56292564",
"0.56242514",
"0.5590234",
"0.55890447",
"0.5565225",
"0.555... | 0.79076797 | 0 |
Blockstake inputs of this Transaction. | def blockstake_inputs(self):
return self._blockstake_inputs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def blockstake_outputs(self):\n return self._blockstake_outputs",
"def inputs(self):\n pass",
"def inputs(self):\n return super().inputs",
"def inputs(self):\n return super().inputs",
"def inputs(self):\n return super().inputs",
"def inputs(self):\n return super(... | [
"0.6437797",
"0.6227412",
"0.61687285",
"0.61687285",
"0.61687285",
"0.61687285",
"0.61643004",
"0.60167396",
"0.5892044",
"0.5803583",
"0.5784823",
"0.567815",
"0.5671604",
"0.564129",
"0.564129",
"0.564129",
"0.55738175",
"0.55738175",
"0.55738175",
"0.5549223",
"0.5533055"... | 0.7803568 | 0 |
Blockstake outputs of this Transaction. | def blockstake_outputs(self):
return self._blockstake_outputs | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def outputs(self):\n return super().outputs",
"def outputs(self):\n return super().outputs",
"def outputs(self):\n return super().outputs",
"def outputs(self):\n return super().outputs",
"def outputs(self):\n pass",
"def coin_outputs(self):\n return self._coin_ou... | [
"0.6245822",
"0.6245822",
"0.6245822",
"0.6245822",
"0.62456393",
"0.6083549",
"0.59201723",
"0.58614194",
"0.5824727",
"0.58095473",
"0.5804078",
"0.5786087",
"0.5749186",
"0.5740939",
"0.5719438",
"0.570687",
"0.570687",
"0.5694341",
"0.5688758",
"0.5688758",
"0.5594648",
... | 0.7414077 | 0 |
Miner fees, paid to the block creator of this Transaction, funded by this Transaction's coin inputs. | def miner_fees(self):
return self._miner_fees | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def prepare_funding(self):\n entity_miner = self.entities[0]\n\n entity_miner.send_bitcoins(entity_miner.address)\n entity_miner.purchase_mastercoins(500.0)\n\n self.generate_block()\n self.check_balance(entity_miner.address, MSC, '50000.00000000', '0.00000000')\n self.ch... | [
"0.66922605",
"0.58207643",
"0.581066",
"0.57854795",
"0.57327056",
"0.5670109",
"0.5667312",
"0.56460047",
"0.5637521",
"0.56239104",
"0.56096333",
"0.5599002",
"0.5562422",
"0.5553269",
"0.55527157",
"0.5529413",
"0.55228823",
"0.55146056",
"0.55044276",
"0.5483918",
"0.548... | 0.508458 | 61 |
Optional binary data attached to this Transaction, with a max length of 83 bytes. | def data(self):
if self._data is None:
return BinaryData(strencoding="base64")
return self._data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data(self, data):\n if len(data) > 41:\n self._data = b\"\"\n else:\n self._data = data\n return self._data",
"def as_bytes(self) -> bytes:\n if isinstance(self.data, bytes):\n return self.data\n elif isinstance(self.data, str):\n ... | [
"0.65607315",
"0.61228114",
"0.6119616",
"0.61050373",
"0.5891042",
"0.5891042",
"0.5800566",
"0.5734391",
"0.5688271",
"0.56584054",
"0.5628926",
"0.56091785",
"0.5567403",
"0.5566596",
"0.55665",
"0.55652833",
"0.5525507",
"0.5522612",
"0.5522612",
"0.5522612",
"0.55147225"... | 0.6219342 | 1 |
Binary encoding of a Transaction, overriden to specify the version correctly | def binary_encode(self):
if self._legacy:
return bytearray([TransactionVersion.LEGACY]) + self._binary_encode_data()
encoder = j.data.rivine.encoder_sia_get()
encoder.add_array(bytearray([TransactionVersion.STANDARD]))
encoder.add_slice(self._binary_encode_data())
ret... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __bytes__(self) -> bytes:\n from hathor.merged_mining.bitcoin import encode_bytearray, encode_list\n struct_bytes = self.header_head\n struct_bytes += encode_bytearray(self.coinbase_head)\n struct_bytes += encode_bytearray(self.coinbase_tail)\n struct_bytes += encode_list(sel... | [
"0.6348444",
"0.62601185",
"0.6169922",
"0.61575854",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
"0.61489797",
... | 0.73798925 | 0 |
Convierte el numero en un string en formato moneda SetMoneda(45924.457, 'RD$', 2) > 'RD$ 45,924.46' | def SetMoneda(num, simbolo="$", n_decimales=2):
#con abs, nos aseguramos que los dec. sea un positivo.
n_decimales = abs(n_decimales)
#se redondea a los decimales idicados.
num = round(num, n_decimales)
#se divide el entero del decimal y obtenemos los string
num, dec = str(num).split(".")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def transform(s):\r\n return 'digit ' + str(s)",
"def transform(s):\n return 'digit ' + str(s)",
"def text_transform(val):\n if CURRENCY == \"USD\":\n return \"$%d\" % val\n if CURRENCY == \"EUR\":\n return \"€%d\" % val\n if CURRENCY == \"GBP\":\n return \"£%d\" % val\n ... | [
"0.6369034",
"0.6291154",
"0.61577356",
"0.61298066",
"0.6096125",
"0.6077178",
"0.59460807",
"0.5917721",
"0.5841402",
"0.58112806",
"0.5718429",
"0.57112324",
"0.5696326",
"0.566329",
"0.5642763",
"0.5630994",
"0.56287545",
"0.56125355",
"0.5596081",
"0.5594857",
"0.5593213... | 0.6246501 | 2 |
Callback function for the intent "adaptVolume", gets called when intent is detected | def start_adaptVolume(hermes, intent_message):
#log the input and the received intent
start_logging()
log_asr_input(intent_message.input)
log_received_intent(intent_message)
#extract the desired volume value from the intent message and adapt the volume
volume_value = get_required_volum... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slotVolume(self, a0):\n self.sampleGroup.action('volume', value=a0)",
"def setVolume(intent, session):\n\tif 'volume' in intent['slots']:\n\t\tvolume = intent['slots']['Volume']['value']\n\n\tspeech_output = \"Chromecast Volume set to \" + volume\n\tcard_title = \"ChromeCast - Volume Set to \" + volu... | [
"0.6542319",
"0.6332836",
"0.6268154",
"0.6231558",
"0.62264824",
"0.6061285",
"0.6000607",
"0.59331447",
"0.5866246",
"0.5794333",
"0.5783454",
"0.5674449",
"0.56732404",
"0.5658846",
"0.5651501",
"0.56294245",
"0.5600345",
"0.5582338",
"0.5578721",
"0.5578557",
"0.5527833",... | 0.7289963 | 0 |
Writes geometry and load database items to a file. | def cdwrite(self, option="", fname="", ext="", fnamei="", exti="",
fmat="", **kwargs):
command = f"CDWRITE,{option},'{fname}',{ext},,{fnamei},{exti},{fmat}"
return self.run(command, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_mat_file(self):\n mat_dict = {}\n mat_dict['Lx_p'] = self.Lx_p\n mat_dict['Ly_p'] = self.Ly_p\n mat_dict['Lz_p'] = self.Lz_p\n mat_dict['Lo'] = self.obst.get_Lo()\n mat_dict['Ny_divs'] = self.N_divs\n mat_dict['rho_p'] = self.rho_p\n mat_dict['nu_p'... | [
"0.6128178",
"0.6012342",
"0.59800637",
"0.5937306",
"0.59276754",
"0.5845964",
"0.5839604",
"0.5822085",
"0.5814595",
"0.5770231",
"0.5736637",
"0.57171774",
"0.57083464",
"0.56898177",
"0.56540304",
"0.5653079",
"0.56423223",
"0.56169623",
"0.5611881",
"0.56063175",
"0.5591... | 0.0 | -1 |
An App with 100 tasks already in the queue. Tasks will randomly fail when executed. | def app():
app = App(
name="testapp",
processes=1,
concurrency=4,
prefetch_count=1,
retry_backoff=lambda retries: 0.01,
maintenance_interval=0.1,
schedule_interval=0.1,
heartbeat_interval=0.1,
heartbeat_timeout=1,
grace_period=1,
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_no_more_tasks(self):\r\n self.create()\r\n app = App(short_name='egil', name='egil',\r\n description='egil')\r\n owner = db.session.query(User).get(1)\r\n app.owner_id = owner.id\r\n db.session.add(app)\r\n db.session.commit()\r\n\r\n app_i... | [
"0.7139638",
"0.6872016",
"0.6820473",
"0.64749575",
"0.6203939",
"0.6192355",
"0.61694515",
"0.6168766",
"0.61448485",
"0.6123286",
"0.61067617",
"0.6095766",
"0.6092713",
"0.60915005",
"0.60242605",
"0.60211843",
"0.6011442",
"0.6004388",
"0.5986613",
"0.5975115",
"0.594326... | 0.7122439 | 1 |
Ensure that jobs which sometimes randomly fail will be rescheduled and eventually succeed. Job failures should not crash the worker. | def test_job_failure(app):
with worker(app):
state = wait_for_results(app, length=100, sleep=0.2, maxwait=4)
# Tasks have been delivered and executed.
assert set(r.return_value for r in all_results(app)) == set(range(100))
assert len(state.queue.messages) == 0
# Consumer groups behaved pro... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_retry_errors_sooner(self):\n config_manager, json_file = self._setup_config_manager(\n 'socorro.unittest.cron.test_crontabber.BarBackfillJob|1d\\n'\n 'socorro.unittest.cron.test_crontabber.FooBackfillJob|1d\\n'\n 'socorro.unittest.cron.test_crontabber.FooBarBackfill... | [
"0.70238954",
"0.7021493",
"0.6980119",
"0.67947364",
"0.67771506",
"0.6720906",
"0.66957974",
"0.6615476",
"0.6472577",
"0.6455228",
"0.6385922",
"0.63313305",
"0.6242333",
"0.6215919",
"0.62111884",
"0.62082505",
"0.6191246",
"0.61907566",
"0.61778253",
"0.61403835",
"0.612... | 0.6697551 | 6 |
This test is designed to crash the worker during processing and ensure that when we bring up a new worker, the system fully recovers. To achieve this, we're using a 'sentinel' job which triggers an exception when we try to deserialise it. | def test_worker_failure(app):
sentinel = 50
def mocked_deserialise(fields):
job = Job.deserialise(fields)
if job.args == [sentinel]:
raise Chaos("Found sentinel job")
return job
with mock.patch("fennel.worker.broker.Job", wraps=Job) as mocked_job:
mocked_job.des... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def test_launch_400():\n work_queue = asyncio.Queue()\n await work_queue.put(TestData.JOB_TEMPLATE_LAUNCH_PAYLOAD)\n worker = tower_api_worker.TowerApiWorker(TestData.config, None, work_queue)\n with aioresponses() as mocked:\n mocked.post(\n TestData.JOB_TEMPLATE_POST_URL, stat... | [
"0.6359065",
"0.6358153",
"0.6343971",
"0.62961966",
"0.62398404",
"0.62254554",
"0.6220339",
"0.6151781",
"0.6128433",
"0.61171836",
"0.61096936",
"0.61035645",
"0.6060205",
"0.6046334",
"0.60378677",
"0.60087585",
"0.6002686",
"0.5972724",
"0.5961226",
"0.5950227",
"0.59496... | 0.74951327 | 0 |
Initialize local storage of active agents, connect to the database | def __init__(self, datastore_root: str):
self.session_storage: Dict[str, ProlificClient] = {}
self.agent_data: Dict[str, Dict[str, Any]] = {}
self.table_access_condition = threading.Condition()
self.conn: Dict[int, sqlite3.Connection] = {}
self.db_path = os.path.join(datastore_ro... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initialize_database():\n # TODO: Refactor the funtime library\n this.db = Store(this.host).create_lib(this.store_name).get_store()",
"def init_database():\n exists = Agent.query.all()\n if exists is None or len(exists) == 0:\n # Setting up agent\n agent = Agent(name='OpenCampus',\n ... | [
"0.6617449",
"0.61237335",
"0.5979491",
"0.5936732",
"0.59310615",
"0.5922503",
"0.58505607",
"0.5802189",
"0.57936794",
"0.5789929",
"0.5780297",
"0.5701071",
"0.56965166",
"0.56882364",
"0.56478816",
"0.5633063",
"0.56197894",
"0.5587522",
"0.558614",
"0.55832756",
"0.55672... | 0.558001 | 20 |
Returns a singular database connection to be shared amongst all calls for a given thread. | def _get_connection(self) -> sqlite3.Connection:
curr_thread = threading.get_ident()
if curr_thread not in self.conn or self.conn[curr_thread] is None:
conn = sqlite3.connect(self.db_path, check_same_thread=False)
conn.row_factory = sqlite3.Row
self.conn[curr_thread] ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_connection(self) -> Connection:\n # TODO(101) is there a problem with having just one db connection?\n # Will this cause bugs with failed commits?\n curr_thread = threading.get_ident()\n if curr_thread not in self.conn or self.conn[curr_thread] is None:\n try:\n ... | [
"0.79301536",
"0.74529684",
"0.7043397",
"0.7013358",
"0.6935523",
"0.6571063",
"0.65294355",
"0.6474125",
"0.64452714",
"0.64002967",
"0.6362195",
"0.63587844",
"0.6348218",
"0.634644",
"0.63254464",
"0.6292941",
"0.62925506",
"0.62602526",
"0.6254633",
"0.6221707",
"0.62125... | 0.8007835 | 0 |
Update the last Study mapping time to mark a change to the Study mappings table and allow dependents to invalidate caches | def _mark_study_mapping_update(self, unit_id: str) -> None:
self._last_study_mapping_update_times[unit_id] = time.monotonic() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mapper_updated(self):\n self.invalidate()\n return",
"def memoryMapChanged(self, mem: ghidra.program.database.mem.MemoryMapDB) -> None:\n ...",
"def is_study_mapping_in_sync(self, unit_id: str, compare_time: float):\n return compare_time > self._last_study_mapping_update_times[u... | [
"0.6335052",
"0.58112735",
"0.56721526",
"0.54929096",
"0.5459769",
"0.5457291",
"0.5452044",
"0.54163307",
"0.54032046",
"0.5332193",
"0.52810687",
"0.52514476",
"0.52494526",
"0.52186",
"0.520193",
"0.51904476",
"0.5174565",
"0.5160427",
"0.51492006",
"0.5144736",
"0.513647... | 0.77558404 | 0 |
Run all the table creation SQL queries to ensure the expected tables exist | def init_tables(self) -> None:
with self.table_access_condition:
conn = self._get_connection()
conn.execute("PRAGMA foreign_keys = 1")
c = conn.cursor()
c.execute(tables.CREATE_STUDIES_TABLE)
c.execute(tables.CREATE_SUBMISSIONS_TABLE)
c.exe... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_tables(self):\n for query in table_create_sql:\n self.cursor.execute(query)\n\n self.commit()",
"def create_tables():\n db.create_all()",
"def create_tables():\n db.create_all()",
"def createTables():\n conn = getConnection()\n try:\n cur = conn.cursor()... | [
"0.8495893",
"0.7980632",
"0.7980632",
"0.7966904",
"0.79503256",
"0.7923164",
"0.7920233",
"0.7841086",
"0.78342694",
"0.7815559",
"0.77894527",
"0.77793336",
"0.77781737",
"0.7769905",
"0.77690786",
"0.77588534",
"0.77438813",
"0.77397835",
"0.77397835",
"0.77397835",
"0.77... | 0.7529499 | 34 |
Determine if a cached value from the given compare time is still valid | def is_study_mapping_in_sync(self, unit_id: str, compare_time: float):
return compare_time > self._last_study_mapping_update_times[unit_id] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def valid(t):\n return float(t) > time.time()",
"def is_cache_valid(self):\n if os.path.isfile(self.cache_filename):\n mod_time = os.path.getmtime(self.cache_filename)\n current_time = time()\n if (mod_time + self.cache_max_age) > current_time:\n return T... | [
"0.6786222",
"0.6448674",
"0.64324737",
"0.63750684",
"0.630569",
"0.63012683",
"0.6299927",
"0.6272141",
"0.6211941",
"0.6175154",
"0.61743593",
"0.61084133",
"0.6042745",
"0.6010127",
"0.6009563",
"0.60086095",
"0.6004558",
"0.59777814",
"0.5974766",
"0.5972415",
"0.5965831... | 0.0 | -1 |
Register a new Study mapping in the table | def new_study(
self,
prolific_study_id: str,
study_link: str,
duration_in_seconds: int,
task_run_id: str,
status: str = StudyStatus.UNPUBLISHED,
) -> None:
with self.table_access_condition, self._get_connection() as conn:
c = conn.cursor()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register(self, table_name, **fields):\n if table_name == 'groups':\n self.register_group(**fields)\n elif table_name == 'homework':\n self.register_homework(**fields)\n elif table_name == 'parents':\n self.register_parent(**fields)\n elif table_name ... | [
"0.5860516",
"0.5694577",
"0.56291115",
"0.5563596",
"0.5524145",
"0.54332376",
"0.5419561",
"0.5383397",
"0.5380749",
"0.5315402",
"0.52709424",
"0.5228869",
"0.5204167",
"0.5195095",
"0.5187756",
"0.5159983",
"0.51177984",
"0.5053667",
"0.5052416",
"0.50509524",
"0.50397503... | 0.47300953 | 73 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.